Until recently, the only way to provide design context to AI tools was to feed an image of a design or an API response to a chatbot. This has changed with the recent advent of Model Context Protocol (MCP), a standard for how applications provide context to LLMs. We set out to apply this standard with Figma’s MCP server, which allows developers to bring context from Figma into agentic coding tools like Copilot in VS Code, Cursor, Windsurf, and Claude Code. Whether it’s creating new atomic components with the proper variables and stylings or building out multi-layer application flows, we believe this server will provide a more efficient and accurate design-to-code workflow.
As a beta, this is only the beginning. Over the coming months, we plan to release a slew of updates, including features like remote server capabilities and deeper codebase integrations. With your feedback, we’ll continue to iterate on and expand our offering. You can provide feedback directly to us through this form. There’s a lot more to come, but first, let’s take a step back to share how we got here.
Context is everything
Today, LLMs can create workable code. But if you ask a tool to write code with no other context beyond its training data, its output-while usable-likely won’t match the patterns found in the rest of your codebase. This is because every team approaches their codebase differently-with a different structure, framework, vocabulary, and workflow-and makes decisions that evolve their codebase based on their specific needs. All these differences compound into a unique fingerprint that’s difficult for LLMs to infer.
Recognizing and understanding these patterns requires additional context, and this is where agentic coding tools come into play. They gather context-from reading existing code, examining repository history, accessing documentation, and understanding database schemas-and feed it to LLMs so they can generate code in your IDE that’s precise, informed, and in line with your existing systems. MCP servers like Figma’s MCP server add onto this by bringing outside context from other tools like Figma into that workflow, so your code doesn't just match the fingerprint of your codebase, but that of your design, too.
Design context is critical for going from design to code. When it comes to understanding design intent, we need to consider a range of information that could be valuable based on what we’re asking an LLM to do. Getting this information right is important because the process of translating design to code is more than detailed inspection.
How we translate design intent for LLMs
When a developer opens a Figma file, the first thing they probably do is zoom all the way out to get a sense for order and structure. Then, they might process a sequence of screens or inferred logic, thinking about how they could structure the feature across different files in code. They audit as they build, making sure the patterns are right, interpreting placeholder content as something real they need to retrieve from the backend. Throughout the process of implementing a design, they’re generating different types of code and working across different altitudes-from under-the-hood details to higher-level patterns. To ensure that design intent translates to code, LLMs also need this holistic picture.
The Figma MCP server paints this picture for LLMs in a few key ways, supplementing visual information with more nuanced details around design intent, while also drawing from existing patterns and systems. Different tasks might require different combinations of these points of context, and often, the context we exclude is just as important as what we provide. This is why MCP servers, like ours, surface tools that represent specific types of context for LLMs. Our server also allows you to configure settings to give you control over what those tools return. Here’s a look at when to consider dialing up and down these points of context-depending on your setup and what you want to prioritize.
Pattern metadata
Since you have limited space in an LLM’s context window, the more information you can provide, the better. By giving the LLM the context from your designs, the fewer tokens it uses. If you’ve already invested in a design system and leverage patterns like components, variables, and styles that are aligned between design and code, the Figma MCP server is a multiplier-we want to make sure that the LLM can benefit from these patterns, too. Agentic search techniques can take quite a bit of time to locate the right patterns, especially in large codebases. They may also find valid patterns that stray from those referenced in a design. By providing references to specific variables, components, and styles, the Figma MCP server can make generated code more precise, efficient, and reduce LLM token usage.
In this article we illustrate how to bulk add code syntax to a variable collection with the plugin API and how alignment between design and code can streamline the handoff. If you only provide a screenshot of a component instance, the AI tool will spend a lot of time searching the codebase-like icon and component libraries-to identify the right component to use. If it doesn’t find a match, it will likely create a new component based on the screenshot. By contrast, if Figma knows which components you’re using, it can share the exact path to the code file the agent needs with Code Connect. Similarly, if you take a screenshot of a red rectangle and prompt your agentic tool to use tokens, there might be many different tokens with the same red value. Figma knows which specific token is used, and can provide the name of that variable to the LLM via MCP. Even better, if you have provided code syntax in Figma for that variable, the Figma MCP server can provide that exact code to the LLM.
An example of the Code Connect and variables code syntax metadata that the Figma MCP server provides for a selection.
Screenshots
Designers often use imagery to represent a piece of interactive content-like using a picture of a map in a design to represent a live embedded map experience. In these scenarios, metadata may not fully communicate that interactive functionality to an LLM. With a screenshot, the Figma MCP server can provide that design context.
Teams build all types of complicated and compelling designs, and it’s often helpful to zoom out and think about the high-level view of a design before diving into the details. For example, when you’re trying to get a sense for the overall context-sequence of screens, sections, mobile and desktop responsive context-a high-level screenshot can provide the LLM information about the relationship between sections and nodes, and capture the overall flow in a way that style details can’t.
The value of this kind of visual information is more about what it tells us about design intent than it is a spec for the LLM to replicate one to one. The right code is aligned to design intent, not just pixels. We like to think of screenshots as supplemental information for the code response; a screenshot combined with Figma’s code outputs performs better than either on their own.
Interactivity and content
Code examples can describe design behavior already defined in Figma, or already connected to the codebase. Pseudocode, which you can think of as a code prototype, is often a great way to give an LLM context that’s more effective than simply describing properties-especially if the pseudocode is also informed by the codebase, with features like code syntax for variables and Code Connect for components. This sample code can be helpful in a few scenarios, like when you’re looking to describe a fully encapsulated piece of functionality. A psuedo-representation of a stateful component is useful to an LLM in a way that a tree of Figma metadata is not. It’s also useful to represent a sequence of UI-rather than inspecting them independently as metadata-to focus on the differences between them.
An example of the React and Tailwind code the MCP server provides by default. In this case, it’s a working React representation of this image gallery. LLMs can make use of this interactive code representation as they incorporate this design into the codebase.
Content
We want to make sure that we’re getting what’s implied by a design out of Figma, too. Even placeholder content in Figma can be representative of design context and informative for LLMs. Content like text, svg, images, layer names, and annotations can help LLMs derive how to fill the interface with the data model on the code side. Here we can see that the text and layer names for the current Figma selection show up in the MCP server’s React output and allow the LLM to tell us quite a bit of information about the design.
Design-informed code generation
Many developers are already using AI to work more efficiently in their IDEs, and we’re excited to accelerate those workflows while keeping output consistent and at a high fidelity. Today, that starts with three tools in the MCP server that allow you to get context from Figma for the current selection or specific node: one for code, another for images, and a third for variable definitions. You can change the type of response the code tool returns inside your server settings, which allows for fine tuning based on the task at hand. You can enable the more interactive code representation with React and Tailwind, with more options to come down the line. Code Connect ensures that generated code aligns with your codebase, allowing you to see component mappings and any code syntax you add for your variables will also be surfaced.
As we launch the Figma MCP server in beta, we’re looking for your feedback on current capabilities, which will inform what we build down the line. Based on early testing, we’re already working on a few improvements, starting with making the MCP experience available without needing the Figma desktop app, so it’s easier for teams to onboard and collaborate from anywhere. We’re also working on a deeper codebase integration and simpler Code Connect experience with a more intuitive setup. Future versions will explore features that support annotations, Grid, and more. This is just the first step in our commitment to building a better design-to-code experience with faster handoff, smarter outputs, and more efficient workflows. You can access Figma’s MCP server with any Dev or Full seat, and look out for more updates as we continue to invest in this space.
Note: We're quickly improving how Figma supports AI agents. Create and modify native Figma content directly from your MCP client. Note: This feature requires the remote Figma MCP server. We're quickly improving how Figma supports AI agents. This feature is continuously being improved. Turn live UI from your browser (production, staging, or localhost) into editable design layers in Figma. This feature is continuously being improved. Select a Figma frame and turn it into code. Pull in variables, components, and layout data directly into your IDE. Access content from your FigJam diagrams and use it in your code generation workflow. Gather code resources from Make files and provide them to the LLM as context. Boost output quality by reusing your actual components. Desktop MCP server: Runs locally through the Figma desktop app. Learn how to install the desktop MCP server. The desktop MCP server is primarily for specific use cases for organizations and enterprises. Connect the MCP server to your editorFollow instructions for your specific editor to connect to the Figma MCP server, either locally or remotely. Skills don’t replace MCP connections or add new MCP capabilities. Tip: For the latest list of supported editors and clients, check out our MCP Catalog.

