Design systems are now AI infrastructure
Your tokens and components are now instructions for AI agents.

Zander Whitehurst
10 min read
For years we have argued that design systems are worth the investment because they make teams faster and products more consistent. That is still true, but there is a new and more urgent reason: AI agents build with whatever system you give them.
I have spent more hours than I would like to admit arguing about whether a token should be called grey-200 or surface-subtle. For years it felt like the kind of debate only design systems nerds cared about. Turns out those arguments were secretly prompt engineering. Who knew.
If your system is clear, the agent produces work that looks like your product. If it is messy, the agent faithfully reproduces the mess at speed.
This shift turns the design system from a nice internal resource into something closer to infrastructure. It is now the layer every AI generated screen is built on, and its quality directly decides the quality of everything that comes out.
The new audience for your system
Design systems were built for people. Designers browsed the library, engineers read the documentation and everyone learned the patterns over time through repetition and review.
AI agents learn differently. They do not absorb culture or remember last week's feedback. They read exactly what is in front of them, every single time. That means anything implicit in your system, anything that lives only in people's heads, is invisible to them.
The practical question becomes: if an agent could only see your tokens, components and docs, would it build the right thing? For most teams today the honest answer is not quite.
Tokens are prompts
Every token name is a small piece of instruction. A token called surface-raised tells an agent far more than one called grey-200. Semantic naming used to be a nice to have for humans. For AI it is the difference between guessing and knowing.
Audit your tokens with that lens. Would an agent reading only the names understand when to use each one?
A useful structure is to keep primitive tokens, like raw colour values, separate from semantic tokens that describe purpose. Agents should almost always use the semantic layer. When they reach for primitives, it is usually a sign that a semantic token is missing.
Components need documentation agents can read
Agents do not look at your Storybook screenshots. They read code, props and descriptions. The components that get used well are the ones with:
- Clear, typed props with sensible defaults
- Short descriptions of when to use them and when not to
- Examples of real usage in the codebase
Five minutes writing a good component description now saves hours of correcting AI output later.
The "when not to use" part is especially valuable. Agents are eager to use whatever component looks closest to the request. A single line explaining that a component is only for destructive actions, or only for navigation, prevents a whole category of mistakes.
Fewer, better components
Large libraries with many near duplicates confuse agents just as they confuse new team members. If you have three slightly different card components, the agent will pick one more or less at random.
Consolidating is one of the highest leverage things you can do. Merge similar components into one with clear variants. Delete the ones nobody should use any more. A smaller, sharper library produces more consistent AI output than a large, sprawling one.
Keep Figma and code in sync
Figma MCP lets agents read your design files directly, which is powerful only if those files match what is in code. Drift between the two is now a bug, not just an inconvenience. Treat variable and component parity as part of your definition of done.
In practice this means using the same names for variables in Figma and tokens in code, keeping component properties aligned with props and reviewing both sides when either changes. It is more discipline than many teams are used to, but the payoff is an agent that can move between design and code without getting lost.
Write rules down
Some of the most important parts of a design system are not tokens or components at all. They are the rules about how things fit together: how much space goes between sections, when to use a modal versus a new page, how many primary buttons a screen can have.
Write these rules in plain language and store them where agents can load them, such as a project rules file or a reusable skill. These short documents often improve AI output more than any single component change, because they capture judgement rather than just parts.
Measure the quality
You can only improve what you notice. Keep a simple log of the mistakes agents make when building with your system. Group them into themes. If agents keep using the wrong text colour, the token naming probably needs work. If they keep building custom layouts, you may be missing a layout component.
Over time this log becomes a roadmap for your system, driven by real usage rather than guesswork.
I watched an agent build an entire dashboard using our oldest, most deprecated card component last month. Not because it was clever, but because that component had the best documentation. That was a humbling moment. The agent did exactly what we told it to. We just had not told it the right thing.
Start with the most used pieces
You do not need to rebuild everything. Pick the ten components your product uses most, tighten their names, props and docs, and point your agents at them first. The quality jump will be immediate and it will make the case for doing the rest. We go deeper on this in our AI Design Systems Bootcamp.
Teams that treat their design system as AI infrastructure now will find that every AI generated screen gets better automatically. Teams that do not will spend more and more time cleaning up after their tools.
Memorisely