Why AI needs your design system (and humans)

Kevin Coyle
Written by Kevin Coyle
Mar 12, 2026

Who needs a design system when you can generate an app in only a few minutes? Who cares if it doesn't have that exact spacing between the buttons and the date picker?

Yeah, I've heard this sort of thing with increasing volume in the background, and honestly, it can be somewhat tiresome to defend our existence from the impending surge of robots that are just gagging to take our jobs – if the gossip columns on LinkedIn are to be believed.

This concern isn't hypothetical. In a recent survey I ran with Ben Callahan on The Question, one respondent put it bluntly:

"My concern is that when leadership sees AI generating UIs, they'll be so wowed that they'll simply think there's no need for a design system or a team to maintain it. They won't see how the two can complement each other perfectly. They'll fall into the trap: just seeing dollar signs."

Yet the same survey revealed something encouraging: The majority of practitioners see AI in design systems as amplifying their work, not replacing it. Documentation, code generation, auditing, and prototyping were the most common uses. Humans are still very much in the loop. The question isn't whether to use AI to generate a design system – it's how to use it well.

Design systems are needed more than ever

So why do some managers and executives feel that AI can build applications without a design system in place? 

If I were to give the lazy definition of a design system, I'd reduce it to a dysfunctional situationship of a Figma file and an associated git repo. From that angle, it's easy to conclude that a machine can create it by rapidly remixing things it has seen before.

This reductionist view, however, does a huge disservice to what a design system actually is. And it's easy to conflate output with outcome. The serotonin-fueled high that floods the minds of executives when they see a demo of an LLM creating an application sometimes leads to a sinister, secondary thought: Do I even need these troublesome, expensive, fleshy beings in my money-producing machine?

It won't surprise you that my answer to this question is, of course, YES. Naturally, I'm biased in the respect that a lot of those expensive fleshy beings are also my prized friends and colleagues. But I have a more objective reason for this, too, and it's often overlooked when we focus on output alone.

What's more important about a design system isn't the visuals or the code that accompanies it: It's the series of decisions people have painstakingly made through discussion, argument, and sometimes tears.

That’s one of the primary reasons why I believe that we shouldn’t just generate documentation from code. It misses so much context. It’s much better for a human being who has been through the trials and tribulations to explain not just the how but the why inside those sacred documents.

These decisions, however, have always come at a great cost in terms of implementation. Creating code is an expensive pastime, and once a team decides to do something in a particular way, changing course later usually requires meetings, cost estimates, and pain.

LLMs are a step forward in innovation because they really speed up how fast we can crank out stuff. That quick output means we can get fast results to use or ditch.

What is our target output?

Let's set the frame about what we're actually talking about when we say "AI-generated design systems".

This isn't a definitive list, but here are the components I think materially make up a design system's output:

Documentation

  • Storybook
  • zeroheight
  • Codebase documentation
  • Architectural decision records

Code

  • Front of the front-end code
  • Tokens

Design

  • Component-level designs
  • Recipes

Which of these do we want our unfeeling robot overlords to accelerate? The first thing I tried to automate, unsurprisingly, was code generation. 

Generating web components with AI

Way back in late 2023, I was working with a major U.S. financial market operator, and I promised that – even when LLMs were still somewhat in their infancy – I could generate our component code. 

The thing I struggled with was that back then, people were writing huge prompts to try to shepherd these unwieldy models into giving us an output that was acceptable and coherent. I never found that to work particularly well with the way that my mind thinks as an engineer. I like direct, succinct instructions, and I like my robots to be the same.

The challenge here was to deliver the context of what the component is, how it works, and how it interfaces with other components in the system. 

My solution for this was to create a YML-based specification describing how a component works. It was so simple that non-technical people, including designers, joined in and helped write these specifications. It was also a way for us to help document our code. 

Here's what they looked like:

name: calendar
description: A calendar widget that can be used to show or select dates. It shows only a month at a time.
properties:
  - name: selectedDate
    description: The selected date in the calendar.
    type: string
  - name: minDate
    description: The minimum date that can be selected in the calendar.
    type: string
  - name: maxDate
    description: The maximum date that can be selected in the calendar.
    type: string
  - name: disabledDates
    description: The dates that are disabled in the calendar.
    type: array
    items:
      type: string
considerations:
  - The calendar should show the current month by default.
  - The calendar should show the days of the week at the top.
  - The calendar should show the dates of the month in a grid.
  - The individual dates should be selectable.
  - The individual dates should have stying states for hover, if its today, if its selected, if its disabled.
  - The user should be able to select a range of dates

