Figma Dev Mode MCP Server Links Design to Code, but UX Curation Remains Manual

- Reading
- 4 min
- Tables
- 1
Figma's Dev Mode MCP Server lets AI agents extract variables, components, and layout directly from the design file to generate code in the editor. What it solves from the classic handoff and where human UX review remains indispensable.
The problem manual handoff always had
The design team finishes a screen, exports specs, notes spacing and color in a comment, and sends the dev a link. The dev opens the file, looks for the variable, guesses the component name, and writes the CSS by hand. This cycle wastes time on both sides and is where accessibility details, hover state, contrast, and focus order get lost most often.
The Dev Mode MCP Server, described in Figma's official Help Center guide, tackles this specific point. It connects Figma to the code editor via the Model Context Protocol, the standard that lets an AI agent query external data sources during the conversation. In practice, the design file becomes just another context source the agent consults before writing code, in the same flow where it already reads the repository today.
How the flow works under the hood
Usage starts in Figma, not in the editor. In Figma Design, the designer right-clicks a frame or layer and chooses Copy link to selection. That link carries a node identifier (node ID) that the MCP server uses to know exactly which object to fetch, without opening the entire file.
In the editor, the developer pastes that link into a prompt and asks the MCP client (Cursor, Claude Code, VS Code with the extension, among others in the official catalog) to implement that piece. The client doesn't open the link as a page: it extracts the node ID, queries Figma's MCP server, and gets back variables, components, layout data, and auto layout for that specific node. It's this extraction that replaces the process of opening Figma, clicking each layer, and copying value by value by hand.
What already works today
The guide lists a set of capabilities that go beyond "generating CSS for a screen":
- Code generation from selected frames: useful for product teams building a new flow or iterating on an existing feature.
- Design context extraction: variables, components, and layout data straight into the IDE, built for teams working with a design system.
- Reading FigJam resources: early-stage diagrams and architecture maps become context for the code generated later.
- Code Connect: keeps generated code aligned with the real components in the repository, instead of reinventing markup on every call.
- Figma Specs via the
figma-specskill: the agent reads, creates, and updates the team's spec, logging decisions it makes during the work.
There's also a newer, more ambitious feature: writing back to the canvas. With the correct skill installed, the agent creates and updates frames, components, and variables directly in the Figma file, using the design system as the source of truth. This writing requires the remote MCP server and a Full seat license outside of drafts, and it's in free beta until it becomes a pay-per-use feature.
Two ways to connect, with different trade-offs
Figma offers two ways to connect the MCP to the editor, and the choice isn't neutral.
| Mode | Where it runs | Who should use it |
|---|---|---|
Remote server (https://mcp.figma.com/mcp) | Endpoint hosted by Figma, no need for the desktop app | Recommended for most people: broadest set of features |
| Desktop server | Local, via Figma's desktop app | Organization/enterprise-specific needs, requires a Dev or Full seat on a paid plan |
Government accounts follow a separate route, with their own endpoint (https://mcp.figma-gov.com/mcp) and a different toolset from commercial Figma, with no guaranteed plugin or skill parity.
Where UX curation is still mandatory
In short: the MCP server delivers the design's structural context (color, spacing, component hierarchy), but it doesn't deliver experience judgment. The Figma file rarely documents the expected focus order, image alt text, screen reader behavior, or the reasoning behind a contrast choice. That remains the work of whoever designs the screen, not whoever converts it into code.
The guide reinforces this by recommending the use of Code Connect to "improve output quality by reusing your real components": without this layer, the agent tends to reinvent generic markup instead of using the accessible component the team has already validated. Variable naming, HTML semantics, and ARIA attributes don't come from the design file; they come from whoever defines the design system and whoever reviews the generated code before the merge.
When it's worth adopting now
It makes sense to turn on the MCP server for teams that already have:
- A mature design system, with components and variables named consistently in Figma.
- Code Connect configured, so the generated code pulls the real components from the repository instead of recreating markup from scratch.
- A review process that includes an accessibility check after generation, not as an optional step.
Without these three things, the risk is flipping the problem: instead of spending time on manual handoff, the team spends time reviewing generated code that ignores the accessibility standards and naming conventions the design system had already solved. The MCP server speeds up the transcription from design to code; it doesn't decide, on its own, whether that design is ready for everyone to use.
Translated from the Brazilian Portuguese original · Read the original
Reference guide lists the UI edge cases that code-generating AI usually misses
Published this week on UX Collective, the document was born from a client's question during a workshop on agentic flows: why only review the AI's code afterward, if you can hand over the list of edge cases beforehand?





