Agents build the screens. Models write the sentences. Fourteen slides on the one governed system that keeps a product recognizably, accountably itself while both generators work.
Coherence used to arrive as a side effect of scarcity: every surface passed through a person who knew what the product stood for. AI removed that bottleneck twice, at design time and at runtime. No reviewer will see most of what a generative product shows its customers.
An agent in the repository produces the screens; a model inside the product produces the sentences, and increasingly the interface itself. Both are fluent. Neither knows what the product must never say.
Tokens, behaviors, brand contracts, profiles, and evaluations, written down in one repository, compiled into every generator's context before it works and checked by validators after. Pay for coherence once; collect it at both moments.
Screens and sentences were scarce; the people producing them carried the brand in their heads
The style guide was a reminder of judgments transmitted person to person
Slow, expensive, and reliable, because nothing shipped untouched
One prompt per feature, copied and edited: eleven personalities, none of them chosen
Every generated screen slightly different from its siblings; each difference defensible, the sum incoherent
Most surfaces did not exist until the moment they were shown; nobody signed off
Machines handle divergence, generating options in minutes. Humans own convergence: the choice and the reasons for it. A team that accepts the first plausible output has not automated design; it has abandoned it.
| Old unit | New unit | Why it matters |
|---|---|---|
| Screen | Behavior | The surface is generated per person and per channel; only the behavior is stable enough to design |
| Style guide | Governed context | Taste the generator reads before producing beats taste a reviewer applies after |
| Handoff | Pull request | The design and its specification become the same artifact, one merge from shipping |
| Brand review | Contracts & evals | Coherence gets checked by the system on every generation, not remembered by the team on some |
Nothing is maintained by remembering to maintain it: the guide site, the exported specs, and the agent's instructions are all generated from the same source.
Three layers: primitives name what exists, semantics name what things mean, component tokens name exceptions. Generators touch only the semantic layer.
The verbs of interface: Explain, Clarify, Confirm, Compare, Recommend, Repair, Warn. Each defines required facts, allowed actions, and evals, on no particular surface.
Voice moved from adjectives to constraints: tone by context, terminology, and the never-say list. The brand file teaches the generator; the contract checks its work.
Behavior localization (pacing, directness, formality) and renderer contracts that test placement and reachability per channel, with a plain deterministic fallback.
Taste written as executable rubrics attached to behaviors, and a replayable record of every governed turn for the day someone asks why.
Both exist to solve the same problem: a fluent generator that must be briefed before it works and bound while it works. The two share their load-bearing walls, so coherence is paid for once.
| Function | Design time (the repo) | Runtime (the product) |
|---|---|---|
| Brief the generator | Agent instructions and skill files, compiled per task | Context compiler admitting facts with provenance |
| Bound the actions | Review gates, branch rules, protected paths | Action contracts and the authority graph |
| Check the output | Hooks, audits, and evals on the diff | Validators on the rendered turn |
| Keep the evidence | Decision log, changelog, git history | Replayable traces of every governed turn |
One designer owns the flow; the system owns the coherence. A flow is not done until every state exists: happy, empty, error, loading, and the 375-pixel screen.
The agent loads instructions, brand skill, tokens, behaviors, and the decision log before generating
Five directions in minutes. One option is not a decision; it is an acceptance
The designer picks, blends, and writes two sentences on why. The why lands in the log
The behavior joins the vocabulary with contracts, a repair path, and a plain fallback
Two-layer accessibility pass; evals run against twenty generated variants. Failures tighten the contract, not the prose
The diff is the design, the PR description is the brief. Nobody translates anything
Runtime conversations compile the same brand file the agent read on Tuesday, and leave a replayable record
Every substantial piece of work gets options before commitment and a structured critique against written criteria. A different model makes a usefully disagreeable second reviewer: it shares none of the first one's habits.
An eval is taste written down and attached to a behavior: fee stated before consent, no apology openings, warning salience proportional to the money at risk. Checkable across a hundred variants, the only scale that now matters.
A variant that converts beautifully while breaching a disclosure rule is not a winner; it is an incident with good numbers. Evals gate what enters the test at all.
What was decided, what was rejected, and why, in two or three sentences, written where the work happens. The artifacts carry the design; the log carries its reasons.
Someone owns the tokens, someone the behavior vocabulary, someone the contracts with legal weight. Standardize the artifacts, not the tools; every designer keeps the harness that makes them fast.
A new designer who reads the decisions, the brand file, and the behavior vocabulary absorbs the team's taste in an afternoon, because for once it is written down.
Chapter 12 breaks the system on purpose, with a failure assembled entirely from defensible decisions: a skipped options pass, an unregistered behavior variant, a small PR reviewed for performance. For eleven days, one surface collected consent before stating its price.
One behavior variant on one surface, not a personality drift across the product, because everything else was contract-bound
Caught in the weekly screen-level audit, not in a courtroom; the trace answered why in minutes
The postmortem produced a rule, the rule became a hook, and the hook removed the option of forgetting
Voice, tone by context, and the never-say list, in a file the agent reads before generating. Costs an afternoon; changes the next morning's output.
One semantic token set as the only visual truth. A generator that touches only the semantic layer keeps a thousand screens siblings.
An instructions file with the absolute rules. Preferences live there; invariants become hooks that fire every time.
Two sentences at every convergence: what was decided, what was rejected, why. The log becomes the onboarding.
Pick the one behavior that can do harm and write its rubric. Contracts, profiles, and traces follow as exposure grows.