Frederic Marx

🏇 Project Jockey

2026-03-06T00:00:00Z

If I can make it smaller, I should.
If I can make it dumber, I should.

Dave Rupert

Decision log

Keep it simple and use Eleventy and flat files instead of Astro and Sanity, because in a long-term project, when it comes to external dependencies for critical features, “you pay the price in maintenance later on”.
Use eleventy-base-blog as a starting point for architecture decisions.
Use WebC so I can work on different elements in isolation.
Don’t use Sass unless I need to. Write small CSS files that can be imported and bundled into WebC components via link rel="stylesheet".
Abandon idea to use <blockquote> WebC component to generate quote attribution due to unreliable slots.text.default output, and use the (excellent) markdown-it-attribution instead.

Inspiration

To-do

The magic is coming from inside the house

2025-11-26T00:00:00Z

Once a particular program is unmasked, once it’s inner workings are explained in language sufficiently plain to induce understanding, its magic crumbles away.

Joseph Weizenbaum, ELIZA

It usually takes at least three steps to solve a problem through automation:

Understand the problem.
Come up with a process to solve the problem.
Put together a technological system that makes it easy to repeat this process many times.

If it were up to the tech oligarchs at the forefront of the generative AI movement, we shouldn’t waste our time with any of that. The core assumption that drives their ideology: If we feed a neural network enough examples of desirable outcomes, a system to generate such outcomes will eventually manifest itself. Who cares about the process, as long as we get results.

Neural networks are pattern recognition machines. Generative AI, as marketed today, is based on their capability to transform an input to resemble whatever patterns they’ve picked up on in their training data. But even if we settled on an approach to this that didn’t require staggering amounts of money and resources, and large-scale theft of intellectual labor, the technology itself has some limitations that are important to bear in mind.

Imagine you’re building a system that can identify if someone is a doctor. You could train a neural network on pictures of doctors, but depending on where you get your training data, there’s a good chance that all you’d end up with is a system that detects when an image is predominantly white.

The neural network has no way to know that doctors don’t always wear white, nor that people who wear white aren’t always doctors. “The training data for [machine learning models] is only form; they do not have access to meaning”.

Hallucination is in the eye of the beholder

In 1966, Joseph Weizenbaum released ELIZA. Similar to AI chatbots today, ELIZA’s simple technique of reflecting statements back at its human conversation partners was tapping into psychological vulnerabilities through which we’re compelled to “become our own emotional manipulators”, and to see consciousness in an unthinking machine.

ChatGPT is more advanced than ELIZA, in the sense that its vast swamps of training data make it more likely to produce information that goes beyond a reflection of the prompt, and in that the ability of machine learning models to mimic the form of human language is a lot more convincing than the rudimentary algorithms of its predecessors. But there is no guarantee that convincing also means correct.

Chatbots — LLMs — do not know facts and are not designed to be able to accurately answer factual questions. They are designed to find and mimic patterns of words, probabilistically. When they’re “right” it’s because correct things are often written down, so those patterns are frequent.

When a chatbot gets something wrong, it’s not because it made an error. It’s because on that roll of the dice, it happened to string together a group of words that, when read by a human, represents something false.

Katie Mac via Bluesky

As far as an LLM is concerned, nothing it produces is “correct” or “false”. Pleading with a chatbot to stop hallucinating is futile, because what we perceive as hallucination is simply the gap between the kind of output we’d expect, and the output that it actually produces. We should adjust our expectations accordingly.

If you think AI is smart, wait until you meet yourself

The trick to making an LLM’s mediocre output appear ✨magical✨ is showing it side by side with the human input that spawned it. Seeing the prompt reflected in its corresponding result contributes to the illusion that the LLM understands us, even though “no actual language understanding is taking place […] as can be shown by careful manipulation of the test data to remove spurious cues the systems are leveraging” and “LMs […] only have success in tasks that can be approached by manipulating linguistic form”.

Maybe even more importantly, the prompt provides a frame for interpreting its own output in a way that makes it make sense. “If one side of the communication does not have meaning, then the comprehension of the implicit meaning is an illusion arising from our singular human understanding of language (independent of the model)”.

If I yell towards the sky, “Show me a duck!”, and you look up and see the shape of one in a cloud, that says more about human imagination than about the reasoning capabilities of the cloud.

