Figma

Open Figma in the embedded thread view, optionally targeting a file with fileKey and a layer with nodeId.

open_figma_mcp_app_in_thread

Finds a Weave AI model by name so it can be run directly with weave_run_model — no Weave tool needed. Use this when the user names a model ("run nano banana 2 on this image", "make a video with veo 3"). A model is not a Weave tool: for a published Weave workflow use weave_list_tools and weave_run_tool instead. Returns the model with an approximate cost and the contract to run it with — its inputs and tunable params, each with a type, whether it is required, and any allowed values — or a short list of candidates to choose between when the name matches more than one model.

weave_find_model

Generates polished and fully editable presentation decks in Figma Slides, suitable for a wide range of use cases including pitches, slideshows, portfolios, readouts, workshops, research summaries, moodboards, training materials, retrospectives, event recaps, and strategic reviews. This tool produces visually refined, ready-to-edit decks that can be customized for personal, creative, professional, corporate, and creative contexts. Use this tool when you need a slide deck that communicates ideas, findings, or proposals in a visually compelling way. Decks are optimized for storytelling, clarity, and design consistency—ideal for presenting to teams, clients, stakeholders, or audiences. Do not use this tool for designing application UIs, websites, flow diagrams, or standalone marketing assets. For FigJam diagrams, use the generate_diagram tool instead. This tool requires the following parameters to generate high-quality outputs: objectives, outline, style, color palette, use case, and theme. This tool does not retain chat history or conversational context beyond what you provide in the current request. To ensure best results, include all relevant details directly in your prompt, describing your goals and constraints clearly and completely. The prompt should be self-contained and include all relevant details with the context in mind but without referencing earlier prompts. This tool will return up to three unique slide deck options, each including a thumbnail and Figma Slides URL for editing within Figma. These generated decks serve as starting points for refinement, collaboration, and final presentation design.

generate_deck

Create a flowchart, decision tree, gantt chart, sequence diagram, state diagram, or entity relationship diagram in FigJam, using Mermaid.js. Generated diagrams should be simple, unless a user asks for details. This tool also does not support generating Figma designs, class diagrams, timelines, venn diagrams, or other Mermaid.js diagram types. This tool also does not support font changes, or moving individual shapes around -- if a user asks for those changes to an existing diagram, encourage them to open the diagram in Figma. If the tool is unable to complete the user's task, reference the error that is passed back. Do not use the create_new_file tool prior to creating a diagram using this tool; generate_diagram creates its own files.

generate_diagram

Capture a live web page by URL into an *existing* Figma design file. Use this tool when the user wants to capture, screenshot, or push a running webpage (localhost or external URL) into Figma. REQUIRES an existing `fileKey` — if the user does not already have a Figma file, first call `create_new_file` (load the `figma-create-new-file` skill for the plan-resolution contract) and reuse the returned file_key here. Works with both local dev servers (localhost) and external websites. For LOCAL projects: explore the user's codebase to identify the page, dev server command, and URL before calling. Call this tool with a fileKey (no captureId) to get the capture script + a captureId, then poll with the captureId every 5 seconds (up to 10 times) until status is 'completed'. Each capture ID is single-use. The maximum capture size, including serialized images, is 50MB. USING generate_figma_design WITH use_figma: - For web apps, use BOTH tools in parallel: run this tool (generate_figma_design) to capture a pixel-perfect layout, and use use_figma with search_design_system to build the screen from design system components. - Once both complete, refine the use_figma output to match the pixel-perfect layout from this tool's capture, then delete this tool's output (it was used as a layout reference only). - For non-web apps (e.g. iOS), use use_figma only. - For updating/syncing a page already in Figma, use use_figma only.

generate_figma_design

