What it takes to let AI build your design system

We rebuilt our design system from the ground up, and I didn't build a single component myself. AI built every one. Token-bound, documented, and shipped into the library. The full build took two months.

The clearest lesson: output quality is decided before the AI does anything at all.

Cheap generation is the trap

Generating is easy, and that's exactly the danger. Weak inputs still produce output, and it arrives fast, looks plausible, and quietly rots your files. Inconsistent components. Off-standard details. Work that drifts away from the problem it was meant to solve. Garbage in, garbage out still applies. AI just produces the garbage faster.

Spotting a wrong result is the easy bit. Any decent designer can look at a component and see the problem. The hard part is upstream: giving the AI everything it needs to get the work right, consistent and scalable, while keeping it pointed at the actual problem.

It all starts with a document

Before anything gets built, there's a standard. What every component must include, how it's named, how it binds to tokens, what documentation ships with it. The AI reads it before every build. It supplies the labour. The rules come from someone who understands the problem.

Standards are one input. Decisions are the other. Every meaningful call goes into a log: what we decided, and why. The AI reads that too, so settled questions stay settled and nothing gets re-litigated three weeks later.

Every component passes a gate

Nothing enters the library on trust. The sequence is the same every time.

Check it doesn't already exist. Sounds trivial. It saved days of duplicate work.

Read the source completely before building. Every variant, every state, every edge. Partial reads produce confident, wrong output.

Build what's right, not what's legacy. Old files carry old mistakes. A defect in the source gets fixed in the rebuild, not copied forward.

Audit before calling it done. The finished component gets checked against the source and the standard, property by property.

Verify with code, not eyes

Screenshots lie. A component can look perfect and be wrong underneath. A hardcoded colour where a token should be. A missing state. A broken binding. So verification is programmatic. We query the actual properties and check them against the standard. If a check can't be run, the component isn't done.

A designer can eyeball a handful of components. A script can check every property across the whole library.

Mistakes are why designers matter

The AI gets things wrong, and that's to be expected. It's also exactly why a designer belongs in the loop. Someone has to know what right looks like, catch the miss, and course correct. That judgment is the job.

Every failure also becomes a written rule, added to the instructions the AI reads on the next build. If the same mistake appears twice, that's on me. The setup got harder to fool every week.

Where that leaves the role

Direction and judgment. I define the inputs, review the output, and make the calls the AI can't. Less time producing. More time making sure the production is right.

The impact is easy to measure. Two months for a full component library, work I'd normally scope at the better part of a year for a small team. Every component shipped with full documentation and a written decision trail on the day it was built, which I've never seen happen on a manual rebuild. And the designers on my team now spend their time on product problems instead of library maintenance.