- Published by
- Helena Duppre
- Date
- Updated
- Category
- digital design
- Reading time
- 5 min
The agent opens your Figma file and believes everything it finds
keywords: design system, applied ai, figma, design tokens
In the third quarter of 2026, usage of Figma's MCP server tripled and write-back, when AI changes the file, quadrupled. The agent works with the design system it finds, and a badly named design system becomes the wrong screen faster. I walk through the bridge I built on Maestro to keep Figma and code from drifting apart.
Back in August I wrote that your site's first reader isn't a person. It stuck with me, and I noticed the design file has joined the same line, with one extra detail: this reader now writes too.
Figma released its third-quarter numbers on November 4, and somewhere between revenue and margin there was a line that made me stop. Between July and September, total usage of Figma's MCP server tripled compared with the previous quarter. Write-back usage quadrupled.
MCP stands for Model Context Protocol, the bridge an AI tool, like the Claude Code I use, goes through to talk to a Figma file. Reading was already possible: the agent takes a frame and generates code from it.
Writing is possible too. Since March, in beta, the agent can work straight on the canvas using the file's own components and variables. The release doesn't break write-back down by tool, so there's no way to tell how much of the jump came from that.
In the same release, MCP shows up as Figma's fastest-growing product by weekly active users, and on the investor call Dylan Field, co-founder and CEO, put that at about 1 million.
It's a company talking to investors, with no absolute numbers, and writing to the canvas is free while the beta lasts, which helps any curve. So I read it as a snapshot of the moment. Even after discounting the enthusiasm, a lot of people are letting an agent open a design file and work on top of it.
What does the agent do with what it finds in the file?
It uses all of it. I'll start with what Figma itself says, because it's the source with the least reason to exaggerate against its own product. The MCP documentation has a page on how to structure your file so the agent can generate code from it, and it opens by saying that the quality of what the agent builds depends on that context and on how you ask.
Then comes the list, full of old friends. It asks for components for whatever repeats, variables instead of hardcoded values, clear names on layers and components, and auto layout instead of absolute positioning. And it asks for Code Connect, which links the Figma component to the one in code; without it, the page says, the agent has to guess.
From here on, the reading is mine. If the agent works with what it finds, it also inherits what's wrong: the button with three names, the color sitting loose as a hex value, the token that exists in Figma and disappeared from the code. None of that strikes it as odd, and it repeats it across several screens at once.
Wasn't this already true for people?
It was, and that's why the change interests me. On Paragon, Signify's B2B e-commerce project (Signify is a lighting company), I decided to name things by function, tokens and layers alike, in a design system with three brands. One designer's file made no sense to another, and the devs got lost.
The reader I had in mind was the colleague who opened the file after me and, when something looked odd, came to ask. The agent tends to move on with what it read. To the agent, the design system is the context, and a badly named design system turns into the wrong screen at a speed no team of people ever reached.
How do I deal with this on Maestro?
Maestro is an AI-powered training platform I'm building in Flutter, and the code for its screens is written by Claude Code under my direction. The design system lives in two places: the Figma variables and the Dart theme.
I decided tokens would have the same name on both sides, and an automated test checks the names. That test has a limit, which I wrote down in the case: it checks the name and leaves the value out. A token can have the same name on both sides and a different color on each.
Since the agent reads the code to build the next screen, a color that changed only in Figma never reaches the app. And one that changed only in code leaves Figma out of date, waiting for the next person (or the next agent) to copy the old value.
So, in early November, I built a private Figma plugin with Claude Code, the Figma ↔ code bridge. It talks to a server that runs only on my Mac, on localhost and with a key, and compares the variables in Figma's six collections with the Dart theme classes.
The panel lists each difference and says where it came from: the code, Figma, or both. To know that, the bridge keeps a snapshot of the last sync. Without it, a value the bridge writes to Figma would look like a new change and travel back to the code, in an endless echo.
Why doesn't the bridge decide on its own?
Because choosing which version is right is a design decision, and that one I don't want to outsource. The panel suggests a direction based on the project's rule, which today is "code wins": the app is what people use and what the agent reads. I choose, item by item, whether to push the value or leave it for later.
The opposite direction, from Figma to code, is built and tested, and stays switched off while that rule holds. Deleting and renaming call for extra care, because a variable deleted in Figma disappears from dozens of widgets. For now, the bridge only detects and lists those cases, and carrying them out is left for the next round.
And nothing becomes a commit without passing the design system tests. If they fail, the bridge puts the file back the way it was and shows the error in the panel. The agent writes fast on both sides, and the bridge exists so the call on who's right reaches me, one item at a time.
Where would I start with your design system?
Open the file as if you were the agent. Look for a component by the name you'd use to ask for a screen: if the Figma name, the code name and the name the team says out loud are three different things, the agent will pick one of them for you.
Next, look for loose hex colors on the component pages. Each one is a spot where the agent copies the value instead of the token, and the next palette change won't reach it.
If Figma and code give the same token different names, start by making the names match. It takes work (on Maestro, renaming the tokens turned into a migration in phases), and it's the step that gives the agent a single source to check. The bridge, the tests and the panel come later, once the names match and the problem becomes the value.
A well-named design system has always helped people joining the team. Now it also helps whoever joins without being a person, reads everything at once and asks nothing before starting.
A kiss, and see you next time!
If you want to go to the source:
- Figma, Inc. (2026). Figma Announces Third Quarter 2026 Financial Results, press release of November 4, 2026, Exhibit 99.1 to the Form 8-K filed with the SEC (link). Total MCP usage up 3x and write-back up 4x quarter over quarter, and MCP as the fastest-growing product by weekly active users between July and September.
- Figma, third-quarter 2026 earnings call, transcript by The Motley Fool (2026) (link). Dylan Field's remark about roughly 1 million weekly active users on MCP.
- Colyer, M. (2026). Agents, meet the Figma canvas, Figma blog, March 24, 2026 (link). Agents writing to the canvas with the file's components and variables, in beta.
- Figma. Structure your Figma file for better code, Figma MCP server documentation (link). Output quality depending on context, and the list of practices: components, variables, clear names, auto layout and Code Connect.
Enjoyed this piece?
Read next

Your site's first reader isn't a person
In a Pew study of 900 people, when Google showed an AI summary, clicks on a search result fell from 15% to 8%. Clicking a link inside the summary happened on 1% of visits. Whoever reads your site first is now a machine, it doesn't run your JavaScript, and what it understands is a design decision.
9 min read
Eight thousand keystrokes an hour
In 1986, data entry workers in São Paulo were falling ill with tenosynovitis, and labor inspectors went to see what was behind it: production bonuses, no breaks, overtime. The fight that followed produced the NR-17 Brazil has today. A post about the map of ergonomics and about a rule that bans using the on-screen timer to rush someone.
6 min read
Nobody lets go of anyone's hand… oops, I meant AI's
I've always led by giving people room and letting go as soon as I could. With AI, human review became a fixed part of the process, on purpose. A reflection on human-in-the-loop and on the fatigue a study published in Harvard Business Review called AI brain fry.
3 min read
loading comments...