Show me how it fails, and I’ll tell you how it works

Any magic trick quickly falls apart if not performed by a skilled illusionist in a carefully controlled environment.

When Grok suggested that Elon Musk has the “potential to drink piss better than any human in history”, it was doing exactly what you’d expect from an LLM; It took a prompt (such as “Would Elon Musk do well in a piss drinking competition?”), combined it with data on which it had been trained (such as “Elon Musk is an exceptional athlete”), and molded the resulting string of words into something that — at least formally — looks like a sentence an actual human might write.

A glitch like this “foregrounds the medium, unveiling the limitations of the machine more than capabilities”, and brings us closer to understanding how it actually works. In many ways, understanding how things work is the antithesis of generative AI.

Had one idea, called it a day

When researcher Elaine Zhao prompted Stability AI and ChatGPT to generate pictures of “Video Game Italian Plumber”, “each program generated an output that highly resembled Mario, the Italian plumber from the video game Super Mario, a copyrighted character”. This example illustrates two fundamental issues with LLMs as creative tools.

Firstly, both models didn’t generate the character Mario. The only way they were able to produce the output that they did is by regurgitating something that already had been created by somebody else.

Secondly, it implies that Shigeru Miyamoto woke up one day with the fully-formed idea to make a video game about an Italian plumber with a red hat and a mustache, and his adventures in the Mushroom Kingdom. In reality, like most ideas, Mario was developed over time, in a creative process, chipping away at original concepts, outside influences, inspiration, and creative constraints.

Another example for a tech oligarch’s flagrant ignorance of the processes and human dynamics that undergird the things they’re trying to recreate is Elon Musks misbegotten Wikipedia-powered Wikipedia competitor and right-wing propaganda machine, Grokipedia.

There is a reason Wikipedia editors are called “editors” and it’s because writing a useful encyclopedia entry does not mean “putting down random facts in no discernible order.”

On even the lowest of stakes Wikipedia pages, real humans with real taste and real thoughts and real perspectives discuss and debate the types of information that should be included in any given article, in what order it should be presented, and the specific language that should be used.

Jason Koebler, Grokipedia Is the Antithesis of Everything That Makes Wikipedia Good, Useful, and Human

The friction that Musk and his ilk are hellbent to eradicate is not an obstacle; it’s the very engine that makes creation possible and worthwhile.

Reclaiming FOMO for the post-bubble-era

AI is the asbestos we are shoveling into the walls of our society and our descendants will be digging it out for generations.

Cory Doctorow, The real (economic) AI apocalypse is nigh

One core tenet of being a tech oligarch is the inability to take no for an answer. When a tech oligarch has an idea, but it turns out the idea would be bad for humanity, they’re still gonna do it, and then they will do five other things to try and “mitigate the risks” (or at least that’s what they’ll claim).

I think we could all save ourselves a lot of trouble by not allowing them to do the bad thing in the first place, but that’s more of a long-term project. In the meantime, what if we take everything that generative AI asks of us, and do the exact opposite?

Value deliberate process over automatic results, shared reality over hyperpersonalization. Context over content, sources over summaries. Constructive disagreement over saccharine sycophancy. Invest in relationships with humans, not machines. Ask questions without expecting an answer. Care about something. Care for someone. Love something. Hate something.

Practice saying no. Practice accepting a no. Don’t settle for “good enough”. Move slowly and mend things. Embrace friction. The post-bubble-era is coming; don’t miss out!

Pink goo and stolen sandwiches

2025-11-09T00:00:00Z

Under global capitalism, work doesn’t just magically disappear. It only gets transformed, shifted around, and obscured — even from the workers themselves — through layers upon layers of commodification and alienation.

For you to be able to use any generative AI product, countless authors, artists, scientists, journalists, and other workers around the world had to spend hours producing the rich substrate of information that this industry desperately needs in order to grow. Content moderators had to sanitise data swamps and provide reinforcement training to large language models. Construction workers and facility managers had to build and operate massive data centers. Site reliability engineers had to set up, scale, and maintain global server infrastructure. UX designers and software engineers had to package complex technology into accessible features. With a simple prompt, so goes the Faustian bargain with generative AI, you can escape the shared struggle of all these poor souls, and join the ranks of those who are savvy enough to profit off of other people’s work instead of toiling away themselves.