Generate a raster image from a text prompt and place it directly in an editable Design, FigJam, or Slides file. If no editable file exists, call create_new_file first. Width and height guide the aspect ratio; the model chooses a supported output size, so the image pixel dimensions may differ from the requested values. Omit nodeId to create a new image-filled frame, or provide nodeId to replace an existing image fill without resizing it. Returns fileKey, nodeId, model, image metadata (including width, height, and image.url for downloading the full-resolution image), and curl instructions, plus an inline thumbnail preview. **This is a paid feature — each call consumes Figma AI credits against the destination file's plan (different models have different per-call costs).**

generate_image

Get structured component metadata including properties, variants, and descendant tree for a Figma component or component set. Returns property definitions with types and variant options, and a tree of descendant instances and text nodes with their property references. Designed for creating Code Connect template files. Use the nodeId parameter to specify a node id. Use the fileKey parameter to specify the file key. If a URL is provided, extract the node id and file key from the URL, for example, if given the URL https://figma.com/design/:fileKey/:fileName?node-id=1-2, the extracted nodeId would be `1:2` and the fileKey would be `:fileKey`. If the URL does not include `node-id`, ask the user for a node-specific URL. Do not pass an empty or guessed nodeId.

get_context_for_code_connect

Get a mapping of {[nodeId]: {codeConnectSrc: e.g. location of component in codebase, codeConnectName: e.g. name of component in codebase} E.g. {'1:2': { codeConnectSrc: 'https://github.com/foo/components/Button.tsx', codeConnectName: 'Button' } }. Use the nodeId parameter to specify a node id. Use the fileKey parameter to specify the file key. If a URL is provided, extract the node id and file key from the URL, for example, if given the URL https://figma.com/design/:fileKey/:fileName?node-id=1-2, the extracted nodeId would be `1:2` and the fileKey would be `:fileKey`. If the URL does not include `node-id`, ask the user for a node-specific URL. Do not pass an empty or guessed nodeId.

get_code_connect_map

Get AI-suggested strategy for linking a Figma node to code components via Code Connect. Workflow: call this tool → review suggestions with the user → call send_code_connect_mappings to save the approved mappings. Use the nodeId parameter to specify a node id. Use the fileKey parameter to specify the file key. If a URL is provided, extract the node id and file key from the URL, for example, if given the URL https://figma.com/design/:fileKey/:fileName?node-id=1-2, the extracted nodeId would be `1:2` and the fileKey would be `:fileKey`. If the URL does not include `node-id`, ask the user for a node-specific URL. Do not pass an empty or guessed nodeId.

get_code_connect_suggestions

Get design context for a Figma node — the primary tool for design-to-code workflows. Returns reference code, a screenshot, and contextual metadata that must be adapted to the target project. IMPORTANT: You MUST load figma-design-to-code guidance BEFORE calling this tool. Prefer the /figma-design-to-code skill if available; otherwise read the skill://figma/figma-design-to-code/SKILL.md MCP resource. NEVER call this tool without loading that guidance first — skipping it produces code that ignores the target project's existing components, design tokens, and conventions. Use the nodeId parameter to specify a node id. Use the fileKey parameter to specify the file key. If a URL is provided, extract the node id and file key from the URL, for example, if given the URL https://figma.com/design/:fileKey/:fileName?node-id=1-2, the extracted nodeId would be `1:2` and the fileKey would be `:fileKey`. If the URL does not include `node-id`, ask the user for a node-specific URL. Do not pass an empty or guessed nodeId. If the URL is of the format https://figma.com/design/:fileKey/branch/:branchKey/:fileName then use the branchKey as the fileKey. If the URL is of the format https://figma.com/make/:makeFileKey/:makeFileName then use the makeFileKey to identify the Figma Make file. Only for Figma Make files (URLs containing `/make/`), and only when calling get_design_context, assume the nodeId is `0:1`. The response will contain a code string and a JSON of download URLs for the assets referenced in the code. It will also include a screenshot of the node for context by default.

get_design_context

Generate UI code for a given FigJam node in Figma. Use the nodeId parameter to specify a node id. If no node id is provided, use `0:1` which is the root node ID. Use the fileKey parameter to specify the file key. If a URL is provided, extract the node id from the URL, for example, if given the URL https://figma.com/board/:fileKey/:fileName?node-id=1-2, the extracted nodeId would be `1:2` and the fileKey would be `:fileKey`. IMPORTANT: This tool only works for FigJam files (URL path `/board/`), not other Figma files.

get_figjam

Reads a generative plugin from the account library by id (from list_generative_plugins), returning its name, description, owner, version, and a manifest of its source files as { filename, bytes, uri }. Owner is the authenticated user's email when they own the plugin, or a public publisher handle otherwise. Read each file's contents from its uri as an MCP resource (contents are not inlined here). Only set includeSource to true to add source to each file when the MCP client cannot read MCP resources. Pass an optional version (commit SHA) to read a specific build; defaults to the latest.

get_generative_plugin

Get the design libraries associated with a Figma file. Returns two lists: (1) libraries currently added to the file (subscribed), and (2) libraries available to add (community UI kits and organization libraries). Each library includes its name, library key, description, and source type. The organization libraries portion of libraries_available_to_add is paginated — when the response includes a libraries_available_to_add_next_offset value, pass it back via the offset parameter to fetch the next page. Use the library keys from the response to scope searches with search_design_system by passing them as includeLibraryKeys.

get_libraries

IMPORTANT: Always prefer to use get_design_context tool. Get metadata for a node or page in the Figma desktop app in XML format. Useful only for getting an overview of the structure, it only includes node IDs, layer types, names, positions and sizes. You can call get_design_context on the node IDs contained in this response. Use the nodeId parameter to specify a node id, it can also be the page id (e.g. 0:1). IMPORTANT: This tool only works for Figma design files (URL path `/design/`). It is NOT supported for FigJam (`/board/`) or Slides (`/slides/`) files. This tool is not supported for Figma Make Files (URLs containing `/make/`). The nodeId parameter is optional: when omitted, the tool returns a list of the top-level pages (guid + name) in the document instead of an XML dump — use this when you don't yet know which page or node to drill into. When the user has a current selection relevant to the request, the response is prepended with a "Currently selected nodes:" block listing the selection by guid and name, so you can tell whether it matches the queried nodeId. If the URL includes `node-id`, extract it and pass it as nodeId; for example, if given the URL https://figma.com/design/:fileKey/:fileName?node-id=1-2, the extracted nodeId would be `1:2`. If the URL does not include `node-id`, do not set nodeId; omit the field so the tool lists top-level pages. Do not pass an empty or guessed nodeId. If the URL is of the format https://figma.com/design/:fileKey/branch/:branchKey/:fileName then use the branchKey as the fileKey.

get_metadata

Get keyframe animation data for a Figma node. Returns animated-node inventory, keyframe tracks with easing curves, pre-computed CSS/@keyframes and motion.dev code snippets, and timeline coordination hints for recursive calls. Use after get_design_context for motion-aware code generation. Use the nodeId parameter to specify a node id. Use the fileKey parameter to specify the file key. If a URL is provided, extract the node id and file key from the URL, for example, if given the URL https://figma.com/design/:fileKey/:fileName?node-id=1-2, the extracted nodeId would be `1:2` and the fileKey would be `:fileKey`.

get_motion_context

Generate a screenshot for a given node or the currently selected node in the Figma desktop app. Works on Figma design files (URL path `/design/`), FigJam boards (`/board/`), and Figma Slides (`/slides/`). The optional `maxDimension` parameter (positive integer, max 65536, default 1024) caps the longer edge of the rendered PNG in pixels — increase it when you need to inspect fine detail, decrease it for thumbnails or to save context. The JSON metadata entry in the response includes both `width`/`height` (the rendered PNG size) and `original_width`/`original_height` (the node's natural canvas size before any clamping), so callers can decide whether to re-request at a higher `maxDimension`. Use the nodeId parameter to specify a node id. nodeId parameter is REQUIRED. Use the fileKey parameter to specify the file key. fileKey parameter is REQUIRED. If a URL is provided, extract the file key and node id from the URL. For example, if given the URL https://figma.com/design/pqrs/ExampleFile?node-id=1-2 the extracted fileKey would be `pqrs` and the extracted nodeId would be `1:2`. If the URL does not include `node-id`, ask the user for a node-specific URL. Do not pass an empty or guessed nodeId. This tool is not supported for Figma Make Files (URLs containing `/make/`). By default this tool returns a short-lived URL to the screenshot plus curl instructions for downloading the PNG — the URL+curl path is strongly preferred because it uses far fewer tokens than embedding the image inline. The `enableBase64Response` parameter defaults to `false`. Only set `enableBase64Response: true` when the agent cannot fetch URLs (no shell access, no HTTP client, or a sandboxed environment that blocks outbound requests); when set, an inline base64 image entry is appended to the response in addition to the URL and curl instructions. If the URL is of the format https://figma.com/design/:fileKey/branch/:branchKey/:fileName then use the branchKey as the fileKey.

get_screenshot

Reads a shader effect or shader fill from the account library by id (from list_shaders), returning its name, description, owner, type, version, and a manifest of its source files as { filename, bytes, uri }. Owner is the authenticated user's email for their shaders, or figma for first-party shaders. Read each file's contents from its uri as an MCP resource. Only set includeSource to true to add source to each file when the MCP client cannot read MCP resources. Pass an optional version (commit SHA) to read a specific build; defaults to the latest.

get_shader

Get variable definitions for a given node id. E.g. {'icon/default/secondary': #949494}Variables are reusable values that can be applied to all kinds of design properties, such as fonts, colors, sizes and spacings. Use the nodeId parameter to specify a node id. Extract the node id from the URL, for example, if given the URL https://figma.com/design/:fileKey/:fileName?node-id=1-2, the extracted nodeId would be `1:2`. If the URL does not include `node-id`, ask the user for a node-specific URL. Do not pass an empty or guessed nodeId. This remote tool requires a concrete node target. This tool is not supported for Figma Make Files (URLs containing `/make/`). If the URL is of the format https://figma.com/design/:fileKey/branch/:branchKey/:fileName then use the branchKey as the fileKey.

get_variable_defs

Gets the output and status of Weave model runs started with weave_run_model. Pass the `predictionIds` those calls returned. This is for model runs only — for a run of a Weave tool (a published Weave workflow) use weave_get_tool_run_output instead. Poll this after weave_run_model to track progress and read the output. The response also includes curl instructions for downloading the outputs — the URL+curl path is strongly preferred because it uses far fewer tokens than embedding media inline.

weave_get_model_run_output

Gets the input contract of a Weave tool (a published Weave workflow) — the inputs you fill in to run it. Pass the `recipeId` (from weave_list_tools, or the `<id>` in a pasted Weave URL like app.weavy.ai/tool/<id> or app.weavy.ai/flow/<id> — that `<id>` is the recipeId). A pasted Weave URL is enough to inspect and run the tool right here — do not open a browser or use browser automation for Weave. Call this before weave_run_tool to learn what to send. Returns the tool `version` (pass it back to weave_run_tool), an `outputs` summary (what the tool produces), and a flat `inputs` list. Each input has a `nodeId` (the key you send in weave_run_tool), `name`, `type` (text, integer, boolean, select, seed, image, video, audio, 3D, color, or any), `default` (its current value), and `required` (true when the tool needs a value for it; if `default` is non-null it is used unless you override, otherwise you must provide one), plus `options` (for `select`), `range`, `isIterator`, and `description`.

weave_get_tool_inputs

Gets the output and status of runs of a Weave tool (a published Weave workflow). Pass the `recipeId` of the tool and the `runIds` returned by weave_run_tool; omit `runIds` to get the tool's most recent run. Returns each run's status (RUNNING, COMPLETED, FAILED, or CANCELED), progress, any error, and — when complete — a link to every output the run produced. Poll this after running a tool to track progress and read its output. Each output is a JSON entry with a `url`, its `type` (e.g. image, video), and, when known, `width`/`height`/`format`. The response also includes curl instructions for downloading the outputs — the URL+curl path is strongly preferred because it uses far fewer tokens than embedding media inline.

weave_get_tool_run_output

Lists the shader effects and shader fills used in a Figma file. Returns each shader as { id, name, description, type, version, published, truncated, files }, where type is "effect" (post-effect that samples an input raster) or "fill" (generates pixels directly), published indicates whether the shader is a published library version, and files is a manifest of its authored source files as { filename, uri }. When truncated is true, the manifest hit its 10,000-file safety cap and is not exhaustive. The top-level truncated field is true when a referenced shader could not be returned, including when the file references more than the 100 returned shaders. Read each file's contents from its uri as an MCP resource (contents are not inlined here). Requires view access to the file. Use this to inspect shaders in a file you can open, including ones you do not own. Source reads are pinned to the exact shader version referenced by the file.

list_file_shaders

Lists the generative plugins in the authenticated user's account library, including Figma's first-party plugins. Returns each plugin's id, name, description, and owner (plus a nextCursor when more pages exist). Owner is the authenticated user's email for their plugins, or a public publisher handle otherwise. Use the id with get_generative_plugin to read a plugin's source. Generative plugins are runnable tools that modify the canvas, distinct from shader effects and shader fills.

list_generative_plugins

Lists the shader effects and shader fills in the authenticated user's account library. Returns each shader's id, name, description, owner, and type (effect or fill), plus a nextCursor when more pages exist. Owner is the authenticated user's email for their shaders, or figma for first-party shaders. Use the id with get_shader to read either shader type's source.

list_shaders

Lists the Weave tools the authenticated user can run — published Weave workflows — in their active Weave workspace: their own, those shared with the workspace, and those shared with them directly. Here "tool" means a Weave tool (a published Weave workflow), not an agent/MCP tool. Use this when the user wants to see, browse, or choose from the Weave tools available to them. Returns the most recently updated tools and the total number available, each with its name, who created it, when it was last updated, and a link to open it in Weave. If the user already pasted a specific Weave URL (app.weavy.ai/tool/<id> or app.weavy.ai/flow/<id>), you already have its recipeId — that `<id>` — so skip this and go straight to weave_get_tool_inputs/weave_run_tool instead of opening a browser.

weave_list_tools

Runs a Weave AI model directly — no Weave tool needed — and returns a prediction id; poll it with weave_get_model_run_output. Call weave_find_model first for the model `id` and its `contract`. Running spends the user's Weave credits, so it is gated: a call without `acknowledgedCost` only quotes and spends nothing, returning `inputs_required` or `cost_confirmation_required` with instructions to follow. Always show the user the cost and get an explicit Approve/Cancel (a structured prompt, not free text) before echoing `acknowledgedCost` to run — every run, including reruns. Ask the user for any input you don't have; never invent one.

weave_run_model

Runs a Weave tool (a published Weave workflow) and returns run ids; poll them with weave_get_tool_run_output. A pasted Weave URL (app.weavy.ai/tool/<id> or app.weavy.ai/flow/<id>) is enough — never open a browser or use browser automation for Weave. Call weave_get_tool_inputs first to learn the inputs. Running spends the user's Weave credits, so it is gated: a call without `acknowledgedCost` only quotes and spends nothing, returning `status: "inputs_required"` or `cost_confirmation_required` with instructions to follow. Always show the user the cost and get an explicit Approve/Cancel (a structured prompt, not free text) before echoing `acknowledgedCost` to run — every run, including reruns — and confirm any auto-filled inputs (values you did not set that the run will use). Include the response's `costDisclosure` string as its own sentence after the question, not folded into it, the first time you quote a cost in a conversation; omit it after that. For a media input, pass the whole asset object from weave_upload_asset or a run output; pass external media as its https URL directly (only upload a local file). If the user wants an input you did not get from weave_get_tool_inputs, do not omit it or fold it into another input like the prompt — re-fetch weave_get_tool_inputs (its inputs can change) and set it.

weave_run_tool

Search for design system assets (components, variables, and styles). Returns matching assets from all design libraries. Use this when you need to find specific components, variables (e.g. colors, spacing tokens), or styles from design libraries. Pass `queries` as an array of objects, never strings. Each object must contain `entity` (`"component"`, `"variable"`, or `"style"`) and a string `query`. Example: `{"fileKey":"<file key>","queries":[{"entity":"component","query":"button"},{"entity":"variable","query":"surface"}]}`. Do not pass `{"queries":["button"]}`. Combine searches already required for the task in one call, without speculative terms, synonyms, variants, or checklist items. Results are returned in a `results` array in the same order as `queries`; each item repeats its `entity` and `query`.

search_design_system

Save multiple Code Connect mappings in bulk. Use after get_code_connect_suggestions to confirm and save approved mappings. Use the nodeId parameter to specify a node id. Use the fileKey parameter to specify the file key. If a URL is provided, extract the node id and file key from the URL, for example, if given the URL https://figma.com/design/:fileKey/:fileName?node-id=1-2, the extracted nodeId would be `1:2` and the fileKey would be `:fileKey`. If the URL does not include `node-id`, ask the user for a node-specific URL. Do not pass an empty or guessed nodeId.

send_code_connect_mappings

Import a local project into Figma Code. Requires edit access to a standalone Code or Design file. Does not create native Design shapes. Before choosing or creating a destination file, load figma-code-workflows. Target: standalone Code uses its empty main layer, including a starter. Design creates a new layer on pageId (default: first page). For populated Make, create a blank file. Same-target repair requires returned repairFrom: keep fileKey, seedId and makeNodeId; upload the corrected complete project. Changed or successful imports cannot be replaced. Legacy layers are unsupported. Start with the destination, omitting upload, to request instructions. Follow the returned source-configuration and archive guidance; local dependency installation, dev servers, HTTP checks and builds are not required. Static HTML/CSS/JS needs no setup scripts. Create the archive at nextStep.localArchivePath, then run nextStep.uploadCommand. Only after upload succeeds, call send_code_to_figma with nextStep.thenCall.arguments unchanged within one hour. upload.archivePath is a Figma storage path, never a local path. Keep makeNodeId/createLayer and any pageId/repairFrom unchanged. Do not resume failed uploads or retry ambiguous failures. Returns importReceipt, fileUrl, fileKey and nodeId. needs_setup preserves valid source with setupError; follow returned recovery instructions. Unsafe archives/access failures still fail. For import_pending, follow the continuation. Imported does not verify installation, preview or publishing. Open the file to start preview.

send_code_to_figma

You MUST load the figma-generative-plugins skill before calling this tool. If it is not installed, read skill://figma/figma-generative-plugins/SKILL.md with resources/read or get_figma_skill. Use this when the user asks to update, revise, or republish an existing Figma plugin, generative plugin, or custom tool in their account library. Updates an existing generative plugin in the authenticated user's account library. Provide the plugin id, existing authored files to replace, optional name and description metadata, and a required Git commit message describing the change. The update is built, versioned, and deployed; record the new version when the response includes it. Use create_generative_plugin first when no plugin exists.

update_generative_plugin

You MUST load the figma-shaders skill before calling this tool. If it is not installed, read skill://figma/figma-shaders/SKILL.md with resources/read or get_figma_skill. Use this when the user asks to update, revise, or republish an existing Figma shader, shader effect, shader fill, custom effect, custom fill, or procedural shader. Updates an existing shader effect or fill in the authenticated user's account library. Provide its id, matching kind, existing authored files to replace, optional name, description, animation, and mouse metadata, and a required Git commit message describing the change. The update is built, versioned, and deployed; the response includes the new version. Use create_shader first when no shader exists.

update_shader

Upload assets (images and SVGs) into a Figma file. Call with a "count" to get that many single-use upload URLs. POST raw asset bytes to each URL with the correct Content-Type header (e.g. image/png, image/jpeg, image/svg+xml). Each upload URL handles storage, BlobStore commit, and canvas placement automatically. Use nodeIds to set raster images as fills on corresponding existing nodes; its order matches the returned upload URLs. Returned upload entries include targetNodeId when a target was provided. Without a target node, creates new frames with image fills on currentPageId when provided, otherwise on the current page. SVGs (image/svg+xml) are imported as editable vector node trees on that page; nodeIds and scaleMode do not apply to SVGs. Supports PNG, JPG, GIF, WebP, and SVG. Max 10MB per asset. Works on Figma design files (URL path `/design/`), FigJam boards (`/board/`), and Figma Slides (`/slides/`). Request at most 60 upload URLs per call, then POST to every returned URL before calling upload_assets again. Repeat until all assets have been uploaded.

upload_assets

Uploads a local image or video file to Weave and returns the asset object to pass as the value for an image/video input in weave_run_tool. Returns a `submitUrl` and a `token`: POST the file to the submitUrl as multipart/form-data with a `file` field and the token in an `X-Weave-Upload-Token` header (e.g. `curl -F "file=@/path/to/image.png" -H "X-Weave-Upload-Token: <token>" "<submitUrl>"`); that POST returns the asset object. If you already have a reachable https URL, do not upload it — pass it directly to weave_run_tool. If the media exists only in this conversation (you have no path or URL for it), ask the user to save it and give you a path or URL. The token expires in about 10 minutes.

weave_upload_asset

Create, edit, generate, or sync any design in Figma — UIs, screens, mockups, components, frames, variables, styles, text, images, layouts, and design systems. This general-purpose tool writes to Figma with JavaScript via the Figma Plugin API. Works on Figma design files (URL path `/design/`), FigJam boards (`/board/`), and Figma Slides (`/slides/`). IMPORTANT: Before calling this tool, load figma-use guidance — prefer the /figma-use skill if available, otherwise read the skill://figma/figma-use/SKILL.md MCP resource if available. Skipping this causes common, hard-to-debug failures. Use this tool when the user wants to: - Create or generate a Figma design, screen, UI, or mockup from scratch, intent, or code - Update, edit, or sync an existing Figma design - Generate or sync Figma designs from source code - Set up or modify design tokens, variables, or styles - Build or extend a design system or component/variant library - Fix layout, spacing, auto-layout, or fill/hug issues - Add component descriptions, annotations and Code Connect metadata to nodes - Review or fix accessibility, contrast, typography, or visual polish - Inspect or query node properties programmatically CHOOSING BETWEEN use_figma AND generate_figma_design: - Default to use_figma for all write operations - Exception: generate_figma_design ONLY to capture a web app page/view for the first time. For web apps, run both in parallel — generate_figma_design captures a pixel-perfect screenshot, use_figma builds from imported design system components and refines against the screenshot - Non-web (iOS, Android, generic UI) and from-scratch designs: use_figma only - Updating/syncing a Figma page already captured: use_figma — even if source code changed GOTCHAS - For the font "Inter", the style is "Semi Bold", not "SemiBold" and "Extra Bold" not "ExtraBold" - MUST use `await figma.setCurrentPageAsync(page)` to change pages. Setting figma.currentPage is not supported - MUST NEVER use loadAllPagesAsync,setPluginData,createImageAsync. They are not supported API

use_figma

Returns the authenticated user's handle, email, all the plans the user belongs to (and the ID for each plan) and their seats on those plans. code_layers_enabled indicates whether the user has access to Code Layers in Design on any plan; each plan also includes code_layers_enabled for files owned by that plan. You MUST use this tool if you are experiencing file access/permission issues or are being rate limited by the Figma MCP to help debug the issue.

whoami