Design system guardrails for AI generated assets

How do you keep AI generated output on brand and on system? Brief the model with the system itself, catch what it misses with automated checks, and give a named reviewer the final say before anything joins the library. None of the three layers works alone. Together they hold, and the order matters because each one catches what the layer before it let through.

The reason this needs saying now is volume. Generation tools mean more people producing more design and code, faster, with less review per piece, because review does not scale the way generation does. A design system that survived years of careful, slow human contribution can dissolve into a pile of near matches in a single quarter of unreviewed AI output.

The drift is specific

"AI output looks off" is not a useful sentence to act on. What actually shows up, reliably, is a short list: near duplicate components that solve a solved problem slightly differently, spacing values invented on the spot instead of pulled from the scale, colors a shade off the palette, interactive states left unlabeled, and accessibility regressions that read fine in a screenshot and fail the moment someone tabs through the page.

Every one of these is quiet in a screenshot. That is what makes the problem worth naming precisely instead of waving at it. A reviewer scanning for "does this look right" will pass most of this list, because it does look right, at a glance, in isolation. The drift only shows up when you check it against the system, not against taste.

Three layers, not one review step

The instinct is to add a review step. That helps for exactly as long as the volume stays low enough for a person to catch everything, which is not long once generation tools are actually in use. The fix that holds is three layers, each catching what the one before it misses.

Layer 1, the system itself. The single highest leverage guardrail is the one that never looks like a guardrail: a documented system, foundations named as roles and not just swatches, components named and described, the model briefed with that document every time. A model generating against a real vocabulary drifts less than one guessing at conventions from a handful of screenshots. This is the same order of work I have argued for before you build a single component, and it matters more, not less, once the thing consuming the system is a model instead of a person.

Layer 2, automated checks. Lint rules that flag a hex value outside the palette, a spacing number off the scale, or a contrast pair that fails WCAG, catch the mechanical drift before it reaches a human reviewer at all. This layer is not glamorous and it is the one most teams skip, because writing the check feels like overhead until the week the check saves you from shipping an inaccessible default at volume.

Layer 3, human governance. Automated checks catch what can be measured. They do not catch a near duplicate component that is technically on palette and on scale but still should not exist, or a pattern that is correct in isolation and wrong for this product. That judgment needs a named owner and a real contribution path, so an AI produced component does not enter the library because nobody was assigned to say no to it.

Review AI output the way you review a junior's pull request: against the system, not against taste.

The rule that keeps layer 3 honest

What governance experience actually teaches

I ran design systems across multiple products and teams at ibex before any of this generation tooling existed, and the failure mode there is the same one showing up now, just faster. A system does not fail because nobody wrote the foundations. It fails because the exceptions never stop, each one reasonable on its own, and nobody was clearly the person whose job it was to say no. I wrote about that pattern in why design systems die of politeness, and AI generated output is the same problem arriving in far higher volume with far less friction attached to producing the next exception.

That is the part worth being honest about. AI does not introduce a new failure mode into design systems. It removes the natural friction that used to slow the old one down. A person proposing a one-off component had to build it by hand, which bought the system time to notice and object. A model can propose ten in the time that used to buy. The three layers above are what replace the friction that generation speed just deleted.

This is the same discipline behind the design system this site runs on: foundations and states decided once, in writing, so the reasoning does not have to be re-argued every time something new gets proposed against it. Making that discipline hold under AI generated volume, rather than assuming the old process scales, is a real part of what design systems architecture work looks like now.

Takeaways

AI generated drift is specific, not vague: near duplicate components, invented spacing and color, unlabeled states, accessibility regressions that pass a glance. Catch it in three layers. A documented system the model is briefed with, so it generates inside a real vocabulary. Automated checks that catch the mechanical violations before a human opens the file. A named owner and a real contribution path for anything AI produced, so judgment calls a lint rule cannot make still get made by someone. Skip any one layer and the other two absorb a load they were never sized for.

Questions people ask about AI design system governance