The Design System Is Not the Constraint. The Encoded Why Is

We have made an argument here more than once: the design system is the constraint layer that governs what AI produces. Encode the components, the tokens, the brand rules, and the agent has rails to run on. We still believe the artifact matters. A designer who lives inside the discipline has pushed on where it stops mattering, and the push is worth taking seriously.

Robin Cannon, writing in his Field Notes in January 2026, makes a claim that sounds like a contradiction of our thesis and is actually its maturation. His position: “AI doesn’t effectively recognize and implement components in isolation. What AI consumes, and amplifies, is context.” The design system, as most teams have built it, is a catalog of artifacts. Cannon argues that a catalog of artifacts is not a constraint. It is raw material the agent will happily misread.

Components in Isolation Produce Divergence

Here is the mechanism Cannon describes. A team has a mature design system. Buttons, cards, spacing scales, color tokens, all documented. An AI agent is asked to build a feature. It pulls the components, assembles something that passes every individual check, and ships. Then another agent, on another prompt, does the same for a neighboring feature. Both outputs are individually reasonable. Together they drift.

Cannon’s phrase for this is sharp: “AI creates divergence rather than coherence” when product context stays fragmented. The components are consistent. The product is not. Each localized prompt optimizes for its local task, and nothing in the component catalog encodes the reasoning that would keep the two features speaking the same language.

This is the part our earlier framing underweighted. A button component tells the agent what a button looks like. It does not tell the agent why this flow uses a destructive-action confirmation and the adjacent flow does not. It does not tell the agent that the empty state was deliberately understated because the team learned that loud empty states increased support tickets. The artifact carries the what. The why lives somewhere else, usually in a Slack thread, a closed ticket, or a designer’s head.

What AI Actually Consumes

When AI generates a design decision, it is not consulting your component library the way a developer imports a package. It is reading context and producing something plausible inside that context. If the context it receives is “here are the components,” it will produce something that uses the components and ignores the intent. If the context it receives includes the decision rationale, the exception justifications, the accessibility tradeoffs, the tone principles, and the governance boundaries, it produces something that holds together.

This reframes what a design-system team is for. The valuable artifact was never the Figma file. It was the accumulated reasoning that the Figma file represents: why this pattern won, where it is allowed to bend, what was rejected and on what evidence. Cannon’s reframed mandate for these teams is direct: “maintain intent, not artifacts,” and “define boundaries, not enforce consistency.”

That second phrase deserves a pause. Enforcing consistency is a losing game with AI in the loop, because the agent can generate a thousand consistent-looking surfaces faster than any reviewer can check them. Defining boundaries is a winning game, because boundaries are what the agent reads as context and applies at generation time, before the divergence happens.

Why This Sharpens Our Thesis Rather Than Breaking It

We have written that the style guide is a governance layer, and that design systems function as a documented census of governance decisions. Both claims hold. What Cannon adds is a precision we owed the reader: the governance lives in the documentation of intent, not in the inventory of components.

A team can have a flawless component library and zero captured rationale. That team has an artifact and no constraint. The agent will produce divergence with beautifully consistent buttons. Another team can have a messier component library and a disciplined practice of writing down why each decision was made, what it traded off, and where it is allowed to flex. That team has a real constraint layer, because the thing the agent reads at generation time actually steers it.

This is the same pattern we described when we argued that design without governance is decoration. A design system without captured reasoning is decoration with version control. It looks like governance. It enforces nothing the agent can use, because the agent does not consume artifacts, it consumes the why behind them.

The Capture Problem Is the Real Work

Most teams have not captured the why. They have captured the output. The decision rationale evaporated the moment the design was approved, because nobody had a reason to write it down when the only consumers were humans who attended the meeting. Humans carry context implicitly. They remember the support-ticket data that killed the loud empty state. AI carries nothing implicitly. It carries exactly what you wrote down and nothing more.

So the work shifts. The high-value activity for a design-system team operating with AI is no longer producing more components. It is interrogating every existing decision and asking: is the reasoning written down in a form an agent can read at generation time? The accessibility tradeoff, the rejected alternative, the boundary condition, the tone principle. These are the constraints. Everything else is reference material.

This is uncomfortable because it is slow and unglamorous. Capturing rationale feels like documentation overhead until the first time an agent ships a coherent feature without a designer in the loop, and the reason it was coherent is that the agent read the same boundaries the designer would have applied. That is the payoff. The artifact got the agent to plausible. The captured why got it to correct.

Do This Now

Pick one product surface where AI is already generating output. Audit it for divergence: not whether the components are consistent, but whether the decisions cohere. Where they do not, find the decision that should have governed and ask whether its reasoning exists in writing. If it lives in someone’s head or a closed thread, that is your missing constraint. Write the why, the boundary, and the rejected alternative into the context your agents actually read. Then check whether the next generation holds together. That single loop, run on one surface, tells you how much of your design system is constraint and how much is decoration.

---

This analysis synthesizes Design systems are over. Product context is the work (Robin Cannon, January 2026).

Victorino Group helps teams capture the decision rationale that makes AI output coherent at scale. Let’s talk.