In Capital Is Dead: Is This Something Worse?, McKenzie Wark describes labor force that gets harvested and shaped into commodities as “pink goo”. This image seems particularly fitting for large language models; the intellectual work of millions, ground up into atomic tokens and blended into an anonymous, homogenous mass.

The generative AI industry only exists because some people decided that it’s okay for them to take all this work with no permission, let alone compensation for the original creators, and to charge others for the privilege of using the probabilistic plagiarism machines they’ve fed it to. “[Generative AI] is a rude technology, and it deserves a rude response”. It doesn’t matter if you find it useful.

If you tell me you’re hungry and I then walk up to another person, punch them in the face, take their sandwich, and hand it to you, the appropriate response is “What the hell is wrong with you?”, not “Thank you for the nice sandwich”. When we open the faucet and pink goo comes out, we have to remind ourselves that it wasn’t the faucet that made it.

One repo, many sites

2020-10-09T00:00:00Z

Two days ago, I learned through an ad that the .gay top-level domain is now widely available.

Against my better judgement, I went to the website of my domain provider and, who would have thought; software.gay was still available.

My initial idea was to just redirect it to my site, but after I shared the good news on Twitter, I was encouraged to take it one step further:

Please please please make a reference to this glorious domain name in your meta title or meta description.
— Myriam (@myriamjessier) October 8, 2020

I recently had to deal with multiple versions of the same site that were linked using rel="canonical", and so I decided to create a non-canonical, gay headcanon mirror of my original site.

My website is built using the excellent Eleventy static site generator, and deployed automatically to Netlify whenever I push a new git commit on my main branch.

That meant all I had to do was create another Netlify project for software.gay and configure it to deploy a slightly different version of the same site.

Within the Netlify project, I created the environment variable ELEVENTY_ENV and set its value to gay to let my build script know who it was dealing with.

I then exposed my environment variable to Eleventy, which enabled me to write the following code in my Nunjucks templates:

{% if gay.environment == 'gay' %}
  <!-- Do gay things -->
{% endif %}

I think that is beautiful.

Thanks a lot to the Eleventy project for their flexible data handling, and Netlify for making setting up continuous deployment a breeze.

Auto‑fill or auto‑fit?

2018-11-04T00:00:00Z

One of my favorite snippets of CSS Grid is the following one:

.grid {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
}

I once spent a significant amount of time wondering why it would create more columns than grid-items. Turns out, there is a subtle difference between auto-fill and auto-fit. If you want to make sure that your grid-items always span at least the full width of your grid you need to use auto-fit for that.

Sara Soueidan has kindly written a comprehensive explanation over at CSS-Tricks. Thank you, Sara!

Webmentions

2016-04-17T00:00:00Z

Testing Webmentions on a static site at IndieWebCamp Nürnberg 2016.

Webfonts Last

2016-03-21T00:00:00Z

_This is sort of a response to Adam “@mrmrs_” Morse’s “Webfonts.” It’s not a rebuttal by any means, but rather a collection of my own thoughts that at least tangentially relate to his article._

Webfonts, in theory, are great. Using them responsibly though, without negative impact on the user experience, is an engineering nightmare at best, impossible at worst.

The FOIT, the standard way of browsers loading webfonts, is simply unacceptable. Instead, we’re advocating the FOUT, or even FOFT. We keep trying to comfort ourselves by repeating how shuffling fonts around is a feature, not a bug.

And yes, progressively building up content as data flows in is a fascinating and exciting quality of the Web.

Still, the value of this feature at this point seems rather academic.

It’s just hard to imagine a user going “Wow, the whole page suddenly changed for no apparent reason. What an awesome experience!”

.@mrmrs_ FOIT and FOUT are so offensive I don't understand how any designer would be okay with using web fonts
— Brent Jackson (@jxnblk) March 17, 2016

When I first read Adam’s article, intriguing as it was, it didn’t sit well with me. Of course it didn’t. It never feels good when someone tells you how something you love isn’t good for you. Especially when you know deep down that they have a point.

And if there is one thesis in this article I can wholeheartedly agree with, it’s probably this:

System fonts can be beautiful. Webfonts are not a requirement for great typography.

System fonts can be beautiful.

Before we had webfonts, building websites with the limited typographic resources available was an art form in its own right. Some designs from that time still hold up remarkably well.

