Nobody calls me to admire a system that’s working.

I’ve spent a little over two decades in enterprise product design — telecommunications, energy, healthcare, large-scale SaaS — and in that time my role has narrowed into something specific. I’m the outside expert who gets the call after the problem surfaces. To review the deck that didn’t land. To audit the architecture that quietly drifted. To trace the cost overrun back to its actual source.

So I’ve developed a strange professional intimacy with failure. I don’t see the optimistic kickoff. I see the inheritance — the thing already on fire by the time the phone rings.

My colleague Ralf Gehrig always says that in an age of effortless speed, the real differentiator is discipline. He’s right. But I’d add one thing from the enterprise trenches: discipline must be systematic with AI agents executing in the build pipeline. Meaning, discipline can no longer live only in the designer’s head. Agents don’t have judgment. They have instructions. So the discipline has to move out of the practitioner and into the architecture itself — encoded, governed, machine-readable.

That shift is the whole story. And the four fires I keep walking into are all the same fire, burning in the same place: the absence of an architecture that governs what gets built.

I INHERIT A DESIGN SYSTEM EVERYONE IS STILL TRYING TO FIX

Years ago, I sat across from the head of sales operations at one of the largest telecom carriers in the world, building a unified sales intelligence platform. The screens were good. Then he asked what the interface did when two subsidiaries were in active merger review while one of them was simultaneously mid-provision on a new contract.

I did not have a screen for that. Nobody had told me that state existed. There were eleven more conditions like that.

A design system is a library of answers to questions a human already thought to ask. But every enterprise runs on the states nobody named. A human builder hits one and asks a question. An agent doesn’t ask — it builds something, confidently, instantly, and wrong. The system wasn’t decaying, the comforting word that implies a refactor will fix it. It was obsolete. The polish was never the problem. The gaps were the problem — and agents find every gap you left.

→  Your Design System Is Not Decaying. It’s Obsolete.

I INHERIT AN AGENT WITH NO CONSTITUTION

A health insurer I worked with had four product squads — commercial, Medicare Advantage, Medicaid, and employer group — each owning an eligibility surface. Three had quietly forked from the central design system, because it was built for commercial display logic and couldn’t represent a Medicaid redetermination state. Then a regulatory update landed, and one forked view began showing a lapsed member as active.

That’s not a visual bug. That’s claims liability and compliance exposure, shipped at the speed of a deploy.

The instinct in the room is always give the agents better access to the design system. But the component library was never the missing piece. An agent handed a button and a color token still has no idea what a redetermination state is, or why getting it wrong is a regulated event. What it needs isn’t a richer library — it’s a constitution: a machine-readable set of rules about what is true, what is forbidden, and what each state means in consequence. Agents don’t need more assets to assemble. They need laws they cannot break.

→  AI Doesn’t Need a Better Design System. It Needs a Constitution.

I INHERIT AN OPERATOR IN THE EIGHTH HOUR

This is the failure that haunts me most, because the code was flawless.

A commodity trading operation. An operator eight hours into a shift, scanned a dense grid of vessel and terminal statuses. One terminal status resolved to the wrong visual weight — same as every other cell, because the architecture never encoded the distinction as meaningful. The operator’s eye slid past it. The vessel routed to a closed terminal. The demurrage clock started. A six-figure liability from a single missed signal in an otherwise perfect system.

A governed system can still fail the human sitting in front of it. We borrowed consumer-grade ideas — delight, minimalism, “clean” — and applied them to industrial problems where someone stares at one screen for 10 hours and any missed signal is a real number on a real invoice. The metric that matters here isn’t delight. It’s how long an operator can hold peak precision before fatigue starts manufacturing errors.

In the enterprise, friction is not an annoyance. It is a direct threat to margin.

→  Designing for the 8th Hour

I INHERIT A HANDOFF THAT’S STILL A SCREEN

So I’ll walk into all of the above, and someone hands me the proposed fix. It’s a Figma file. Beautiful redlines. Annotated screens, ready for engineering.

In an agentic pipeline, that file isn’t a deliverable. It’s a liability waiting for an interpreter — and the interpreter is now a machine that doesn’t interpret. It executes.

The new deliverable doesn't look like a screen at all. It looks like a document — markdown, a constraint file, what I call the Semantic Handoff — a spec the agent runs against rather than a picture a developer reads from. The design handoff doesn't get more organized. It gets replaced. The architect's value moves from producing the surface to authoring the law the surface is generated from.

The human role doesn’t disappear — it shifts from operating surfaces to governing what agents produced. EXA calls this the Reviewer Interface, purpose-built for one job: validating agentic output against the specification. Build it wrong and the human in the loop is ceremonial. Build it right and one architect governs everything fifty squads will ever ship.

→  The New Deliverable — Why Your Architect Writes Markdown