Figma's Dev Mode MCP Server: what changes in handoff when AI reads the file's variables and components directly

- Reading
- 7 min
- Tables
- 1
Figma's official guide details what the Dev Mode MCP Server exposes to agents like Cursor and Claude Code: variables, components, layout and, now, the ability to write back to the canvas. Traditional handoff doesn't survive as is.
Figma documented in an official guide how the Dev Mode MCP Server works, the server that connects Figma files to AI agents like Cursor, Claude Code, GitHub Copilot and other clients compatible with the Model Context Protocol. The core idea isn't new: give the agent design context to generate code. What the document makes clear is how much has changed since the first beta version: the server doesn't just read the file, it also writes back to it.
For anyone building this workflow today with Cursor or Claude Code pointing at a Figma file, the practical question is no longer 'can you connect it'. It's another one: exactly what data the agent sees, and what needs to change in the handoff process for that data to mean something once it reaches the code editor.
What the agent actually reads from the file
The feature that matters most for a handoff workflow is what Figma itself calls 'extract design context': pulling variables, components and layout data straight into the IDE. That's different from inspecting CSS generated in classic Dev Mode. The agent receives the file's actual structure, not a visual translation of it.
Access is link-based, not free-form search across the entire file. The flow described in the guide is:
- In Figma, right-click the desired frame or layer and choose Copy link to selection.
- Paste that link into the MCP client (Cursor, Claude Code, etc.) and ask it to implement the design.
- The client doesn't open the link: it extracts the node ID that the server uses to identify exactly that object and return the data associated with it.
This means the agent never has the entire file as context by default, only the pointed-to node. A deliberate decision by Figma, and one that changes how a team organizes handoff: instead of exporting a screen, someone needs to point to the right node, with the right name, for each task.
Messy variables and components become messy code
The point that most affects anyone working with design systems is that the MCP server doesn't interpret design intent, it reports the file's literal structure. If a color variable is called Fill/Blue-500 on one screen and azul-primario on another, the agent receives these two strings as if they were different concepts, because they are.
The guide explicitly recommends using the design system as a 'source of truth' so the agent builds and updates frames, components and variables consistently. In practice, this pushes a responsibility that used to belong only to design discipline into the code delivery workflow: variable naming and component structure stop being aesthetic preference and become an API contract consumed by an AI.
Code Connect stops being optional
One of the features mentioned in the guide directly addresses the problem of the agent 'reinventing' a component instead of reusing what already exists in the code: Code Connect. It maps Figma components to the actual components in the repository, and the MCP server uses that mapping to keep generated code aligned with what already exists in the codebase.
Without that mapping, the most likely scenario is an agent generating a button from scratch, with brand-new HTML and CSS, when the team already has a tested, versioned Button in the code design system. That breaks precisely the MCP's productivity promise: generating code that looks like it came from the team itself, not from an intern with no context about the repository.
In teams without Code Connect configured, the speed gain still exists, but it comes with a hidden cost: more manual review to catch components that are duplicated or diverge from the design system.
Handoff stops being one-way
This is the change that the 'redesigned handoff' angle captures best. The guide describes two features that reverse the traditional direction of the design-to-code flow:
- Writing directly to the canvas: with the server's remote version and a Full seat, the agent can create and update frames, components, variables and auto layout inside Figma itself, not just generate code from it. The feature is free during the beta period and will become usage-based billing.
- Generating design from live UI: the agent captures pages, elements or entire flows from an application in production, staging or
localhostand turns them into editable layers in Figma Design, for later alignment and refinement.
If design has always been the starting point and code the endpoint, these two features break that straight line. A code prototype can become a reviewable design; an agent can change the design file without a human ever opening Figma. This requires the team to define, in writing, who has canvas write permission and how changes made by an agent get reviewed before becoming a design system standard, something no classic handoff tool (Zeplin, Dev Mode inspect) had to solve.
Specs, FigJam and Make: context that used to vanish, now persists
The guide also covers three sources of context that would normally get lost between ideation and implementation. The figma-spec skill, in open beta, lets the agent read, create and update the team's requirements specs, including logging decisions made during the work back into the spec. FigJam content (diagrams, architecture maps) and Make files (prototypes) also become context available for code generation.
In practice, this tries to solve a well-known problem: a decision made on a brainstorming board that never reaches the developer because no one wrote it down formally. It's worth noting that writing to a spec via MCP requires the remote server and edit access to the file, so it's not a feature available to every collaborator by default.
Remote or desktop: the choice changes what you get
Figma offers two ways to connect the server, and they aren't equivalent in features:
| Remote server | Desktop server | |
|---|---|---|
| How it connects | Endpoint hosted at mcp.figma.com/mcp | Local, via Figma's desktop app |
| Plan requirement | Recommended for most | Dev or Full seat on Professional, Education, Organization, Government or Enterprise |
| Feature scope | Broader set (includes canvas writes and live UI capture) | Geared toward specific organization/enterprise needs |
For small teams or those without an Enterprise plan, it isn't really a choice: the remote server is the only path to the newest features, like writing to the canvas and capturing live UI.
Who already supports it, and what's still missing
The guide's client table shows Cursor, Claude Code, VS Code, GitHub Copilot CLI, Amazon Q, Gemini CLI, Codex (OpenAI), Replit, Warp, Xcode, Android Studio and JetBrains Junie among the clients with some level of support for the remote or desktop server. Not all support canvas writing, a feature restricted to the remote server, and not all support skills, which reduce the chance of the agent calling MCP tools in the wrong order.
This means the same prompt ('implement this frame') can produce quite different results depending on the client used, not just the AI model behind it. Before standardizing a team workflow, it's worth checking the updated list in Figma's MCP catalog, since client support changes frequently.
Where this breaks down if the design system isn't ready
The MCP server amplifies what was already true in classic Dev Mode: tooling doesn't make up for a poorly maintained design system, it just exposes the problem faster. A file with duplicate variables, components without Code Connect mapping and inconsistent naming across screens will generate inconsistent code, only now in minutes instead of days, and reviewed by an agent with no historical context to know which name is right.
The handoff worth redesigning, then, isn't just the 'export to the dev' step. It's the process before it: who audits variables and component names before a link gets passed to an agent, who approves what an agent writes back to the canvas, and who keeps the Code Connect mapping updated as the design system evolves. Without that groundwork, the MCP server just speeds up the production of code that someone will have to redo later.
Translated from the Brazilian Portuguese original · Read the original
Product design needs to stop producing information and start designing decisions
Between AI-generated research, summaries, and decks, there's plenty of data and little judgment. The point designer Patrizia Bertini raises is about what this demands from those who design decision flows.





