The Substrate Adapts: Design Systems, Docs, and Judgment in the Agent Era

In a single week of late April 2026, three writers from three unrelated corners of the software world wrote essentially the same essay.

David Hoang argued that design systems are now inference systems. Simon Aronsson declared the end of “just ask Sarah.” Kent C. Dodds called judgment the last engineering skill that scales. Different vocabularies, different audiences, different domains. The convergence is the point.

Each was watching agents collide with the same kind of artifact. Tokens that hold values. Documentation that lives in heads. Implementation steps that used to be the work. And each came to the same conclusion: the artifact, as it stands, does not survive agents at scale. The substrate has to move up.

This is a substrate-level claim, not a design or docs or engineering claim. The thing under your team — the layer that quietly carried meaning across people, time, and context — is being asked to do a job it was never designed for. You don’t have a tooling problem. You have a substrate problem.

Three Writers, One Shift

Hoang’s argument is sharpest where it hurts most. In a static system, a design token like --brand-blue: #0066FF is enough. A human designer reads the name, infers the situation, and applies it correctly. An agent doesn’t have the same hallway context. When asked to design an unfamiliar layout, the agent has to make a defensible choice. #0066FF tells it what color to render. It tells it nothing about why.

Hoang’s prescription: tokens have to encode intent, not values. --color-interactive-primary is a defensible decision the agent can reason about. #0066FF is a paint chip. The agent doesn’t need a richer palette. It needs a richer ontology.

Aronsson is making the same move in documentation. His essay’s title is the diagnosis: “The End of Just Ask Sarah.” For two decades, healthy engineering teams ran on tribal knowledge. The senior who knew which service was load-bearing. The PM who remembered why the migration was paused. The on-call who understood that one alert was a false positive on Tuesdays. That knowledge lived between sessions, in human continuity.

Agents do not have continuity. Every session starts cold. The line that earns the essay its title: “the knowledge that used to live between sessions now has to live somewhere that survives the session ending.” If your team’s institutional knowledge was Sarah, your team’s institutional knowledge is now whatever Sarah’s successors can read into context. ADRs, runbooks, decision logs. Not because compliance asked. Because your agents will fail without them.

Dodds completes the triangle from the engineering side. As implementation cost collapses, the leverage moves up the stack. Writing the function is no longer where the difficulty lives. “When the cost of shooting drops, target selection matters more, not less.” The skill that compounds is not typing speed; it is the judgment to pick which problem deserves a function in the first place. Implementation is becoming a commodity the agent provides. The bottleneck is the human deciding what’s worth implementing.

Three domains. Three writers. One shift.

The Pattern Underneath

Strip the vocabulary and what remains is identical. In each case, a static substrate was good enough when humans carried the missing context in their heads. In each case, agents arrived without that context, and the substrate buckled.

The fix in each case is the same shape. Move what was implicit into the substrate itself.

Design: move from values to intent. The token has to carry the why.
Docs: move from tribal memory to recorded decisions. The ADR has to carry the rejected alternatives, not just the chosen one.
Judgment: move from “the team knows” to “the team writes down what it picks and why.” The decision log becomes the artifact.

This is not three trends. It is one trend with three faces. The substrate moved up, and you have to move with it.

The governance question follows. For most of the last decade, governance was a “rules” problem: enforce coding standards, enforce design tokens, enforce review gates. That framing was correct when implementation was the bottleneck. It is wrong now. The bottleneck moved up. Governance has to follow.

The new question is not “how do we enforce the rules” but “how do we maintain the substrate the agent needs to make defensible decisions.” Those are radically different jobs. The first is policing. The second is curation. Most teams are still staffed for the first.

Why This Hits Production

The reason this matters now, and not in eighteen months, is that the failure mode is not theoretical.

A team that has not promoted its tokens to intent will see the agent generate UI that is technically valid and contextually wrong. A team that has not codified its tribal knowledge will see the agent confidently break the load-bearing service no one ever wrote down. A team that has not recorded its judgment will see the agent solve the wrong problem at remarkable speed. None of these look like agent failures. They look like substrate failures the agent merely surfaces.

We have argued this before from the design angle in Design Systems Just Became AI Governance Infrastructure, and from the documentation angle in Codifying Institutional Intelligence. The convergence is what’s new. When three independent practitioners write the same essay in one week, the cost of treating each as a niche concern goes up.

This piece does not extend the design argument or the docs argument. It collapses them. Substrate is the noun.

What “Substrate Readiness” Actually Looks Like

The honest test is uncomfortable. Most teams will fail at least one of the three.

Audit the design substrate. Open your tokens file. Are the names paint chips or decisions? --brand-blue is a paint chip. --color-interactive-primary is a decision. If you cannot give an agent a layout it has never seen and trust it to pick the right token, your design system has not crossed over yet.

Audit the documentation substrate. Find the last three architecture decisions your team made. Is each one written down with the rejected alternatives included? Not the winner — the losers, and why they lost. The rejected alternatives are what carry intent forward. Without them, the next agent (or the next senior, six months from now) will re-litigate decisions that were already settled.

Audit the judgment substrate. Walk back the last month of your team’s roadmap. Where did target selection come from? If the answer is “the staff engineer’s intuition,” you do not have a judgment substrate. You have a single point of failure who has not yet been asked to scale across agents that copy their pattern but not their reasoning.

If any of those three audits fails, you have substrate work before you have agent work. The sequence matters. Putting agents on top of an unprepared substrate produces fast, confident, wrong output. The order is substrate first, agents second. Not the other way around.

What Survives

The pattern that survives the agent era is the one that puts intent into the substrate where humans, agents, and time can all read it. Tokens with names that explain themselves. ADRs that preserve what was rejected. Decision logs that record judgment as a first-class artifact instead of a private mental model.

This is not a new tooling stack. It is a new discipline applied to artifacts you already own. The work is unglamorous, the payoff is structural, and the cost of skipping it scales with how seriously your team plans to use agents.

Hoang, Aronsson, and Dodds were not coordinating. They did not need to. They were each looking at their own corner of the substrate and reporting what they saw. The same thing.

The substrate moved up, and you have to move with it.

Sources:

Hoang, David. “Design Systems are now Inference Systems.” Proof of Concept, April 2026.
Aronsson, Simon. “The End of Just Ask Sarah.” simme.dev, April 2026.
Dodds, Kent C. “The Last Software Engineer.” epicproduct.engineer, April 2026.

Victorino Group audits substrate readiness — design systems, docs, decision logs — for teams shipping AI agents into production. Let’s talk.