We have already argued that when an agent does the work, the interface it produces becomes disposable. The slide deck, the dashboard, the formatted report: these are renderings a human asked for, not the thing the agent reasoned about. That essay asked a question it deliberately left open. If the screen is no longer where the work happens, where does governance go?
This is the answer. Governance descends into the structured spec layer. The deck becomes output. The spec becomes the contract.
The Interface Was Always an Accident
Alejandro Gonzalez’s argument at Mozilla.ai is blunt: the interface is no longer the product. For thirty years we shipped software where the screen was the artifact. A spreadsheet was the cells you saw. A presentation was the slides you clicked through. A document was the page you scrolled. The structure underneath existed only to produce the view.
That arrangement was an accident of who the consumer was. Humans cannot read a binary representation of a financial model, so we wrapped it in a grid. Humans cannot reason about a narrative argument as a data structure, so we wrapped it in slides. The categories we treat as natural (slides, sheets, docs) are not laws of software. They are the residue of a single constraint: the reader had eyes and a cursor, and nothing else.
Remove that constraint and the categories dissolve. An agent does not need the grid. It does not click through slides. When an agent consumes a financial model, the grid is overhead it has to parse away before it can reason. The human-legible representation, the thing we spent thirty years optimizing, is now the worst possible input.
So the structure flips. The machine-readable representation stops being a byproduct of the view. It becomes the thing itself. The view becomes one of several possible renderings of it.
Five Parts of an Agent-Native System
Gonzalez does not leave this as a slogan. He decomposes an agent-native system into five parts, and the decomposition is where governance finds its new home.
First, a structured internal representation. The single source of truth, machine-readable, not bound to any one display format. This is the spec.
Second, renderers. These turn the spec into human views: a deck, a dashboard, a PDF. Plural and disposable. You generate them on demand and throw them away. The view is no longer precious because it is no longer the source.
Third, validators. These check the spec for coherence and safety before anything renders or executes. Is the model internally consistent? Does the plan violate a policy? Validators are not cosmetic; they are the gate.
Fourth, diff and approval systems. These make every change to the spec visible and reviewable. A human signs off on a structured change, not on a screenshot of a slide.
Fifth, legacy-format compatibility. The system can still emit a PowerPoint or an Excel file when a human or another tool demands one. Compatibility, not dependence.
Look at where the human sits in this list. Not at the renderer. The renderer is throwaway. The human sits at the validator and the approval gate, reviewing the spec. Governance did not disappear when the UI became disposable. It moved down a floor.
The Contract Has to Be Machine-Executable
The Mozilla.ai piece gives the systems frame. Allie Paschal’s work, asking whether we design for humans or machines, supplies the proof that this is buildable, not theoretical.
Her example is a Banner component. In the old world, a designer writes prose for the design system: “Use the error variant for critical, blocking messages. Use the warning variant for non-blocking issues the user should know about.” A human reads that, interprets it, and picks a variant. The prose is the spec, and it is unenforceable. Two designers read it two ways. An agent reads it and guesses.
Paschal’s move is to make variant resolution a logic table. The banner’s variant is a function of two inputs: message_type and user_impact. A blocking message with high user impact resolves to error. A non-blocking informational message resolves to info. The table is machine-executable. There is no interpretation left. Feed it the two inputs and the variant is determined.
That is what the spec layer looks like when you take it seriously. The design system is no longer prose a human is trusted to honor. It is a structure an agent executes and a validator can check. The question “did this banner pick the right variant?” stops being a code-review opinion and becomes a deterministic test against the table.
This is the same descent we have traced elsewhere. We argued that the design system becomes the enforcement layer for AI governance. Paschal shows the mechanism. Prose constraints fail as agent inputs because agents do not honor intent; they execute structure. So the constraint has to become structure. The rule has to be codeable, or it is not a rule.
Where Coherence, Safety, and Sign-Off Now Live
Put the two pieces together and the new map is clear.
Coherence used to live on the screen. A reviewer looked at the deck and felt whether the story held together. Now coherence lives in the validator. The spec either passes the consistency check or it does not, and the check runs before any deck exists.
Safety used to live in a human’s judgment at the moment of presentation. Someone caught the slide that leaked a customer name or the dashboard that exposed a number it should not. Now safety lives in the validator and the policy gate. The check fires against the spec, not against the rendering, which means it fires once, deterministically, instead of being re-litigated every time someone regenerates the view.
Human sign-off used to be approval of an artifact: you signed off on this version of the deck. Now sign-off is approval of a diff against the spec. You are not approving pixels. You are approving a structured change, with its provenance and its before-and-after visible. This is the same principle we described when we argued that the company itself becomes a governance layer expressed as code. The thing you govern is the structure, not its appearance.
The screen does not vanish. People still need to look at things. But the screen stops being the checkpoint. You cannot govern at the renderer because the renderer is disposable and plural. You govern at the one place that is singular and authoritative: the spec.
What This Costs, and What It Buys
There is a real cost. Writing a validator is harder than eyeballing a slide. Encoding a design rule as a logic table is more work than writing a sentence about it. Many teams will resist because the prose version feels finished and the structured version feels like extra engineering.
But the prose version was never finished. It was unenforceable, and we tolerated that because a human was always in the loop to interpret it. Remove the human from the loop, hand the prose to an agent, and the absence of structure becomes a live failure mode. The agent does not interpret your intent. It acts on what is actually written down. If what is written down is “use good judgment,” the agent has no judgment to use.
What you buy is governance that scales without a human at every render. The validator runs a thousand times for free. The logic table resolves a million banners identically. The diff makes every change auditable whether a human or an agent made it. That is the trade: more work up front in the spec, far less work per artifact, and a checkpoint that does not depend on someone being awake to catch the bad slide.
Do This Now
Pick one artifact your team produces that an agent now touches. A deck, a report, a configured component, anything an agent generates or modifies.
Ask three questions. What is the structured representation underneath it, and is that representation the source of truth or just a byproduct of the view? Where is the rule that says what makes this artifact correct, and is that rule prose a human interprets or a structure a machine can check? When a change happens, do you review the rendered output or the structured diff?
If the rule lives in prose and the review happens on the screen, your governance is sitting on the disposable floor. Move it down. Write one validator. Turn one prose constraint into one logic table. Review one diff instead of one rendering. You are not adding bureaucracy. You are relocating the checkpoint to the only floor that is still load-bearing once the agent skips the UI.
This analysis synthesizes The Interface Is No Longer the Product (Mozilla.ai, May 2026), Should I Design for Humans or Machines? (UX Collective, May 2026).
Victorino Group helps teams move governance into the spec layer where agents actually operate. Let’s talk.
All articles on The Thinking Wire are written with the assistance of Anthropic's Opus LLM. Each piece goes through multi-agent research to verify facts and surface contradictions, followed by human review and approval before publication. If you find any inaccurate information or wish to contact our editorial team, please reach out at editorial@victorinollc.com . About The Thinking Wire →
If this resonates, let's talk
We help companies implement AI without losing control.
Schedule a Conversation