Figma + developer workflows | design systems, Code Connect, MCP, and Make
Prompt your MCP client
The Figma MCP server introduces a set of tools that help LLMs translate designs in Figma. Once connected, you can prompt your MCP client to access a specific design node. For a complete list of tools and examples, see Tools and Prompts. First, follow the instructions to install the Figma MCP server for your preferred MCP client. For other MCP clients, follow the instructions in your client's documentation for adding MCP servers. See the table under Connect the MCP server to your editor for links.
Example: Get design context. Getting design context and code from files is link-based. Your client won't be able to navigate directly to the selected URL, but it will extract the node ID that is required for the MCP server to identify which object to return information about.
Example: Send UI to Figma. Note: Currently available using the remote Figma MCP server with certain clients. Follow the steps your client provides. Let your client know when you're finished. Press enter or click to view image in full size.
Have you ever wondered why something that looks perfect in Figma somehow feels… different once it goes live in the product? Every product team has lived this frustration. Designers craft beautiful, pixel-perfect interfaces. Developers open those same files, ready to build. And yet, somewhere between artboards and code files, the magic slips away. The spacing is off by 2px. The brand color is just slightly different. A component gets rebuilt from scratch instead of reused. A feature takes days longer than planned because “the design handoff wasn’t clear.” It’s nobody’s fault, just a broken workflow. But what if the design didn’t have to be translated at all? What if the design could speak code? That’s where Figma’s MCP steps in. MCP connects your Figma files directly to AI-powered coding tools, almost like giving your designs a voice. Instead of developers manually inspecting layers and copying values, the AI reads the design’s structure, styles, components, and spacing rules - and generates code that respects them.
No more “Did we use the right button variant?” No more “Is this the correct spacing token?” No more guessing. Just design → context → code. For the first time, building what designers imagine is no longer a translation task. It’s a handoff that actually lands.
What Is MCP?
For Non-Technical Readers: MCP is like a universal translator between design tools (like Figma) and AI coding assistants. Instead of manually copying design specifications, AI can directly read your Figma files and generate matching code. For Technical Readers: The Model Context Protocol is an open standard created by Anthropic that allows AI agents to interact with external data sources through a standardized interface. You provide a URL to tell the AI what to work with.
The Selection-Based Approach (Desktop)
The desktop server is selection-based. Whatever you select in Figma becomes the context: Select a frame or component in Figma desktop. In your code editor, prompt the AI. The AI reads your current selection automatically.
MCP vs Traditional Figma-to-Code Tools
How They Differ
Press enter or click to view image in full size
When to Use Each
Use Traditional Export Tools When: Building quick prototypes, Creating marketing pages or landing pages, Starting from zero with no existing codebase, Need immediate, standalone output
Use Figma MCP When: Working on production applications, Have an established codebase, Need code that matches your patterns, Want iterative design-to-code workflow, Building complex, scalable systems
Competitor Landscape
Design-to-Code Platforms, AI-Powered Full-Stack Builders, and How They Compare to Figma MCP. Key differentiator: Traditional tools export code once. AI builders create full apps from scratch. Figma MCP makes design a living reference that AI coding assistants continuously consult during development, working within your existing workflow and codebase.
Security & Authentication
How Authentication Works and What Data Is Shared? MCP Servers Send: Design structure and properties, Design tokens and variables, Component metadata, Layout constraints. Limitations & Challenges: Current limitations, What MCP Doesn’t Do: Generate backend logic automatically, Connect to your database, Understand business rules, Write tests (though AI can). Quality Depends On: How well your Figma files are organized, Clarity of your AI prompts, Your coding tool’s AI capabilities, Whether you use Code Connect, Your design system maturity.
Key Takeaways
- For Product Managers: MCP reduces design-to-development time significantly; maintains design consistency in production; reduces back-and-forth between teams; requires investment in proper Figma file organization.
- For Designers: Your Figma files become source of truth for implementation; better organization directly improves code quality; you can verify implementation accuracy more easily; learn basic code concepts to write better prompts.
- For Developers: Accelerates initial component scaffolding; reduces manual CSS calculations; respects your architecture with right prompts; still requires code review and refinement.
- For Business Leaders: Faster time-to-market for features; more accurate implementation of designs; reduced miscommunication costs; requires team training and process updates.
Future of MCP and AI integration
The MCP team continually updates the protocol, with new releases shipping multiple times a month. MCP is an open standard, so the larger AI community can contribute to the roadmap. We can expect more focus on security in future releases: authentication, authorization, and data filtering or privacy mechanisms for specific domains (like healthcare or finance). If MCP grows to wide adoption, entire portions of the AI industry may begin optimizing their use of MCP. Model developers might start to include MCP tool usage in their training data, and LLM orchestration frameworks (e.g., LangChain) may support MCP as a first-class citizen in their use cases. Over time, MCP could become the de facto standard for connecting AI to the entire digital landscape of tools and services. Bringing data and actions from external systems into LLM experiences will become increasingly plug-and-play in the AI ecosystem. For developers, that translates into fewer bespoke wrappers, better AI tools, and more time to build the features users really value. For companies shipping data-rich apps, it means instant compatibility with every MCP-enabled AI platform.