Designing with web standards: The playbook for this AI moment

The Standards Movement: A Blueprint for the AI Era

Standards come up from practitioners, not down from committees. A reasonable facsimile of L. Jeffrey Zeldman up top there. AI assisted.

Jeffrey Zeldman helped end the browser wars by making the case for standards. We are starting that journey again and we should follow his example.

Every team building with artificial intelligence right now believes it is working on a blank frontier. New interface, new rules, no map. That belief is wrong, and it is expensive. The cost is not hypothetical, and it shows up as rework, as users who never trust the tool, and products that age quickly.

It feels a lot like 1997, when the web was the wild west almost literally. The images in this post reflect that.

A handful of browsers each went their own way. Netscape Navigator, Internet Explorer, Opera, and the fading remains of Mosaic rendered the same page differently, each with its own proprietary tags, thinking they had invented sliced bread: Netscape, specifically Lou Montulli, gave you a <blink> tag, but he claims it was implemented by someone else. Microsoft answered with a scrolling <marquee>. No one wanted to take credit. Both quite honestly sucked, but it was early times so I won't blame Lou or Bill Gates (That might be the wrong one but who's looking?). A site built for one broke in the next, so designers rebuilt the same thing three times and called it a living.

Then a small group decided the chaos was a choice and not a fact of nature, and they made the case for standards. L. Jeffrey Zeldman was the lead pirate. In the theme of Fight Club, we have to keep saying his name to honor his contribution to the field. His name is Jeffrey Zeldman. Zeldman did not invent the specifications, he did something harder: He convinced an entire industry that shared conventions were worth fighting for, and he won. Zeldman changed the world with a stance, not a specification and we should thank him for it.

We are living through that moment again, this time for the interfaces we wrap around models, the skills we scaffold on top of them and representations they mean. The browsers have new names: ChatGPT, Claude, Gemini, and Copilot each handle the same task their own way, with their own conventions for parsing content, showing reasoning, citing a source, and asking permission before they act. There are no shared standards to make them consistent, so the patterns are unsettled, the vendors are playing jazz, and the window to shape the conventions is open.

We're in a revolution, as Dan Maccarone so correctly points out. It will not stay open long, so it is worth studying what Zeldman did, and asking what we can borrow. We really have to get this right.

The idea that outlived its technology: pull structure, presentation, and behavior into separate layers.

What Happened Before: Zeldman and the Fight for Web Standards

A Magazine and a Coalition

Start with who he is, because a surprising number of designers working today have never had to learn the name. The gap is wider than one name. Most designers now arrive in the field with no working knowledge of how its standards were won - who fought for them, against what, and why it mattered. I ask designers and get a lot of blank stares. That gap runs right up through the people teaching design, many of whom cannot pass on a history they were never handed themselves. A profession that forgets how it climbed out of its last mess is well positioned to climb back in.

So here is the history worth recovering.

Jeffrey Zeldman is, in the phrase Business Week gave him, the King of Web Standards. He has been publishing at his own site since the mid-1990s. In 1998 he founded A List Apart, the magazine for people who make websites, which became the place where the craft argued with itself and got better. That same year he co-founded the Web Standards Project, a grassroots coalition of designers and developers with an unglamorous goal: get the browser makers to support the same technologies the same way.

Note who he organized: the designers and developers who built the web, one page at a time. Other than my disagreements with him using really small type.

His other efforts:

• A List Apart gave them a place to argue and learn
• The Web Standards Project gave them a banner
• An Event Apart, which he co-founded in 2005, gave them a room to stand in together
• A Book Apart grew knowledge of the field by selling books

This was grassroots in the literal sense. The pressure came up from the people closest to the markup - the ones paying the daily tax of the chaos - rather than down from above.

The Browser Wars

That goal sounds small until you remember what it was up against. Browser makers treated the web as territory to capture, not a commons to tend. Microsoft and Netscape shipped incompatible features by design, because lock-in was the strategy. Zeldman and his collaborators spent years making the case, in public and in private, that this served no one over the long run - not users, not designers, not even the browser makers. Browser makers treated the web as territory to capture, not a commons to tend, and it showed up in the quality of their products.

The Argument That Outlasted the Tools

His 2003 book, Designing with Web Standards, was the argument in its most durable form and the first half was not aimed at developers at all. It was aimed at the people who sign the checks: here is why separating structure from presentation from behavior makes your site cheaper to build, faster to load, easier to maintain, and reachable by more people. The book is credited with moving the industry off tag soup and Flash and toward semantic markup and accessibility, and it ended up as a textbook in dozens of college programs.

Here is the part I keep coming back to. Zeldman's real achievement was never a specification, it was a shared belief that the web should work the same way for everyone, held widely enough that building any other way started to feel embarrassing. Standards won because enough people decided they should.

Design systems are the standards movement's direct descendant - shared parts, recombined.

Why It Matters: What the Standards Movement Won

So what did the standards movement win, and how did it win it? Three things worth stealing.

A semantic separation as a standard

The core move was to pull structure, presentation, and behavior into distinct layers so each could change without breaking the others. That one idea outlived every specific technology it was built on. It is why a design system works at all. When Brad Frost introduced atomic design, he was extending the same instinct: stop shipping pages, start composing interfaces from small, shared, recombinable parts.

Design systems are the standards movement's direct descendant, and they are the closest thing we have to a working model for AI interface conventions. Hold onto that frame, because it names the work: this is a design systems problem.

