Can AI Build a Production-Ready Design System?

Why I ran this experiment

Every few weeks there's a new demo of an AI tool generating a full interface in seconds, and every time, the discourse splits into two camps: “designers are obsolete” and “this is a toy.” Neither felt true to me, and neither was based on anything I'd actually tried myself.

So I picked the hardest version of the problem I could think of: not a landing page, not a single screen, but a design system, the kind of foundational, opinionated, detail-obsessive work that takes senior designers weeks to get right, even at companies with unlimited resources. If AI could hold its own here, that would tell me something real.

I want to be upfront: this is one designer's experiment, not a benchmark. No user testing, no client, no rigorous methodology. Just me, a prompt, and a few hours of honest observation.

The prompt I gave Figma Make

I tried to write the kind of brief I'd actually hand a design intern: specific enough to be useful, open enough to see how the tool would fill in the gaps:

“Design an enterprise B2B SaaS design system inspired by Linear's visual language: minimal, high-contrast, precise typography, restrained use of color, purposeful motion. Include color tokens for light and dark mode, a type scale, a spacing scale, and core components: buttons, inputs, tables, modals, navigation, a command palette, status badges, and empty states. The system should feel consistent, accessible, and built for a complex internal tool used by teams every day, not a marketing site.”

That last line mattered to me. Linear's whole design philosophy is downstream of it being a tool people live inside for eight hours a day. I wanted to see if the AI understood that distinction or just borrowed the aesthetic.

What AI generated

What came back was, honestly, more than I expected in the time it took. A token file. A full component set, not just a hero screen. Buttons in multiple states and variants. A data table. A settings layout. A command palette, Linear's signature interaction, recreated with reasonable fidelity. Dark mode that wasn't just an inverted color filter.

It also generated a rough page composition: a dashboard-style layout combining several of the components together, which is usually where a system reveals whether its parts were designed to work together or just designed to exist independently. That's normally the first place things fall apart. So that's where I looked first.

What impressed me

The token discipline was better than I expected. Color, spacing, and type were mostly pulled from a defined scale rather than invented per-component, which is the single most common way AI-generated UI falls apart. It understood, at least structurally, that a design system is a set of rules, not just a set of screens.

The restraint was also real. It didn't over-decorate. Borders were thin, shadows were subtle, color was mostly grayscale with a single accent, all correctly identified as core to Linear's language rather than incidental. And it moved fast enough that by the time I'd normally still be setting up frames, I already had something to react to and critique. That shift, from blank canvas to critique mode, is genuinely valuable, independent of how good the output is.

Where AI fell short

The cracks showed up exactly where I expected: in the parts that require judgment, not pattern recognition.

Contrast was the first issue. Several text and icon combinations technically met the aesthetic but failed accessibility contrast ratios, the kind of thing that looks fine on a bright monitor in a demo and fails immediately in a real audit. The system had opinions about how things should look, but no real model of why those choices needed to hold up under constraints.

The density problem was next. Linear's interfaces work because every pixel of spacing in a dense table is a deliberate decision about scan-ability. The AI's table component was visually clean in isolation, but once populated with realistic data, the hierarchy fell apart: everything competed for the same visual weight.

And the component set had quiet redundancies: two button variants that served the same purpose with no clear rule for when to use which, empty states that were visually polished but interchangeable rather than tailored to their specific context. Nothing was wrong, exactly. It was all just slightly unreasoned: correct-looking answers without the underlying logic a designer would need to defend them in a critique.

Motion and interaction were the most obviously missing piece. Everything was static. Linear's feel comes as much from how things happen (the command palette's timing, the way a status updates) as from how they look at rest. AI gave me the frames. It didn't give me the feel.

How I refined the design

Once I had something to react to, my job became editing rather than generating, which, it turns out, is a completely different skill than I expected it to be.

I rebuilt the token architecture so spacing and type actually cascaded from a single source instead of being close-enough approximations. I fixed the contrast failures by hand, one by one, because that's not something you can prompt your way out of; it requires actually checking. I redesigned the table component around real, messy data instead of the clean placeholder rows it had been generated against, which changed almost every spacing decision. I killed the redundant button variant and wrote down the rule for when to use the one that remained, because a system without that rule isn't really a system. And I added the interaction detail (the timing, the hover states, the small motion cues) that make an interface feel considered rather than assembled. None of this was glamorous work. It was the same unglamorous editing work design systems always require. AI just moved up my starting point.

Final thoughts

Figma Make didn't build a production-ready design system. But it built a very credible first draft of one, faster than I could have sketched the same scope by hand, and that's a genuinely different capability than what existed even a year ago.

What it's good at is pattern replication with real structural discipline: tokens, consistency, restraint, breadth. What it can't do yet is reason about constraints it can't see in a prompt: accessibility failures, real data density, the specific rule a component needs to earn its place in a system. That's still design judgment. That's still the job.

The honest takeaway isn't “AI replaces design systems work.” It's that AI is now a legitimate first draft: a faster blank canvas, not a finished decision. Which, for a discipline that spends so much of its time starting from nothing, might be exactly the right kind of help.