AI will expose weak design systems

The first screen is always convincing.

You describe an interface to an AI tool, wait a minute, and receive something that looks like a finished product: sensible layout, plausible copy, a colour scheme that doesn't offend.

If you've spent years watching teams take a fortnight to get a screen to this state, the effect is genuinely disorienting.

Then you generate the second screen. And the fifth. And the twentieth.

Somewhere in that sequence, the illusion develops cracks. The button that confirmed on screen two now confirms differently on screen nine.

The empty state that offered a helpful action on one page is a shrug on another. Terminology drifts. Error handling exists on the screens where the model happened to think of it.

Each screen, in isolation, still looks fine. Together, they don't add up to a product. They add up to twenty products wearing the same colour palette.

I've run these experiments myself while building a React and Figma system aimed partly at AI builders, and the pattern is consistent enough that I'll make a prediction: AI will not replace design systems. It will reveal which ones were never systems.

Speed scales whatever you already have

Here's the mechanism. AI is an amplifier of the constraints and examples it's given. Give it strong constraints and it produces work within them at remarkable speed.

Give it weak constraints and it produces ambiguity at exactly the same speed.

Before generation tools, a weak design system was a slow leak.

Humans built screens slowly, and human designers carry implicit context, taste, memory of adjacent screens, a sense of how "we" do things, that papered over the gaps in documentation.

Inconsistency crept in at the pace of human output, which gave teams time to catch some of it in review.

Generation removes both brakes at once.

The model has no memory of your other screens unless you hand it one, no taste for your product's conventions unless they're written down, and it produces work faster than your team can review it.

The gaps in your system don't stay gaps. They get filled, instantly and confidently, with the most statistically average answer to every question you left open.

Weak systems don't just fail to help anymore. They fail at scale.

Which inverts something about who benefits. The received wisdom says AI tools help teams with the least design maturity, because now anyone can produce screens.

I think the opposite is closer to true. The teams who'll get the most out of generation are the ones whose foundations are strongest, because they're the only ones who can turn raw output speed into coherent product.

Visual consistency is the easy part

The failures worth worrying about aren't visual. Models are actually decent at keeping colours and type consistent, especially when handed tokens. What they can't infer is behaviour.

A component library, even a good one in code, tells a model what things look like. It says nothing about what should happen.

Does this form validate as you type or on submit? Where does the user land after a destructive action? What does this table do with ten thousand rows, or zero?

When a step in a flow fails, does the user retry, skip or lose their work?

A generated interface answers all of these questions anyway, because it has to render something, and it answers them differently every time you generate.

This is the distinction between visual consistency and behavioural coherence, and generation tools make it brutally visible. Your screens can match perfectly while your product has no consistent opinion about anything.

Users feel this even when they can't articulate it. The product looks trustworthy and behaves like it's improvising.

So the system layers AI actually needs are the ones most teams never built: patterns that record decisions ("destructive actions always require typed confirmation"), state definitions for empty, loading, error and no-permission, content rules for tone and terminology, interaction conventions, accessibility requirements.

And they need to be machine-readable, or at least machine-feedable. A principle living in a senior designer's head governed human output.

It cannot govern generation, because the model was never in the meetings.

Accessibility deserves specific mention because it's where raw generation quietly fails most often. Focus order, contrast in states beyond default, labels on icon-only controls, keyboard paths through multi-step flows.

Generated screens tend to look accessible and miss these things, precisely because they're behavioural rather than visual.

If your system doesn't state these requirements explicitly, generation will skip them at scale, and you'll ship the debt before anyone reviews it.

What this does to the design role

I don't think designers stop designing screens. Some screens carry too much weight, too much nuance or too much novelty to delegate, and knowing which ones is itself a design skill.

But the centre of gravity shifts. Less time drawing every instance, more time defining the system instances are drawn from.

Less time producing output, more time evaluating output, and evaluation is a real skill: reviewing generated work against product intent is closer to design leadership than to production.

When a generated screen gets something wrong, the interesting question stops being "how do I fix this screen?" and becomes "what rule or example was missing that allowed this, and how do I add it?" Fix the guardrail and you've fixed every future screen.

That's systems thinking applied at a new altitude, and honestly it's the part of this shift I find most interesting.

The design system team's customer base also doubles. Yesterday it served designers and engineers. Now it also serves generation tools, and tools are the most literal-minded consumers imaginable.

They don't attend the onboarding session or absorb culture. If it isn't specified, it doesn't exist.

In a strange way this is good discipline: a system that a model can follow is a system that's actually finished, and most of our systems were never actually finished. We just had humans compensating.

Three questions before you connect the pipes

I'm not going to pretend my own system answers all of this yet. It's live work, and part of why I'm building it is to find out where the idea breaks.

But if your team is about to wire AI generation into product UI, I'd want honest answers to three questions first.

Can your system answer behavioural questions, not just visual ones? Pick any component and ask what happens next in every state: loading, empty, failed, forbidden.

If the system is silent, the model will invent, and every invention is a coin flip.

Do your constraints exist outside people's heads? Anything that lives only as culture and taste is invisible to a generation tool.

The audit is simple: could someone with no context, human or model, follow your rules from what's written down alone?

Who reviews the volume, and against what? If you can generate fifty screens a day and review five, you don't have an acceleration problem, you have a quality dilution problem.

Decide what "correct" means before you scale production of maybe-correct.

Teams that can answer these will turn generation speed into real product velocity.

Teams that can't will discover, faster than they'd like, exactly how much of their design system was actually a shared folder of screenshots and good intentions. The tools aren't going to be kind about the difference.