The Figma MCP server is most useful to an agent as a context contract: it scopes a node and binds that node to variables, styles, and Code Connect components. Treating it as a code generator misreads the contract, and most failures are context-contract failures the agent can detect and correct. It speaks the Model Context Protocol, and that framing matters: the agent gets what it asks for, and the quality of the ask is the variable under its control.
This analysis is based on Figma’s official MCP documentation and help-center pages — we did not run the server hands-on.
What the Contract Actually Is
The contract is a scoped context request: the server returns selected design facts, not a finished implementation. Figma’s help center says “The MCP server isn’t a one-click way to turn designs into finished code,” and “Its job is to give your agent design context, not production-ready code.”
Scoping means the agent must name the node, section, or component it needs. Binding means connecting that node to get_variable_defs, get_code_connect_map, and published components via Code Connect. This is a design-system contract, not an export button. For component-level specs, see component spec files as an agent contract.
The Tool Surface: Read vs Write
The surface splits into two servers: the remote server at https://mcp.figma.com/mcp is the recommended path and needs no desktop app, while the desktop server runs locally in the Figma desktop app and is intended for specific organization and enterprise needs, requiring a Dev or Full seat on a Professional, Education, Organization, Government, or Enterprise plan, per MCP server docs. Figma for Government supports the desktop server only.
Read tools at tools and prompts: download_assets, get_code_connect_map, get_code_connect_suggestions, get_context_for_code_connect, get_design_context, get_figjam, get_generative_plugin, get_libraries, get_metadata, get_motion_context, get_screenshot, get_shader, get_variable_defs, list_file_shaders, list_generative_plugins, list_shaders, search_design_system, and whoami.
Write tools: add_code_connect_map, create_generative_plugin, create_new_file, create_shader, generate_diagram, generate_figma_design, generate_image, html_to_figma, send_code_to_figma, send_code_connect_mappings, update_generative_plugin, update_shader, upload_assets, and use_figma. The server also exposes one MCP prompt, create_design_system_rules.
What an Agent Actually Receives
An agent receives typed context objects: a lightweight XML outline from get_metadata, variable and style lists from get_variable_defs, a PNG from get_screenshot, download links from download_assets, and code-shaped context from get_design_context, per tools and prompts.
get_design_context is the main design-to-code tool. Its default output is React and Tailwind, and you can ask for Vue, plain HTML and CSS, or iOS. That shape is a transport choice, not a promise about the final codebase. download_assets returns download links, works with several layers at once, and supports SVG, PDF and JPG plus original uploaded images. Skills are Markdown files, such as foundational figma-use and the open-beta figma-spec skill for Figma Specs (Figma skills for MCP), and they reduce setup and guesswork without replacing the MCP connection or adding new capabilities. For related tool choices, see Figma agent tools.
Six Anti-Patterns That Break the Contract
Each anti-pattern is a contract violation that can be named and tested: large scope, wrong tool intent, expecting finished code, wrong framework, blind polling, and flat capture confusion, all traceable to Figma’s FAQ.
The Whole-File Dump
The agent asks for a file, page, or huge frame. Figma’s FAQ says large, deeply nested frames can overwhelm an agent, slow things down, or fail without an error. The failure is silent context loss, not a model defect.
Prompt-as-Tool Confusion
The agent asks for variables in prose but calls a tool that returns code. Figma advises naming the intent exactly, for example “Get the variable names and values for this selection.” The tool choice, not the prompt, determines the payload.
The Production-Code Expectation
The agent treats get_design_context output as finished implementation. The help center says the server gives design context, not production-ready code. The correct move is to bind the context to tokens and components before writing code.
Framework Mismatch
The agent requests a target framework that does not match the Code Connect mapping. The desktop server uses the mapping selected in Dev Mode; with the remote server, the agent sets clientFrameworks to the Code Connect label such as React or SwiftUI (tools and prompts). On Professional plans only one framework can be active at a time, changed by a team admin in Admin → Settings → Resources → Code Connect.
Limit-Blind Polling
The agent retries reads after a slow or incomplete result without checking the seat and plan. Figma’s MCP rate-limit docs set read limits by plan and seat, and a low-budget seat can exhaust monthly access quickly. The error is often the absence of an error.
Flat-Capture Confusion
The agent uses generate_figma_design when it needs maintainable library bindings. Figma’s docs say generate_figma_design captures a running app as flat Figma layers, fast but not connected to libraries, while use_figma builds with existing components and variables. Flat capture is useful for Figma Make exploration, but it is not a design-system binding.
The Contract as Computable Checks
The anti-patterns become executable checks when each rule is tested with documented tools only. The table below maps each rule to a tool, a trigger, and a corrective action; triggers come from Figma’s FAQ and tools and prompts.
| Rule | Check (documented tool) | Trigger | Action |
|---|---|---|---|
| Scope must be small enough for complete context | Call get_metadata for the proposed node and inspect the XML outline. |
Scope is a file, page, or deeply nested frame; or a request hangs, is slow, or returns incomplete results. | Rescope to a smaller section or single component, then call get_design_context. |
| Intent must bind to the tool, not prose | For variables or styles, call get_variable_defs; for design context, call get_design_context. |
Prompt asks for variable names and values, but response is code-shaped. | Re-request with get_variable_defs and exact intent: “Get the variable names and values for this selection.” |
| Code-shaped output is context, not implementation | Before emitting code, require get_variable_defs and get_code_connect_map, or get_code_connect_suggestions if mapping absent. |
Agent plans to paste get_design_context output as final code. |
Map output through variables and Code Connect bindings; publish components manually before completing mappings. |
| Framework label must match target | Call get_code_connect_map and inspect framework; for remote server, require clientFrameworks to be set to the Code Connect label. |
Target framework missing, differs from mapping, or Professional team has another active framework. | Set clientFrameworks or ask admin to change active Code Connect framework in Admin → Settings → Resources → Code Connect. |
| Read budget must be known before retrying | Call whoami to read seat and plan, then compare planned repeated reads against documented limits. |
Agent retries MCP reads after incomplete or slow result, or seat is Starter, View, Collab, or unknown. | Stop retrying, cache get_metadata and get_variable_defs, and rescope instead of re-running get_design_context. |
| Capture method must match maintainability intent | Inspect requested write tool: generate_figma_design for flat capture, use_figma for bound construction. |
Task requires library or variable bindings but uses generate_figma_design, or task needs quick flat capture but assumes bound components. |
Use use_figma for existing components and variables; use generate_figma_design only when flat layers are acceptable. |
How to Verify a Run
Verification is a sequence of documented tool calls: whoami reports the seat, get_variable_defs reports variables and styles, get_code_connect_map reports binding status, and get_metadata or get_screenshot expose incomplete scope without a thrown error, per tools and prompts.
A good run shows a bounded scope, a non-empty variable list when the selection uses variables, a framework label matching the target, and a Code Connect map or suggestion set. An empty variable list is not always failure, but it is a signal to confirm the selection. A missing framework label is a stronger failure. Error-free incompleteness is the worst signal, because the agent may continue from partial context. For token coverage checks, see token intent coverage.
Limitations
The contract is constrained by product status and access: write-to-canvas output is beta quality, writing outside drafts requires the remote server plus a Full seat, and the feature is free during the beta period but will eventually become usage-based paid, per MCP server docs.
Each write tool call can return up to 20 KB; use_figma cannot add new images on its own, while upload_assets and generate_image do that; importing components that contain images or videos, and creating GIFs, are not supported yet; fonts must be uploaded to your Figma account, so fonts installed only on your computer are unavailable; components must be published manually before Code Connect mappings can be completed.
Client support is allow-listed: only clients in the Figma MCP catalog can connect, and the documented table lists roughly 30 clients including Claude Code, Cursor, VS Code, Codex, Gemini CLI, Warp and Xcode beta. Community reports describe token bloat qualitatively, without percentages. For export-side comparison, see Figma-to-code exporters through an agent lens.
Figma MCP at a Glance
MCP reads are budgeted by plan and seat, while the listed write tools and whoami are exempt, and generate_figma_design and use_figma differ by whether layers remain bound to libraries and variables, per MCP server docs and tools and prompts.
| Surface | Documented behavior | Rate-limit status |
|---|---|---|
MCP read tools, except whoami |
Return design context, metadata, screenshots, assets, libraries, variables, Code Connect maps, motion, shaders, and identity. | Starter, View and Collab: up to 20 per month; Full or Dev on Professional: 200 per day, 10 per minute; Organization: 200 per day, 15 per minute; Enterprise: 600 per day, 20 per minute; Education matches Professional Full or Dev. |
| Exempt tools | add_code_connect_map, create_new_file, generate_figma_design, and whoami are exempt from MCP read limits. |
Exempt. |
| Figma AI-credit actions | generate_image and Figma Make prompts are Figma AI-credit actions. |
Do not count against MCP limits. |
generate_figma_design |
Captures a running app as flat Figma layers, fast but not connected to libraries. | Write tool. |
use_figma |
Builds with existing components and variables. | Write tool. |
FAQ
Frequently asked questions resolve to documented behavior: the server returns context, the remote server is recommended, large selections fail, and generate_figma_design and use_figma differ by binding, per Figma’s help center and tools page.
Does the Figma MCP server write code?
No. Figma’s help center says the server gives agents design context, not production-ready code, and it describes designs in a React and Tailwind-shaped format because models are trained on web code. Agents should treat the output as input for their own framework, token, and component mapping decisions, not as finished implementation.
Which server should an agent use?
The remote MCP server at https://mcp.figma.com/mcp is the recommended path and needs no desktop app, per Figma’s MCP docs. The desktop server targets specific organization and enterprise needs and requires a Dev or Full seat on an eligible plan. Writing outside drafts needs the remote server plus a Full seat.
Why does a large selection fail?
Figma’s help center says large, deeply nested frames can overwhelm an agent, slow things down, or fail without an error. A hung, slow, or incomplete result is a scoping signal, so the agent should rescope to a smaller section or single component before retrying.
What is the difference between generate_figma_design and use_figma?
Per Figma’s tools page, generate_figma_design captures a running app as flat Figma layers, fast but not connected to libraries, while use_figma builds with existing components and variables. Use the latter when the design system contract matters. The former is useful for quick capture, not for maintainable bindings.
The Bottom Line
The design principle is to treat every Figma MCP call as a contract check: scope the node, bind tokens and components, and let the agent implement, because Figma’s help center says the server gives design context, not production-ready code. The server’s value is not code emission; it is a documented context surface that can be verified, limited, and corrected. For memory around those contracts, see design-system agent memory.
How This Guide Was Built
This guide was built from Figma’s MCP docs, Figma’s help center, and Figma’s blog, source-checked on 2026-10-29. This analysis is based on Figma’s official MCP documentation and help-center pages — we did not run the server hands-on. Figma’s blog says Affirm’s PMs, engineers and designers report “orders of magnitude” velocity gains and rebuilt major product flows in fewer than two days; treat that as a vendor claim, not a general result.