Design systems are changing AI can actually use them now

Design systems used to be something people read and interpreted. Now AI can work directly from the rules, which changes what a design system actually needs to be.

Published Read6 min read CategoryChange
Product design workspace with digital interface work and design documentation.

For most of my career, a design system has been something people use.

You build the components, define the type scale, decide how spacing works, document the states, explain when to use one button over another, then spend a surprising amount of time making sure everybody actually follows it.

The system might live in Figma, Storybook, a brand site, a PDF, or some combination of all four. But the assumption underneath it has always been the same: a human being is going to read it, interpret it and make a judgement.

That assumption is starting to change.

Over the last few weeks, I’ve been building out design and brand systems in a slightly different way. Alongside the visual libraries, I’ve started writing the rules in Markdown so tools like Codex can use them directly.

That sounds like a small change.

I don’t think it is.

From documentation to instruction

Traditional design-system documentation is often descriptive.

It tells you what the primary button looks like, what the spacing scale is, which heading style to use and what the accessibility requirements are.

Useful, obviously. But there is still a gap between the rule and the thing that gets built.

Somebody has to interpret it.

With AI-assisted development, that documentation can start becoming instructional instead.

A rule can define the default behaviour, the variation that is allowed, what should never happen and what the fallback should be if the preferred solution is unavailable.

For example, the system might say that the primary button is used for the main action on a page. Secondary treatments are available for lower-priority actions. A new button style should not be invented simply because the existing options feel inconvenient. If the exact component required doesn’t exist, use the closest approved pattern and flag the gap.

That is a different kind of design-system language.

It isn’t just showing somebody what good looks like.

It is telling a system how to behave.

The interesting part isn’t the components

I used to think the difficult part of a design system was getting the components right.

I’m less convinced now.

The components matter, of course, but the real value is in all the decisions around them: what is allowed, what isn’t, where variation is acceptable, and what should happen when there isn’t a perfect answer.

That is the part designers carry around in their heads.

It is also the part that normally disappears when work moves from Figma into production.

Recently I’ve found myself documenting things I would previously have considered too obvious to write down.

How links should behave on light and dark backgrounds. Which Lucide icon represents search. Whether an icon can be reused for a different meaning elsewhere. Which image ratios are approved. How body copy should be coloured. When a border is appropriate and when spacing or contrast should do the work instead.

None of those decisions is especially dramatic on its own.

Together, they are the system.

And once those decisions are machine-readable, an AI coding tool can start checking its own work against them.

The design system becomes part of production

This changes where the design system sits.

Instead of being a reference library beside the work, it starts becoming part of the production environment itself.

That is the bit I find interesting.

If an AI agent is creating a new page, it can be told which tokens exist, which components it is allowed to use, which patterns are prohibited and what to do when the preferred solution is unavailable.

If the icon registry says search uses a particular Lucide icon, the agent can check that before reaching for something else.

If the brand rules say body text uses one token and headings another, that can be dealt with while the page is being built rather than spotted three days later during a design review.

If the visual language says no unnecessary borders, no decorative dot dividers and no random arrows where a chevron is the established pattern, those rules can travel with the code instead of living as tribal knowledge.

This isn’t particularly glamorous design-system work.

It is governance becoming executable.

Figma is still important It just isn’t the whole system

I don’t think any of this makes Figma less important.

Quite the opposite.

Figma is still where a lot of the visual thinking happens. It is where you establish hierarchy, proportion, rhythm, interaction patterns and the overall feel of a product.

But I’m starting to think about the Figma library as one representation of the design system rather than the design system itself.

The real system is the agreement underneath it: the tokens, component logic, naming, accessibility rules, content rules, exceptions, fallbacks and all the things we have deliberately decided not to do.

Those decisions can now exist in a form that both people and machines can understand.

That matters because more implementation work is starting to happen through prompts and agents rather than through a designer handing over a screen and a developer manually recreating it.

If the AI only sees the screen, it can imitate the screen.

If it understands the system, it has a chance of extending it.

That is a much more useful relationship.

It also exposes weak design systems very quickly

There is another side to this.

AI is quite good at exposing where a design system is vague.

Designers are used to filling in the gaps themselves. We can look at three examples and infer what the fourth probably ought to be. We know that a certain rule was never formally documented, but everybody on the team understands it.

An AI agent doesn’t have that shared history unless you give it one.

So you start noticing the holes.

What happens if this component appears on a dark background? Can this icon mean two different things? Is this spacing token a preference or a hard rule? What happens on mobile? What is the fallback if the preferred photography isn’t available? Are we actually allowed to create a new pattern here?

These are good questions whether AI is involved or not.

The machine just forces you to answer them.

The next generation of design systems may be less visual

Not less designed.

Less visual.

A lot of design-system maturity has traditionally been judged by the library: how many components there are, how polished the documentation looks and how complete the Figma file is.

I suspect a more useful measure is going to become how clearly the system can express intent.

Can a new designer understand it? Can a developer implement it without guessing? Can an AI agent create something new without slowly turning the product into visual soup? Can the system recognise when one of its own rules is being broken?

That requires more than components.

It requires language.

Clear defaults, constraints, exceptions and fallbacks.

In other words, it requires design judgement to be written down.

The strange thing is that this makes design systems feel more human

There is an obvious irony in all of this.

The more AI becomes involved in making digital products, the more important it becomes to document the human decisions behind them.

Without that, AI tends towards the generic. It reaches for familiar patterns, adds things that look plausible and fills gaps with whatever it thinks probably belongs there.

A good design system can push in the opposite direction.

It can preserve the small decisions that make a product feel like itself.

Not because the AI has taste, but because somebody with taste has made the rules clear enough for it to follow.

That feels like a meaningful change.

For years, we built design systems so teams could work consistently.

Now we may need to build them so teams and machines can work consistently together.

And I think we’re only just starting to work out what that really means.

Quick check

Project video