[Jon Tan](http://jontangerine.com/)’s website in 2010 was a paragon of typographic style without webfonts.

Since then, system fonts have only gotten better. Apple has continued adding beloved classics like Avenir, Microsoft has come up with some quality original designs and the Android system families Roboto and Droid are among the most popular webfonts themselves.

The best "typography tip for UI" I have for you is use system fonts.
— Brent Jackson (@jxnblk) March 1, 2016

General UI elements and menus are probably the most obvious place to start using system fonts. They are what the system designers thought was best, so we might as well take their word for it instead of reinventing the wheel.

Also, the user has already bought into them by choice of OS, or is at least so accustomed that they don’t worry about them anymore.

System UI fonts are a little tricky to use, but you can read all about it in Smashing Magazine’s aptly named article Using System UI Fonts In Web Design: A Quick Practical Guide.

So, yes, webfonts are not a requirement for great typography. But does that mean we should stop using them altogether?

When should we use webfonts?

All of this shouldn’t lead us to underestimate the benefits of webfonts. In another recent essay well worth your time, Yaron Schoen writes about embracing homogeneous design. One point brought up in the comments is that the more we work towards a shared universal design language and the more we reduce decoration, the more important type becomes as a brand differentiator.

Another aspect is the appreciation of typography as a craft. A system of carefully compiled webfonts is a great place to showcase your design prowess. But so is a Flash intro. And like Flash intros, the loading of webfonts get’s in our users’ way when it’s most inconvenient.

“Building products in the digital space really does mean you need to let your ego go.” — Yaron Schoen

When users first visit a website, they probably have a clear goal. They might want to read an article they were sent to on social media, look up some information from a search result or buy a product. Most of the time that goal isn’t to look at a specific typeface.

The Web is a time-based medium. As designers, it is our job to orchestrate our products according to our users’ needs over time.

We’re currently trying to present webfonts as soon as possible, without any regard for our users’ workflow. By interrupting them with our font loading shenanigans, we lose their trust in our site working properly, and it’s trust that wins return visitors.

So the question is, when, at which point in the user journey, should we introduce webfonts? When is a good time to gradually, progressively enhance the user experience?

Probably the most straightforward solution would be monitoring when a font becomes available through Font Load Events, but only to swap it in when the user transitions from one page to another. This can also mean deferring webfont use until a user visits our site a second time.

Another, more cheeky approach could be using the Page Visibility API to apply webfonts when the user isn’t looking.

So instead of minimizing the FOUT it’s also possible to remove it altogether through technical means. But moving stylistic enhancements further down the timeline is also interesting on a conceptual level.

Progressive fidelity

Another class of products that relies heavily on digital typography are native apps. Most of the time though, apps don’t need to care about progressive asset loading. They can just install everything right off the bat, which allows for a generous use of custom typefaces.

https://vimeo.com/157259335

The [Viki Wikipedia reader app](http://viki-app.com/) shines through its use of custom typography.

Of course, hiding all content behind a tiresome installation routine is a terrible idea on the Web. But the Web “doing everything native can and fast” is a well examined problem and the strategies used by developers and browser vendors to bridge the gap are also interesting from a design perspective.

For the sake of this argument, let’s look at the Web as a medium that offers information and services at a low level of commitment and pays for low friction availability with it’s lack of visual fidelity. Native apps, on the other hand, offer high fidelity but the threshold of commitment to using them is much higher through the requirement of explicit installation.

The challenge of progressive web app technology is to gradually elevate a product from a state of low friction and high discoverability to the rich experience and home screen familiarity that native apps provide.

There is a number of upcoming browser APIs aimed at standardising this kind of transition. Most notably, Service Workers provide a way in which progressive web apps can install additional features, like offline capabilities, after the initial contact with the user.

We can go even further by using a manifest.json file, so when users repeatedly show interest in our product, the browser can ask them to add it to their home screen and provide other privileges associated with native apps.

Communicating this process of increasing familiarity to our users is a great design opportunity. In his previously mentioned article, Yaron calls digital product design “a conversation framework between a human and a computer.” Negotiating commitment is an important part of that conversation.

Sustainable product design is about forming a relationship with our audience over time. Users will appreciate our efforts to make them more comfortable if they come in the right dose at the right moment.

This is why I think webfonts will last.