Design OS
Three systems · One standard
Quality that holds.
Without you in the room.
An AI-native layer a design team works on, where the standard is enforced by the system rather than by the seniority of whoever happens to be in the room — a reviewer that shows its evidence, a relay that routes work to whichever model is better at it, and a pipeline that won’t let anything advance unproven.
My role — Creator
The gap between a junior and a lead shows up in the artifacts. That’s the real target.
When a design team is asked to “use more AI”, the easy reading is to democratize design or automate it away. I took a narrower view: find the repetitive, low-judgment work AI should absorb, and make the output consistent. Because there is a structural version of the same problem — designers sit between product management and front-end engineering, close enough to contribute to both and walled off from both. Every handoff becomes a translation tax: designers describe, PMs re-document, engineers re-interpret. Quality leaks at each seam, and varies with each person.
Failure A — In the seams
Every handoff is a translation tax
I surveyed the team before assuming where the friction was. 83% named chasing feedback and approvals as their biggest time drain — and every one of their top four requested fixes was a handoff problem, not a drawing problem.
Failure B — In review
The bar moves with who’s in the room
67% named reviewing for compliance and consistency as a primary drain, while information flow inside the team scored 4.0 out of 5. The friction was never internal — it was in the seams on either side.
The premise
“What stops a product designer — at any level — from producing consistent, PM- and engineering-ready work, and what would it take to remove that?”
Review
The judgment layer
Design Counsel
A reviewer that shows its evidence.
Design Counsel is a design reviewer that installs into an AI coding agent. Point it at a screenshot, a design file, a written spec, or a running app, and it returns what a senior reviewer would tell you — what’s broken, why it matters, what to fix first, and how sure it is. It is public, MIT-licensed, and runs in both Claude Code and Codex.
The problem — what a generic AI review gets wrong
F·01
Confident guessing
A static screenshot treated as proof that keyboard navigation works.
F·02
Polish before structure
Spacing notes on a screen whose core task is broken.
F·03
Forgotten states
Empty, error, permission-denied, offline — the ones that surface mid-sprint.
F·04
Crying wolf
Twenty small nits inflated into one urgent High.
F·05
Consumer defaults
Dashboards, roles, audit trails, bulk actions — skipped entirely.
F·06
Vibes, not sources
Contrast called bad by taste, with no standard behind it.
Ask a general-purpose model to “review my design” and you get a taste bot: fluent, confident and unfalsifiable. It sounds senior, and it collapses the moment anyone asks how it knows.
The idea — grade the evidence, not the vibe
So every claim has to carry its source. Each finding is tagged Observed, Inferred, Standard, Research or Precedent — and severity is graded on consequence, reach and frequency rather than on how strongly the reviewer feels. “Competitors do it” never counts as proof that it’s right.
Using Andrej Karpathy's concept of the LLM wiki, I trained the design counsel agent to learn from established design concepts and exposed to great art direction to learn to get better over time.
Why AI was the right shape for this
A checklist can’t review anything, and a person can’t review everything. This needed something that reads an artifact the way a reviewer does, holds a written standard without ever getting bored of it, and is available at the moment work is being made rather than at the next crit. And unlike a document, doctrine can be tested — so the reviewer is held to the same evidence bar it enforces.
R·01
Reads the artifact
Given a browser or design tool, it walks keyboard order and reads real contrast and token values — observing instead of guessing.
R·02
Loads only what it needs
Twelve specialist references open on demand, so a motion review doesn’t drag in enterprise doctrine.
R·03
Cites its sources
Rules trace through a 41-page wiki to WCAG 2.2, the W3C token spec, Material 3 and dozens of other primary sources.
R·04
Regression-tested
Confirmed misses become fixtures; a doctrine change is accepted only when the failing case passes without breaking the rest.
The benefit
The standard is installable. Anyone can run the same review and get the same shape of answer with the evidence attached — and a team can calibrate it to their own principles without being able to quietly switch the guardrails off. It is public and MIT-licensed: add the marketplace Aakreit/design-counsel in Claude Code, or run npx skills add Aakreit/design-counsel in any harness.
Execution
The delivery layer
The Claude ⇄ Codex Relay
Two models, routed by what each is best at.
A small, transparent relay that hands a task between two AI coding agents working in the same project folder. The handoff is a plain document committed alongside the code, each agent uses its own existing authentication, and no third model provider sits in between.
The problem — one agent, two very different jobs
Running everything through a single agent means accepting its weakest mode. In my own work the split was consistent enough to plan around: Claude was the stronger partner for framing a problem, arguing about approach and writing the acceptance criteria; Codex was markedly better at actually landing the change. Bugs Claude would circle for an hour, Codex often fixed on the first attempt.
Claude and Codex being best buds. Grok isn't too happy.
P·01
Frame
Claude sets the goal, the constraints and what “done” has to mean.
P·02
Hand off
The assignment is written to a plaintext document inside the project.
P·03
Implement
Codex works the same files and writes its result back beside it.
P·04
Review
Claude judges the result against the criteria it wrote — then reframes, or hands back.
The idea — make the handoff an artifact, not a conversation
The relay’s only real trick is that the handoff is a file. It sits in the project, in version control, beside the code it describes — so the receiving agent reads the same brief a person would, the reasoning survives the transfer, and afterwards I can read exactly what was asked and exactly what came back. Nothing is piped into another product’s interface, and neither side inherits the other’s hidden context.
Why this only works with agents
Routing by strength is only possible because both agents act on the same files rather than inside a private session. That is what turns the choice of model into a scheduling decision instead of a commitment — and it is why the workflow, not the model, became the thing worth optimizing.
M·01
Shared workspace
Both agents read and write the same project files.
M·02
No shared provider
Each uses its own authentication; no third service sits in between.
M·03
Written, not remembered
Brief and result persist as files in the repository.
M·04
Either direction
Codex can hand back to Claude as readily as the reverse.
M·05
Plain text
Nothing to inspect but Markdown — no hidden state to take on trust.
The benefit
Process
The operating layer
The Gated Pipeline
Three process agents. Nothing advances unproven.
The third system turns the other two into an operating procedure. Three purpose-built agents carry a feature from first brief to engineering-ready, and none of them will hand over until the stage before it has recorded a clean verdict.
The problem — good work, ungated
G·01
Unexamined briefs
A spec accepted because it was well written, not because it was checked.
G·02
Assumed evidence
Claims about what people want, with nothing standing behind them.
G·03
Uncovered states
The main flow is designed; the exceptions never are.
G·04
Silent gaps
Nobody notices the screen that was never drawn.
G·05
Handoff by meeting
Understanding lives in a conversation nobody wrote down.
G·06
Lessons lost
The same gap is found again next quarter, by someone else.
Every one of these is survivable once. The cost is that they recur — and a process with no gate has no way to stop them recurring.
The idea — a gate is a recorded verdict
So each stage writes a verdict to a shared memory, and the next stage reads it before it will start. Not a status in someone’s head or a nod in a standup — a written record. You can override a missing verdict and carry on, but the output is then stamped unverified, so the shortcut travels with the work. A brief judged not ready has no override at all: it goes back.
Three gated stages, and the shared memory every verdict is written to
Why AI was uniquely suited
Interrogation is the thing people are worst at doing to their own work. An agent will ask the ninetieth obvious question without embarrassment, apply the same checklist to the ninetieth screen without fatigue, and — because it wrote the verdict down — be held to it afterwards. That is the real advantage here: not intelligence, but stamina and a record.
S·01
Interrogate the brief
Pressure-tests the requirement against real signal, and hardens it before anyone designs.
S·02
Validate the design
Walks the design against the brief, hunts the missing states, and fills gaps rather than only flagging them.
S·03
Write the handoff
Produces one document that removes the walkthrough meeting — and stamps it if the design was never validated.
S·04
Learn
Recurring findings are promoted into shared rules every future design is checked against — never automatically, always with approval.
The benefit
The process holds without me chairing it, and because the memory is shared it gets stricter over time — each recurring gap becomes a rule the next design is checked against. Measured against the period before it ran: rework from unstable requirements down roughly 25%, state coverage at handoff at or above 90%, handoff meeting time per feature down roughly 40%. Directional in-house measurement, not a controlled trial.
Why these belong together
These aren’t three tools that happen to sit in the same portfolio. They’re one system with three jobs: the Counsel holds the standard, the Relay gets work done by whichever model is better at it, and the Pipeline makes sure nothing advances unproven. The obvious fix for the seams was to hire the gap away — more PMs, more engineers. That scales cost, not capability, and deepens the dependency. The contested call was the opposite: push capability down into the design role, and let the system carry the consistency instead of the org chart.
“A standard that can’t run is just a preference with citations.”
What it reveals
I build the mechanism,
not just the standard.
These were built for my own practice, in my own repos — one of them is public and installable by anyone. The integrations are deliberately swappable; what matters is the shape, not which tools it happens to talk to today. Same instinct as the frameworks: I’d rather leave behind something a team can run without me than a verdict they have to come back to me for.