# The agent-ready design system: readiness checklist

Five checks. Ten minutes. Score one point per pass, and be strict: "partially" is a zero.

From tokenstoagents.ai. Free to use inside your team.

## Check 1: values are data

Your design decisions exist as structured tokens (DTCG .tokens.json or equivalent), not only as a Figma library, a stylesheet, or a PDF. The test: can a program list every color, spacing step, and type size in your system without parsing CSS or opening a design tool? If the source of truth is a compiled artifact, that's a zero.

## Check 2: meaning is encoded

A semantic tier exists and is complete enough to build with. The test: could someone assemble a correct screen using only semantic tokens (color.text.primary, color.feedback.danger, space.inset.card) without ever touching a primitive? Bonus signal: primitives are linted out of application code. Most teams fail here, and most agent guessing traces back to this gap.

## Check 3: components have contracts

Your top components have machine-readable contracts: props, variants, allowed values, and the specific tokens applied, as data (JSON schema or equivalent), not prose. The test: could an agent validate "is this Button legal?" without reading your docs site? If the answer lives in Storybook prose, that's a zero.

## Check 4: intent is written

New work starts from a written spec an agent cannot misread (EARS patterns or equivalent testable statements), and for system-critical surfaces the spec stays alive after the build. The test: pick your last shipped feature. Does a document exist that states, unambiguously, what it was supposed to do? Could a second agent rebuild it from that document alone?

## Check 5: context reaches the agent

Runtime context files exist and are current: an AGENTS.md (or equivalent) with the standing rules, pointers to tokens, contracts, and specs, and on-demand detail (skills or linked docs) rather than one giant prompt. The test: open a fresh agent session in your repo and ask it "what are the rules here?" If the answer isn't your actual rules, the delivery layer is missing.

## Scoring

5: Agent-ready. Your bottleneck is governance throughput, not context. Wire the observe-detect-suggest-fix loop next.
3-4: One layer is carrying the others. Fix the lowest failing check first; the layers hand context downward, so gaps compound in order.
1-2: You have a human-readable system. Agents will hit roughly 80 percent and slip on component details, which is exactly where your users notice. Start with checks 1 and 2; they're the cheapest and everything else stands on them.
0: Good news: greenfield discipline is easier than renovation. Start with 20 primitives and 12 semantic roles this week.

## The order of operations

Values first (check 1), meaning second (check 2), contracts third (check 3), specs fourth (check 4), delivery fifth (check 5). Each layer hands the next the context it needs. Skipping ahead feels faster and isn't; a spec that references tokens that don't exist is fiction with structure.

One honest note: a 5 out of 5 doesn't remove review. One production team generated 4,300 prototypes in four months with a winning machine-readable format, and an audit still found violations. Structure raises the floor. Governance holds the ceiling. Plan for both.