A normal day on a design system team can look like this now. One agent is porting a component to another platform, another is drafting usage docs, a third is checking a Figma file for contrast failures, and a fourth is writing the codemod for next month's migration. You move between them all day, approving and redirecting, and now and then catching a prop that doesn't exist. By evening a remarkable amount has shipped.

I like a lot about this. Work that used to sit in the backlog for a quarter gets done in an afternoon, and nobody misses writing the fourth near-identical docs page by hand. But those days leave me tired in a way that doesn't feel earned, and at the end of them I can rarely say what I actually thought about.

The part of the job I used to enjoy most worked the other way round. You pick up one problem and carry it around for days. You keep all of its details in your head, turn it over on the walk home, and come back the next morning with a slightly better idea. I see less of that kind of thinking every month, and design systems will probably feel its absence before most other kinds of software do.

What living with a problem looks like in a design system

Most of the decisions that make a design system good look small from the outside. Take a Button. Is loading a state or a variant? Should a disabled button still be focusable, so a screen reader user can find it and learn why it's unavailable? What does an icon-only button announce, and who makes sure that label gets translated? Each answer ends up as a prop name or a line in the docs. Getting to it can take a week.

Whether a token called "primary" means the brand color or the main action sounds like an argument about naming. It's really a decision about what happens on the day the brand color changes and every primary button in every product changes with it, whether anyone wanted that or not. You only see that coming if you hold the brand, the products, the platforms and the cost of migrating in your head at the same time, long enough for the connections to show up.

Most of the work is in that holding. The answer, when it comes, is often a single sentence, and the days spent finding it show up nowhere except in how rarely anyone has to revisit it.

Reviewing spends judgment without building it

Guiding agents works best when you already know the territory. Years of shipping components teach you what a bad API looks like, so you can spot one in an agent's pull request in seconds. That's real skill, and it's the reason experienced people get so much out of these tools.

The catch is that review draws on that judgment without adding to it. You check the output against what you already understand, and the problem never stays in your head long enough for you to understand anything new. Switching away from an unfinished task also leaves part of your attention behind on it. The management researcher Sophie Leroy named this attention residue in 2009, and anyone who has juggled several agent sessions will recognize it. A dozen threads give you a dozen shallow passes and not one deep one.

So experienced people are drawing down savings. That works for a while, maybe for years. It works much less well for people who never had the chance to build savings in the first place.

Picture someone joining a design system team this year. An agent can produce a plausible Button in four minutes, so they may never spend the three days that would have taught them why disabled buttons are an accessibility mess, or why the focus ring sits two pixels outside the border instead of on it. They get fluent at reviewing before they've had the experiences that make review worth anything. That isn't their fault, and I'm not sure yet what replaces those three days.

Design systems multiply whatever you decide

A product team that makes a shallow decision ships one awkward screen. A design system team that makes the same decision ships it to every product that uses the system, on every platform it supports. That multiplier has always been the reason design systems are worth funding, and it's also why the thinking behind them has to be better than average.

Agents add a second multiplier on top. If your system is the context coding agents build from, they will reproduce its decisions faithfully and in volume, the careful ones and the careless ones alike. A token named after a color instead of a purpose used to spread as fast as people copied it. Now it spreads as fast as agents generate screens. The cost of a decision nobody thought through used to arrive slowly enough to notice and fix. With agents in the loop, it can be everywhere before anyone looks.

One decision fans out A single root decision branches into four components, and each component branches into four screens or pieces of agent output. The root is labeled stay with it; the leaves are labeled fan it out. One decision Components Screens and agent output Stay with it Fan it out
One decision near the root reaches every component, product and generated screen below it. Agents are very good at producing the leaves. Someone still has to stay with the root.

Sort the work before you fan it out

The breadth work on a design system is enormous and mostly thankless: ports, docs, audits, mappings, migrations. Agents are good at it, and running several at once is a sensible way to get through it. The mistake is treating every task as that kind of task.

Most design system work falls into one of two piles. Some of it sits near the root, where one decision reaches everything below. The rest sits at the leaves, where the decision is already made and somebody needs to carry it out consistently. You can fan the leaves out to as many agents as you can review. The root resists that, because what it needs is one person holding every constraint at once, and splitting it across threads breaks exactly that.

Fan it outStay with it
TokensPlatform outputs, bulk renames, contrast checksTier structure, naming, what "primary" means
ComponentsVariants, platform ports, stories and testsThe API contract: props, states, what a component refuses to do
AccessibilityAudits, alt text, lint rulesFocus, keyboard and announcement behavior for new patterns
DocumentationFirst drafts, examples, changelogsThe rules people and agents are told to follow
FigmaVariable syncing, Code Connect mappings, file auditsHow design and code name the same thing
GovernanceUsage reports, adoption trackingWhat not to add, and when to deprecate

Protecting the slow part

I don't have this solved. These are the things I'm trying, and some of them may not survive a busy quarter.

Root decisions get an owner and a block of uninterrupted days, with no agent sessions open. Before asking any model about the problem, the owner writes a first draft of the decision by hand. Writing it out is how you find the parts you don't understand yet, and an agent's draft tends to cover those gaps with fluent sentences.

Agents still help with root problems, in a different role. Instead of asking for the answer, I ask for the strongest case against my current one, for edge cases I haven't listed, or for how other public design systems handled the same choice. That widens what I'm thinking about without doing the thinking for me.

There's a limit on parallel threads, the way kanban teams limit work in progress. The exact number matters less than having one, because the list of things an agent could start is always longer than the attention available to review them.

And newer people get root problems on purpose. Pair them with someone senior on a token or API decision and let them sit with it for a week, even when an agent could produce something plausible by lunch. I'd expect that week to teach them more about design systems than a month of reviews would.

Is slow, single-threaded thinking still needed when agents can do this much? For a lot of software I can't tell. For design systems I'm fairly sure it is, and more than before, because a design system is where one careful decision gets copied into everything, first by people and now by machines.

Agents can cover the breadth faster than any team I've worked with, which is exactly why the root decisions deserve more of our attention. I don't know whether people starting out now will learn to stay with a problem until it gives something up. If they do, I suspect a lot of them will learn it on design system teams, because that's where skipping it costs the most.