My LinkedIn feed has a new favorite genre: “Company X kicks out Figma.” First Meta, then Atlassian, now Revolut. Somebody is already asking who is coming to Figma’s funeral.
I’ll say it: I think Figma is slowly dying. Why draw static frames when agents can build working apps on top of your design system in seconds? With agentic design tools and a design system exposed via MCP, it barely matters whether you use Claude Design, Open Design or something else. The graphics tool is no longer where UI gets made.
What matters more is what’s happening underneath the headlines: design systems are turning into infrastructure for AI agents. And that changes what a design system is, where it lives and who should own it.
What Actually Happened
Two stories caught my attention in the last few months.
Meta open-sourced a design system it has been building for eight years. As Dominic Nguyen (founder of Chromatic & Storybook) summarized it: code only, no design files. Meta calls it “AI-fluent” and built it around agent-first workflows. It’s reportedly used by around 13,000 internal apps, and it’s documented with Storybook. You can look at it yourself: astryx.atmeta.com.
Revolut is moving its designers off Figma. According to a post by Guillermo Flor, Nik Storonsky noticed one team designing much faster than the others. What that team did:
- Gave an LLM Revolut’s design system at the code level
- Prompted it to build new flows on top of that system
- Got a live interface they could click through on a laptop or phone instead of static frames
The reported result: three to four times faster. Now that workflow is being rolled out to every designer at Revolut.
The Pattern: Code Is the Design Surface Now
Put both stories side by side and the pattern is obvious. In both cases the design system is not a Figma library with a code implementation trailing behind. The code is the design system. Design files are no longer the end state.
Back in February, I was already arguing that design tokens don’t belong in Figma. They belong in the codebase, structured in the W3C format, as the single source of truth. Not because this alone would kill Figma, but because it points to a bigger shift: the design tool is no longer necessarily the source of truth. What’s new is the reason it suddenly matters so much: agents.
An LLM can’t do much with a Figma frame. It can do a lot with:
- Typed components with clear props and sane defaults
- Design tokens in a structured, validated format
- Documentation and usage rules it can read
- Stories and examples that show how things are supposed to be combined
Give an agent that, and it builds real, clickable interfaces that are on-brand by construction. Give it a pile of screenshots and it guesses.
What “AI-Fluent” Actually Means
If agents are going to create a large part of our UI, a design system needs two things at the same time:
Constraints. Component primitives with sane defaults, a limited set of tokens, clear rules about what goes where. Constraints are what keep generated UI consistent. Without them, every prompt produces a slightly different button.
Flexibility. Strong theming and composition, so the same primitives can serve many products and brands. Meta’s number is telling here: when AI makes it cheap to build internal apps, the number of apps explodes. Scaling frontend infrastructure stops being optional.
In practice, an AI-fluent design system looks a lot like a well-built design system always should have looked:
- Tokens as code — versioned, validated against the W3C Design Tokens spec, transformed for every platform
- Components as code — accessible, typed, tested, documented in Storybook
- Rules as text — guidelines written so both humans and agents can follow them, close to the code
- A feedback loop — linting, visual tests and reviews that catch it when an agent (or a human) leaves the guardrails
The difference is that “nice to have” items like machine-readable docs are now load-bearing. If your rules only exist in a designer’s head or in a Confluence page nobody reads, an agent won’t follow them either.
The Heart, Not the Buttons
A design system is not just a collection of nice buttons and form fields. It’s the heart of your frontend architecture. And what good is the fittest body if the heart fails?
In an agentic workflow, that dependency gets even stronger. Your design system is now the context every agent works with. It defines what your product can look like, how fast new flows are built and how consistent they turn out. If that foundation belongs to someone else, so does a big part of your velocity.
External component libraries can be a great starting point. I’m not against them. But the more critical they become for your product, the more important it is to take back control of your own components. Especially in enterprise environments, where products live for many years and a license change can hit dozens of applications at once.
That’s why at my main job we started moving to our own design system a while ago. Not because of agents at first, but it turns out to be exactly the foundation they need.
Independence is often worth more in the long run than the development time you save in the short run.
So, Is Figma Dead?
Not overnight, but I believe it’s on its way out. Who still needs a graphics tool when an agent turns a prompt plus your design system into a clickable app on a laptop or phone? Static frames have to be redrawn, handed off and rebuilt. A generated prototype already is the product, built from your real components.
Exploration and sketching won’t disappear, but they’re moving too: into agentic design tools, into the browser, into code. Whether that’s Claude Design, Open Design or the next tool doesn’t really matter. They’re interchangeable. What isn’t interchangeable is the design system they all build on. The source of truth is code, because that’s what agents can read, test and build on.
Where to Start
If you want your design system to be ready for this:
- Own your foundation. Know which parts of your UI depend on third-party libraries and what happens if their license or pricing changes.
- Move tokens into code. One versioned JSON source, validated in CI. If you still use Figma, it consumes the tokens instead of producing them.
- Expose your design system to agents. An MCP server for your components, tokens and guidelines gives every agentic tool the same context.
- Document for machines too. Write usage rules and component guidelines in the repo, in plain text, next to the components.
- Try the Revolut workflow on a small scale. Give an agent your components and tokens and let it build one real flow. You’ll quickly see where your system is missing constraints.
- Make specs part of the system. I built a Design System extension for Spec Kit for exactly this: giving spec-driven, agent-assisted development the design system context it needs.
The companies in the headlines didn’t win because they dropped a tool. They won because their design system was already code, already structured and already theirs. That’s the part worth copying.
How do you see it? Is your design system ready for agents, or still living in design files?