Accompanying this, I created a Rust-based application that read in these specification files in a rather dashing 1980s-style interface. And, as if by magic, it'd output a rather convincing-looking component. This was coupled with the crucial infrastructure, such as the project scaffolding, code guidelines, and, of course, design tokens.

With that critical infrastructure in place, I was surprised by how close the output got to the design – without even touching Figma. Context is vital, and giving it to the AI without hitting token limits or sending it down a winding path to hallucinated nonsense is where design system practitioners come in. We can act as the shepherds and guardians of these tools to make sure that, whilst they're pumping out this slop, the slop is at least tasty and useful.

In reality, the tool’s output was limited at the time, but it did accelerate us significantly. We still needed humans to do the final polishing here and there to make sure it deserved a place in our repository. We also had some issues with developer adoption – devs were always itching to edit the code manually, which ran counter to my idealistic expectation that we'd just prompt our way out of any problem.

Things have changed a tad since then. Claude Opus 4.5 and GPT-5.2 blow my humble generator out of the water. Agentic tools such as Claude Code and OpenAI’s Codex intelligently scour through your existing codebase and formulate the current context into something the model can use to produce much more accurate and sophisticated code. 

Delivery methods for providing context to the AI have changed, too.

Context is important

Model Context Protocol (MCP) is basically the USB port for AIs. If you don't know what MCP is, think of the clunky ways in which we've had to inject context into an LLM before: either by writing those super-long system prompts or by creating that YML structure, which I always had to have ready in advance. 

It was like a student having to check out every library book, DVD, and microfiche before they could study. MCP means models now have access to context and tooling to do things at their fingertips, in a predictable format that can be read.

One exciting upcoming MCP is the Storybook MCP, which not only arms the agentic coding system with relevant information about the component library in question but can also empower the agentic tool to self-heal errors and bugs. At the time of writing, this isn’t generally available yet. 

But one thing that is available is the zeroheight MCP! This will give your agentic coding system, or even a chat app like Claude Desktop, the ability to get page content from your carefully crafted documentation. Additionally, it can also fetch styleguide information to inform your agentic amigo further. (Also see Vibe coding your design system with the zeroheight MCP).

Another MCP worth mentioning is, of course, the Figma MCP – one of the more powerful Figma AI tools available. This was one of the missing pieces in my old component generator: It enables you to pull all of the metadata from individual nodes within your Figma document, and it gives it more knowledge to be able to understand and style. This works really well when you integrate it with Cursor or Claude Code and a well-structured design system codebase.

What about documentation?

I've always thought that design system documentation isn't just a clinical assessment of the facts, but a record of lived experience and the decisions, with rationales, behind them. 

AI does have a place here, though. There are exciting developments around generating Storybook stories. TJ Pitre at Southleft has created a rather innovative tool that, once integrated into your Storybook, lets you prompt it to generate stories – even from a screenshot. It's well worth a look to accelerate your work and reduce some of the tedium that can come with creating stories.

The future is bright for design systems

I have fond memories of having my headphones on, going into deep concentration, alone, and working on boilerplate and complex component code alike. Sadly, those days are either over or nearing completion – especially for boilerplate code.

Design systems aren't going anywhere, though. They're critical infrastructure that is vital in the AI age because they provide the context that can differentiate slop from usable products.

I don't believe that in the near future interfaces will remain static. Projects such as A2UI present an exciting paradigm whereby the application signals intent to the AI, which then generates an interface from your design system and presents it to the user. 

As these agentic tools improve, our code and our design files will become build artifacts. These artifacts will be created at the speed of thought.

The word thought here is, of course, a loaded term. I’ve chosen it particularly because, despite appearances, LLMs are incapable of the sort of thought that we expensive fleshy beings are able to manifest.

One of the major impediments to agility, a big criticism of design systems, may well disappear when we can design and code at the speed of thought.

Kevin Coyle
Kevin Coyle
Kevin Coyle is a design systems and AI consultant based in Manchester, England. He helps product and engineering teams bring large language models into real-world applications, with a focus on design systems, developer experience, and the tools that connect them. Through his consultancy, Drutek, and a handful of AI-powered products, Kevin explores how humans and machines can collaborate to build software that is both fast and thoughtful.
Try zeroheight
The design systems platform that keeps teams and agents in sync
Start for free
Share this post