Your Best Reviewer Is Doing a Machine's Job on Friday Night

Your design system has one person who touches every change before it ships. On a good week that feels like rigor. On a bad week it's nine pull requests stacked up at 6:40 on a Friday, all waiting on the same tired human. AI is about to make that setup impossible to defend. Let me catch you up on what actually shifts, and what your team should protect.

The gate, not the library

Most writing about AI and design systems is about making your tokens and components machine-readable so an agent can build with them. That work is real, but it isn't your bottleneck. The bottleneck is review. It's the gate.

And review is two jobs wearing one coat. There's enforcement: is this token bound or hardcoded, does contrast pass, did the visual snapshot change. Those are rules, satisfied or not. Then there's judgment: should this component exist, do these five variants collapse into one, is this alt text meaningful or just technically present. One design system owner calls conflating the two the single most expensive mistake in governance. Your senior person doing both by hand hides how much of it a script could do.

Accessibility already drew the line for you

You don't have to guess where the machine's job ends. Accessibility measured it. axe-core states its own ceiling: it catches about 57% of WCAG issues automatically. The UK Government Digital Service found the best tools closer to 30 to 40%. That gap is the boundary itself.

The 57% is enforcement: missing alt attributes, low contrast, unlabeled inputs. The other 40-plus percent is judgment: whether the alt text means anything, whether focus order makes sense, whether a screen reader user can finish the task. axe will flag a missing alt attribute. It can't tell you that alt="image" is worse than useless.

Here's the uncomfortable part. The WebAIM Million found detectable failures on 94.8% of top home pages, and the most common ones, low contrast and missing alt text, are exactly the automatable ones. So a huge share of what your gatekeeper catches by hand every week is work a machine catches in 200 milliseconds and never gets bored doing.

The floor is already boring and solved

You probably half-own the tools already. axe-core runs in CI and fails a build on violations. Style Dictionary transforms tokens from one source of truth. ESLint and Stylelint block raw hex values at the moment code is written. Chromatic and Percy catch visual drift by diffing snapshots. None of this is new.

The systems you point to as models already run it. GitHub's Primer requires a component to pass axe with zero violations and clear a manual accessibility review before it even reaches Alpha. Two separate gates, one after the other. IBM Carbon runs automated verification on every change and still keeps the screen reader test manual, signed off by a person.

The pattern holds everywhere the system is good: machines hold the enforcement floor, humans spend attention on the ceiling. If your most experienced person is grepping for hardcoded hex on a Friday night, that isn't craft. It's a machine's job billed at a human's price.

Where an agent earns its keep

So what's AI actually for? Not the floor. A few feet up the wall, in the gray zone where you can't write a rule but you can recognize a pattern. FigmaLint audits naming quality and flags plausible accessibility problems. Copilots layer on top of axe to catch the probable experiential failures and explain them in plain language.

Amplitude built a Design Agent in two days by baking their brand guidelines, tokens, and design philosophy into a system prompt, then wrapping Claude Managed Agents on Cloudflare. It turns a prompt or screenshot into on-brand HTML so a PM without design instincts gets something that looks like Amplitude, not like a vibe-coded tool. In its first weeks it produced over 2,219 session snapshots, with 2 to 4 times more viewers than makers.

The honest version of this is narrower than the hype. Romina Kavcic frames it well: the first useful agents will be boring. They detect drift, update docs, open migration PRs, flag token misuse. "Boring is where trust starts."

The deep cut

Automating the floor exposes something you may not want measured: how much of what you called rigor was just labor nobody scripted. That's the real payoff here. Once the machine holds enforcement, your human review has to justify itself on judgment alone, and that's a harder, more valuable job.

So do the split on paper. List every check your gatekeeper runs and mark each one E or J. Push every E into CI this quarter. Then protect the J work loudly, because that's the reason you pay a senior person. And watch the contract your tools make. As the Magic 8-Ball comparison argues, fluent AI output reads as confident even when it's guessing, so when your agent flags a probable accessibility issue, ship it with a confidence range and a source, not a clean paragraph that invites your team to trust it blindly.

Three questions for your team

1. Which checks in our review process are rules a machine can enforce, and which are judgment calls, and can we point to the line on paper by next sprint?
2. If our senior reviewer got hit by a bus tomorrow, what stops, and what does automating the enforcement half buy back for them?
3. When our agent flags a probable issue, does the interface show its uncertainty, or does it hand our team polished prose they'll trust without checking?