Code is cheap. Intent is not.
A coding agent writes a landing page in a minute. Ask it again tomorrow and it writes a different one, just as good, and neither is your brand.
Producing code keeps getting cheaper. The value has moved to what code never held: saying what you want, handing it to an agent, and keeping it from one session to the next. We call the result slot-machine design. Every pull can pay out a great landing page, and the next pull is someone else's brand. Pulling more often, with longer prompts, never changes the odds, because nothing in the machine remembers what you chose.
Software got its infrastructure: version control, tests, review. Design for agents gets it from Briefatto Lab, and we built Briefatto Board around this one problem.
Where intent leaks
Between a person's idea and the design that ships, intent passes through four steps, and it loses something at every handover.
| Step | What it holds | Loss on the way in |
|---|---|---|
| Human intent | What the person sees in their head | |
| Design brief | That intent put into words | Loss of expression |
| Agent's interpretation | The brief as the model reads it | Loss of understanding |
| Rendered design | The pixels that ship | Loss in execution |
Then the session ends. The next one starts from the brief and drifts further from the last. That is the loss of continuity, and it compounds.
A better prompt reaches the loss of expression and nothing else. A better model narrows the losses of understanding and execution and still starts every session from zero, which is why the effort to make agents better designers never reaches continuity.
Designers solved this with pictures
Designers pinned up references and watched what the client reacted to, then drew directions on the real formats and laid them side by side. The client looked, pointed at one picture and said "this one". From that moment the designer wrote the brand guide and held every later piece to it.
Briefatto Board turns that practice into the protocol an agent runs.
board refsbuilds a reference sheet. The client says which parts to work from.board directionsrenders three distinct directions on the canvases the audience will see.- The client picks one, and their exact approval is recorded with it.
board freezewrites a versioned DESIGN.md: the agent's prose, plus the brand's source wording and the exact styles measured from a fresh render.board statusandboard diffshow which pieces follow the current brand and what changed.
Each step answers one loss: references answer expression, pictures and a pick answer understanding, the floor answers execution, and freezing with versions answers continuity.
Taste belongs to the model
We leave every aesthetic call to the model inside your coding agent. That model gets stronger every year, and we built the board so each of those gains lands in your design.
A fixed taste rubric would throw that away. It caps the model at the taste of whoever wrote the rules, so a stronger model ends up spending its strength on an older model's checklist. The rubric also becomes the target. Agents optimise what they are scored on, which is Goodhart's law, and the piece that comes out passes every score after losing what made it good. Put a scorecard on a slot machine and all you get is a rule for which pulls to keep.
So the board gives the model what a great designer gives a strong colleague: the brief, the references, the client's pick and the brand guide. Then the model designs, and the people who use the picture judge it whole.
The floor belongs to code
A headline cut off at the edge is wrong in every style, and so is a fallback font where the brand face belongs, or grey text nobody can read. None of that is a matter of taste.
board check renders every piece in a real browser and fails it for text that is clipped, off the canvas, over other text or too small at the size it is seen; for fonts that never loaded; for contrast below WCAG; and for the anti-patterns found by Impeccable's open-source detector. It checks the brand name and the brief's required copy. For delivery, every exported PNG and PDF is decoded and compared pixel by pixel with its editable HTML source.
These checks are objective and hold for every model that will ever exist, so when models improve, nothing in the floor is rewritten.
One brand across every agent
A design system's first reader is now an agent, which executes it on every piece it makes. That turns the guide into a production protocol, and a protocol reads the same in every session, month after month. The board gives Claude Code, Codex, Cursor, Copilot and Gemini CLI one DESIGN.md to read before any visual work, and each piece declares the brand version it was made under. After a brand change, board status names the stale pieces.
The repository is the brand system
DESIGN.md is a versioned file in your repo, next to the code it styles, and Git is the collaboration layer. Review, pull requests, permissions and history apply to the brand exactly as they apply to code.
That makes a brand change a pull request. The reviewer reads the new guide, board diff shows what moved, and board log records the decision. A brand change goes through review like any code change.
The result
In a blind test on the open-source project Issue Composer, all four judges ranked the Briefatto Board kit first overall, ahead of Impeccable, Taste Skill and Hallmark. See every kit side by side.
Our kit carried no taste rubric. The model made every call, with a brand it had to hold and a floor it could not fall through.
Questions and answers
What is the intent gap in AI design?
It is the distance between what a person wants and what an agent ships. Intent leaks when it is put into words, when the agent reads those words, when the design is rendered, and again every time a new session starts from zero. Briefatto Board closes it the way designers always have: references, directions drawn as pictures, a pick, and then a frozen, versioned DESIGN.md.
Does Briefatto Board score aesthetics?
No. Your coding agent's model makes the aesthetic calls, and it gets better every year. A taste score would cap it at the rule-writer's taste and hand the agent a target to game. The board checks only what code can prove: text fit, loaded fonts, WCAG contrast, Impeccable's anti-pattern rules and exported files that match their source.
What does board check verify?
It renders each piece in a real browser and fails text that is clipped, off the canvas, overlapping or too small where it is seen, fonts that never loaded, contrast below WCAG, and Impeccable's anti-patterns. It checks the brand name and the brief's required copy, and it compares every exported PNG and PDF pixel by pixel with its HTML source.
How do teams collaborate on a DESIGN.md?
The same way they collaborate on code, with Git. DESIGN.md is a versioned file in the repository, so review, pull requests, permissions and history all work on the brand. board freeze stamps each brand version, board diff shows what changed, board log records the decision, and board status names the pieces still on an older version.
How does Briefatto Board keep Claude Code, Codex, Cursor, Copilot and Gemini CLI on the same brand?
npx briefatto-board install adds a pointer to AGENTS.md and CLAUDE.md, so every agent reads the same frozen DESIGN.md before visual work. Each piece records the brand version it was made under, which means drift shows up in board status before a client ever sees it.
What happens to Briefatto Board as models get stronger?
It gets stronger with them. Taste lives in the model, so a better model makes better work under the same brand, and the floor checks what matters for every model, so nothing in the system has to be rewritten.