Documenting a pattern once and reusing it everywhere did not begin with atomic design, or even with the phrase "design system." erin malone built one of the first public pattern libraries at Yahoo in the mid-2000s and traced the whole lineage, from Chris Alexander forward, in A History of Patterns in User Experience Design. The industry already knows how to stop reinventing the same button. AI is that problem at a larger scale, and the answer is the same shape: a shared, documented, governed system instead of a fresh pile of one-offs per product.

A business case before the moral one

Zeldman did not lead with accessibility as a virtue, though he believed in it. He led with cost and reach, which was exactly the right lever: standards-based sites cost less to build, load faster, and reach more people. Accessibility came bundled with the economics, which is how it got adopted. Do it right, and you don't get sued.

If you want a convention to spread, make it cheap, not just the righteous. VHS won over Betamax for exactly that reason. That is the lever, and it is the one most AI teams are ignoring while they chase novelty. Simplicity wins, full stop.

A coalition, not a command

No one had the authority to mandate standards. The Web Standards Project had no power except persuasion, a body of shared work, and the patience to keep making the case until the browser makers found it easier to comply than resist. The standards did not come down from a committee; they came up from practitioners who agreed with each other, in public, until agreement became the default.

Put those wins next to the vocabulary the standards era produced, and you get a checklist. Every concept below was hard-won for the web, and each one now has an AI-shaped gap where the next convention belongs.

• Separation of concerns. Structure, presentation, and behavior became distinct layers. Keep a model's reasoning, its output, and its actions inspectable and separate, rather than fused into one opaque block of text.
• Accessibility. The web committed to working for the people the median design forgot. Extend that to AI - legible to assistive technology, honest about what the model cannot do, and usable when someone opts out of the automation.
• Semantic markup. Tags gave content meaning a machine could read. AI output needs the same: a claim, a citation, a guess, and an action should each be labeled and legible, not flattened into identical prose.
• Progressive enhancement. Pages worked without the fancy parts, then improved where support existed. AI features should degrade to a dependable path when the model is wrong, slow, or unsure, instead of collapsing.
• Responsive design. Layouts adapted to context instead of assuming one screen, the case Ethan Marcotte made in Responsive Web Design. Generative interfaces can adapt to task and person the same way, as long as the adaptation stays predictable.
• Interoperability. The whole point was that a page worked the same across browsers. The equivalent now is shared interaction patterns across assistants, so moving between tools does not mean relearning the rules every time.

Every vendor has invented its own gestures - the proprietary web, rebuilt for AI.

Why We Need It Now: The AI Interface Moment Is 1999 Again

Now look at where we are. Artificial intelligence has adoption numbers the standards movement could only dream of. ChatGPT alone reached eight hundred million weekly users in 2025, and inside companies the pattern holds: in OpenAI's own state of enterprise AI report, three in four workers said the tools improved the speed or quality of their output. The demand is not in question.

The interface is.

Jakob Nielsen has called this the first new user interface paradigm in sixty years - a shift from telling the computer how to do a thing to telling it what you want and letting it decide how. Nielsen is right, and that is exactly the problem. A new paradigm means some conventions are settled but not all. How should a model show its reasoning? How should it cite a source, signal how confident it is, or hand a task back to a person when it is out of its depth? Every product answers differently, and most answer badly.

That inconsistency carries a cost people are only starting to name. When every model formats its reasoning, its sources, and its confidence differently, you cannot line two answers up side by side - which is exactly what evaluation needs. Comparing answers across systems has become hard, and that is quietly degrading the evaluations teams rely on to know whether any of this is working. You end up grading the packaging instead of the answer.

This is 1999 wearing new clothes. Back then a site worked in one browser and broke in the next. Today a workflow works in one assistant and falls apart in another, because every vendor has invented its own gestures, its own affordances, its own quiet rules about what the machine will and will not do. We are pouring the same proprietary concrete, only faster and with more money behind it.

And the interface is only the visible half. Beneath it sits the scaffolding of skills - the reusable units of capability a model draws on, and the conventions for describing, discovering, and composing them. Every platform defines a skill its own way and wires up its tools on its own terms. One piece is further along than the rest: the Model Context Protocol became a cross-vendor standard for connecting models to tools in barely a year. That is the tell. The shape of the capability layer is being set right now, and most of it is still up for grabs.

The web had a single surface to tame: the page in a browser. AI is spreading across many at once - chat, voice, autonomous agents, assistants embedded in every application, and interfaces that assemble themselves on the fly. Every new surface is another place for conventions to fork, and another set of rules for people to relearn. This is the part the excitement obscures: new surfaces need standards more than ever, because the cost of getting them wrong now compounds across all of them.

Mobile is where this gets concrete. It is the surface most people live on, and the one where agents grow real teeth - booking, buying, and messaging across apps on your behalf, sometimes on standing permission. The AI inside mobile apps and the agents acting across them both need shared rules for consent, confidence, and handoff, or the most personal device becomes the most inconsistent one.

The lock-in logic is identical too. When your patterns are yours alone, switching costs go up and users get stranded. What looked like a moat in 1999 became a liability the moment standards made the rest of the web interoperable. That reckoning is coming for AI interfaces. The only question is whether designers shape it or inherit it.

The same story, twenty years apart - a tangle of incompatibilities, a window of opportunity, and a choice about what comes next.