Cursor Talk to Figma MCP is a tool that allows Cursor AI to directly read and edit your Figma design files, calling get_selection (get selections), set_text_content (batch modify text), create_rectangle (create rectangles), set_instance_overrides (set component instance override properties), and more. The configuration process is simple: when installing the bun runtime, execute the bun setup and bun socket commands, and then add the Figma plugin. This tool helps you eliminate the time of frequently switching between operational contexts, automate repetitive tasks such as text replacement and batch synchronization of overlay attributes, accelerate the “design-to-code” workflow, and ensure that everything is synchronized, making the development and build process more efficient and accurate.
Cursor Talk to Figma MCP。 Its core goal is clear – to allow large models running in Cursor to communicate with Figma through MCP (Model Context Protocol) to read and modify design files.
It’s not a “AI automatically does the design for you” kind of tool, nor is it a complete design-to-code platform, but a more underlying capability exposure layer: encapsulating some of Figma’s operational capabilities into MCP tools for Cursor to call.
The whole mechanism can be understood as a three-tier structure.
The top layer is Cursor, which is responsible for interacting with large models.
In the middle is the MCP service process, running locally.
The bottom layer is bridged to the Figma document through plugins.
Local services typically run based on buns , initialize bun setup dependencies, and start communication services through . bun socket The Figma plug-in is responsible for sending information such as the current document content and selected nodes to the MCP service through sockets. MCP then exposes these abilities to Cursor in the form of “tools”.
From the capability level, it provides a set of callable interfaces, such as:
get_selection: Gets the currently selected nodeset_text_content: Modify text content in batchescreate_rectangle: Creates a rectangular nodeset_instance_overrides: Sets the override attribute of the component instance
These interfaces don’t make any “automatic design judgments”, they just abstract Figma’s operations into structured instructions. It is the large model that really determines the call logic.
The project itself does not claim to achieve “real-time two-way synchronization” or “complete design transcoding system”. It simply establishes a controllable channel that allows large models in Cursor to:
- Read the current design structure
- Modify node properties
- Bulk update text or instance overrides
Whether or not you use it for “design-to-code” depends on how you orchestrate your prompts in Cursor.
To give a more technical way of understanding:
The previous process was that developers would open Figma, look at the dimensions and styles, and then write the code manually.
The current pattern is that the model can read the design structure and generate code based on the structure.
However, the project itself is only responsible for the ability to “read” and “operate”, not the “code generation logic”.
Therefore, if you look at it from a rigorous point of view, it is closer to:
A bridge service that encapsulates Figma document manipulation capabilities into MCP tools.
Instead of a full AI design automation platform.
Its value lies in reducing the cost of context switching. You don’t need to constantly jump back and forth between the design software and the editor. The model can directly obtain the current selection content, modify the text, and adjust the instance attributes to achieve batch replacement or structured update.
Especially in repetitive operation scenarios such as large amounts of text replacement and component instance overwrite synchronization, this capability will significantly reduce manual intervention.
It demonstrates a pattern –
Through MCP, the capabilities of local software are opened to large models.
It can be Figma, but it can also be an IDE, a video editor, a database client, or even a CAD tool.
If you move from design to development, or if you focus on the “design-code automation” path itself, these types of projects deserve more attention than just “AI-generated code”. Because it solves the problem of contextual access, and contextual access is the prerequisite for all agent capabilities.
Strictly speaking, this project is not about automation itself, but about the interface infrastructure of automation.
Github：https://github.com/grab/cursor-talk-to-figma-mcp
Tubing: