My Beef with Agentic Design Systems
I build with agents every day. That’s exactly why this term worries me.
Let me get the disclaimer out of the way, because it matters for everything that follows. I am not an AI skeptic. I run a design systems practice that uses agents at nearly every step. I’ve built MCP servers, written about context-based workflows, and spent the better part of two years arguing that design systems need to become machine-legible or get left behind. I want agents in the loop. I want more of them.
So when I say I have a beef with “agentic design systems,” understand that it isn’t a beef with agents. It’s a beef with one specific move that the term smuggles in, and that most people repeating it haven’t noticed they’re endorsing.
Here’s the move: handing the judgment layer of a design system to an autonomous agent loop that no human owns.
That’s the whole problem. Everything else is just tooling, and the tooling is great.
The sleight of hand
If you read the current discourse, “agentic design system” gets defined something like this: infrastructure that lets AI agents autonomously read, reason over, and build with your components, tokens, and guidelines, observing, detecting, fixing, and learning inside a self-healing loop. That’s a close paraphrase of Into Design Systems’ guide, which is about as canonical a definition as exists right now.
Most of that sentence is fine. The legible context, the structured metadata, agents reasoning over your system and generating against it, all of that is real and useful work. I do it. You probably should too.
The word doing the quiet damage is autonomously, sitting right next to self-healing loop. Because there are two completely different things bundled inside the word “agentic,” and the term deliberately blurs them:
Architecture: are agents acting in a loop? That’s a capability question. Answer: yes, and good.
Governance: who owns the loop, and who’s accountable for the calls it makes? That’s an authority question. And “agentic design system” answers it by quietly removing the human.
These are different axes. You can have agents doing enormous amounts of work with a human owning every gate. You can also have an agent-to-agent loop running with nobody in the path. The first is a power tool. The second is the thing I’m objecting to. The term treats them as the same thing, and that’s the sleight of hand.
A design system is a governance technology
Strip away the Figma libraries and the Storybook instances and ask what a design system actually is. It’s a set of decisions an organization has agreed to and committed to enforcing over time. What does “primary action” mean here. When do we break our own grid. Does this thing deserve to exist as a component at all, or are we about to enshrine a one-off into the canon forever.
Those aren’t generation problems. They’re judgment calls, and they carry consequences the organization is accountable for, to its users, its engineers, its brand. A design system is, underneath all the tooling, a way of encoding collective judgment and holding people to it.
You can automate a lot of what surrounds that judgment. You cannot delegate the judgment itself to a process with no name attached, because the moment something ships wrong, “the agent loop decided” is not an answer anyone can stand behind.
Worth noting: the serious people pushing this term mostly agree. The same Into Design Systems guide states plainly that agents should not run fully autonomously and that some decisions will always need human judgment. Vicente Garcia puts it well in his piece on design systems for agents: a design system has to expose judgment, not just components. My quarrel isn’t with them. It’s that the marketing around “agentic” outruns what its own proponents will actually defend, and the cheap reading drops the human-judgment caveat entirely.
This is the part I’d push hardest. I’m not claiming a human will always produce a better component than an agent. That’s a capability claim, and capability claims have a shelf life. The models keep getting better, and I’m not going to write a sentence today that an upgrade makes me eat in eighteen months. The durable claim isn’t about skill. It’s about ownership. Even if an agent makes an identical call to the one I’d make, that call still needs a human who owns it. Accountability doesn’t transfer to a loop.
What actually separates this from vibe coding
When I first started chewing on this, someone asked me a sharp question: isn’t an agentic design system just vibe coding a design system?
At the generation step, yes, they look identical. Intent goes in, an agent produces a component. Freeze the frame there and you can’t tell them apart.
The difference is what happens next. Vibe coding is defined by what comes after generation, which is nothing. You eyeball it, it feels right, you move on. The defining trait is abdicated verification, and for a throwaway prototype that’s completely fine. That’s the right amount of process for work that doesn’t need to last.
A design system exists for the opposite reason. Its entire job is to kill drift and hold many surfaces to one standard over time. So the verification step isn’t optional. It’s the reason the thing exists at all. Done right, agent generation is followed by a hard gate: token conformance, lint, accessibility checks, design parity, evals at every layer. The agent doesn’t get to feel done. It has to pass, and a human owns what “pass” means.
I’m not alone on this. Brad Frost, in his recent session on agentic design systems, frames the path forward as vibe coding maturing into “vibe engineering,” with coverage on one side and validation, including human sign-off, on the other. That’s the same instinct: the generation is cheap, the gate is where the value lives.
Which gives you a clean test for any “agentic design system” claim you encounter. Ask: what rejects the agent’s output, and who decided the rule it’s being rejected against? If the answer is a human-owned gate, it’s the real thing. If the answer is “another agent checks it” all the way down, you’ve built vibe coding with extra infrastructure and a more confident logo. And that version is arguably worse than a person vibe coding in a scratch repo, because it launders drift through the authority of the system. The output looks sanctioned. It came from “the design system.” Nobody chose it.
The honest part nobody likes to say
Here’s what I think is actually happening. A design system is hard, slow, unglamorous work. It takes practitioners who understand the product’s intent making hundreds of small judgment calls over a long life cycle. “Agentic design system,” in its laziest reading, is being sold as the cheap way out of all that. Point the agents at it, let them self-heal, walk away.
The generation is the easy 80%. The judgment and the enforcement are the hard 20%, and the hard 20% is the entire point. Automating away the part that was easy and calling the result “agentic” gets the ratio exactly backwards.
Where I actually land
I want to be precise, because it would be easy to read this as a retreat, and it isn’t.
Use agents everywhere. Harness them hard. Put them on generation, on documentation, on conformance checking, even on authoring the evals. The more capable they get, the more of the mechanical work they should absorb. I’m not protecting anyone’s job here. I’m protecting the outcome.
The line is simple. Agents do the work between the gates. Humans own the gates and the judgment calls. The instant you remove the human from the judgment layer and let the loop close on itself, you don’t have a more advanced design system. You have a faster way to generate confident, unowned drift.
That’s the distinction I’d draw between a context-based approach and the fully autonomous version the term implies. Not agents versus no agents. Owned judgment versus abandoned judgment.
So, no beef with agents. Deep beef with the quiet little word that says nobody has to be responsible anymore.
References
Into Design Systems, Agentic Design Systems: The Complete Guide — the canonical definition I’m contesting, and the source that also concedes agents shouldn’t run fully autonomously. https://www.intodesignsystems.com/agentic-design-systems
Vicente Garcia, Design Systems for AI Agents: The New Paradigm Shift — on why a design system has to expose judgment, not just components. https://medium.com/@vicentegrafico.com/design-systems-for-ai-agents-the-new-paradigm-shift-ad097cfae228
Brad Frost & Storybook, Agentic Design Systems in 2026 — coverage plus validation, and the vibe-coding-to-vibe-engineering framing. https://bradfrost.com/blog/post/agentic-design-systems-in-2026/
Further reading worth a look: Supernova’s 2026 enterprise design systems trends for the mainstream “agents orchestrating the design-to-code pipeline” position this piece pushes against.