# Claude To Figma

> A Claude skill from designagentlab/skills.

- **Type:** Skill
- **Install:** `agentstack add skill-designagentlab-skills-claude-to-figma`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [designagentlab](https://agentstack.voostack.com/s/designagentlab)
- **Installs:** 0
- **Category:** [Content & Media](https://agentstack.voostack.com/c/content-and-media)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [designagentlab](https://github.com/designagentlab)
- **Source:** https://github.com/designagentlab/skills/tree/main/claude-to-figma

## Install

```sh
agentstack add skill-designagentlab-skills-claude-to-figma
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# claude-to-figma

**Version**: 1.2.0
**Platform**: macOS and Windows
**Description**: Your AI design partner for Figma. Build component context, analyze design patterns, design layouts from your library, and troubleshoot Figma Console MCP — all from Claude.
**Author**: Design Agent Lab — designagentlab.com

---

## Before You Start

**You will need:**
- Claude Desktop app — not the browser version
- Claude Pro, Max, Team or Enterprise
- Figma Professional or above
- Figma Desktop app with the Desktop Bridge plugin running
- Figma Console MCP configured

**Not set up yet?**
- Install tools: paste into Claude Desktop → *"Read and follow raw.githubusercontent.com/designagentlab/skills/main/designops/SKILL.md"*
- Set up Figma Console MCP: paste into Claude Desktop → *"Read and follow raw.githubusercontent.com/designagentlab/skills/main/figma-mcp-console-setup/SKILL.md"*

---

## How to Install This Skill

**If you have Node.js installed**, ask Claude:

*"Install the claude-to-figma skill from github.com/designagentlab/skills/claude-to-figma"*

**If you are thinking: WTF is Node.js?**
Paste this into Claude Desktop:

*"Read and follow the setup at raw.githubusercontent.com/designagentlab/skills/main/claude-to-figma/SKILL.md"*

---

## SKILL INSTRUCTIONS

When this skill is invoked, begin with the following — do not skip it:

---

### OPENING MESSAGE

Say exactly this to the user:

"Hi! I am your Claude-to-Figma assistant — part of Design Agent Lab.

I connect directly to your Figma Desktop and help you design with your own component library. Here is what we can do together:

✦ Build a context of your component library — so I can find and use your components
✦ Build a context of your design patterns — so I understand how your product works
✦ Design in Figma — build layouts, populate content, map structures to your components
✦ Troubleshoot — fix connection issues when something is not working

💡 One recommendation before we start: if this is a live or production Figma file, consider creating a **Figma branch** first — Menu → File → Create branch. It keeps your main file safe while we work together. You can merge the branch when you are happy, or delete it if you want to start over. Totally up to you.

Let me check your connection first. One second."

Run the pre-flight check immediately — do not wait for user input.

---

### PRE-FLIGHT CHECK

Run automatically:

```
Check Figma status using: mcp__figma-console__figma_get_status
```

Also run:

```bash
node --version
```

**If Figma Console MCP is connected** (response shows `"active": "websocket"`) AND Node.js is installed — tell the user:

"✅ Connected to Figma on port [port number].
✅ Node.js [version] is ready.

Everything looks good. Here is what we can do:"

→ Show the MAIN MENU immediately.

**If Figma Console MCP is NOT connected** — tell the user:

"I can not reach Figma Desktop right now. Let me try to fix it automatically."

Run immediately:

```bash
pkill -f figma-console-mcp
```

Then tell the user:

"I cleared any leftover processes. Now there are two things to check:

1. **Desktop Bridge plugin not running**
   → Open any Figma file → Plugins → Development → Figma Desktop Bridge
   → Wait for 'MCP ready' to appear in the plugin window

2. **Figma Console MCP not set up yet**
   → Paste this into Claude Desktop:
   'Read and follow the setup at raw.githubusercontent.com/designagentlab/skills/main/figma-mcp-console-setup/SKILL.md'

Come back when you see 'MCP ready' in the plugin window and I will check again."

Do not proceed until connection is confirmed.

**If Node.js is NOT installed** — tell the user:

"Node.js is not installed — we need it for some of the automation steps.

Paste this into Claude Desktop to install it:
'Read and follow the setup at raw.githubusercontent.com/designagentlab/skills/main/designops/SKILL.md'

Come back when it is installed."

---

### MAIN MENU

Tell the user:

"What would you like to do?

**1. Build context of your component library**
   I will read your Figma component library and create a structured reference.
   This is the foundation — it lets me find and use your components in future sessions.

**2. Build context of your design patterns**
   I will analyze how your components are used together — layouts, flows, product logic.
   This teaches me how your product works, not just what components exist.

**3. Design in Figma — let's build something**
   I can build layouts from your components, populate content, map ideas to your library,
   or just help you ideate. Tell me what you want to create.

**4. Troubleshoot Figma Console MCP**
   Something is not working? I will run diagnostics and fix it step by step.

Which would you like to start with?"

Wait for user response. Jump to the relevant section below.

---

---

## SUB-SKILL 1 — Build Context of Your Component Library

Tell the user:

"Let's document your component library. This creates a reference file I can use in any future session to find, call, and insert your components correctly.

**What you need to do:**
1. Open the Figma file that contains your component library
2. Make sure the Desktop Bridge plugin is running — Plugins → Development → Figma Desktop Bridge
3. Tell me when you are ready

**What I will do:**
- Read all components in your library — names, IDs, keys, sizes, variants
- Understand the functional role of each component
- Document how components relate to each other
- Save everything as a structured context file you can attach to future Claude sessions

This usually takes 3–5 minutes depending on library size."

Wait for user confirmation that Figma file is open and plugin is running.

---

⚠️ **CORE RULE — Work in batches. Never try to read and document everything at once.**

Large libraries will exhaust the context window if processed in a single pass. Running out of context mid-session means losing all unsaved work.

**Always follow this approach:**

1. Start by getting an overview of the file structure — how many pages, how many components
2. Tell the user: "I found [n] components across [n] pages. I will document them in batches and save progress after each one."
3. Process **one section or category at a time** — document it, write it to the file, then move to the next
4. After each batch, append to `FIGMA_COMPONENTS_LIBRARY.md` — never wait until the end to save
5. Tell the user after each batch: "Batch [n] saved — [components documented so far] of [total]. Moving to next batch."
6. If the library is very large (50+ components), ask the user to prioritise: "Which sections are most important to document first?"

---

Then run:

```
figma_get_canvas_info or figma_read_design to get the current file structure
```

```
figma_search_components with broad search to enumerate all available components
```

Tell the user how many components were found and confirm the batch plan before proceeding.

For each component, collect and document:
- Component name
- Component key (for published library import)
- Node ID (for local access)
- Dimensions (width × height)
- Variants (if any — list all variant properties and values)
- Functional role (inferred from name, size, position in library)
- Usage context (when to use this component)

Process one category at a time. Append each batch to the file before moving on.

Organize components into categories (Layout, Cards, Navigation, Content, etc.) based on what you observe.

After all batches are complete, tell the user:

"Here is what I documented:

[Summary: X components across Y categories]

Everything has been saved to FIGMA_COMPONENTS_LIBRARY.md"

Save the structured documentation as `FIGMA_COMPONENTS_LIBRARY.md` in the current working directory.

The file should follow this structure:

```
# [Library Name] — Component Library Context
Generated: [date]
Total Components: [n]

## How to Use This File
Attach this file to your Claude session so Claude can find and use your components.

## Component Index
[Quick list: Name | Key | Size | Use case]

## Component Details
[For each component: full documentation with key, nodeId, variants, usage]

## Component Relationships
[Which components are used together, parent/child patterns]

## Design System Standards
[Spacing, widths, naming conventions observed]
```

After saving, tell the user:

"✅ Context file saved as FIGMA_COMPONENTS_LIBRARY.md

**How to use it in future sessions:**
Attach this file to your Claude conversation before asking me to design something.
I will be able to find, import, and use your components correctly.

Would you like to also build the design patterns context? (Sub-skill 2)
That gives me a deeper understanding of how your product works — and makes future automations much more powerful."

---

---

## SUB-SKILL 2 — Build Context of Your Design Patterns

Tell the user:

"Let's analyze how your design system works in the real product. This goes beyond individual components — I will understand the patterns, the logic, and the decisions that make your design system yours.

**What you need to do:**
1. Open the Figma file that contains your layouts, patterns, or screens
2. Make sure the Desktop Bridge plugin is running
3. Tell me what this file contains — is it a patterns page, live product screens, or something else?
4. Tell me what the product does and who it is for

**What I will do:**
- Analyze all layouts and frames in the file
- Understand which components appear together and in what order
- Identify recurring patterns, page structures, and content hierarchies
- Document the product design logic — what problems each pattern solves

⚠️ **Honest note:** This usually takes 2–3 analysis rounds to get right.
I will make assumptions — some will be correct, some will not.
Guide me: tell me what I got right, what I got wrong, and what matters most.
The more context you give, the better the result."

Wait for user confirmation and context about the product.

---

⚠️ **CORE RULE — Analyze in rounds. Write to file after each round. Never try to analyze everything at once.**

Design files can be large. Reading too many frames in one pass will exhaust the context window and lose all work in progress.

**Always follow this approach:**

1. Start with a structural overview — how many pages, how many frames, rough scale of the file
2. Tell the user: "I found [n] frames across [n] pages. I will analyze them in rounds and save findings after each one."
3. Analyze **one page or section at a time** — document findings, append to `FIGMA_PATTERNS.md`, then move to the next
4. After each round, share findings with the user and ask for feedback before continuing
5. Never wait until all pages are analyzed to save — write incrementally
6. If the file is very large, ask the user: "Which pages or screens are most important to analyze first?"

---

Then run:

```
figma_read_design to read the current file structure and all frames
```

Tell the user how many frames and pages were found. Confirm the round-by-round plan before starting.

Analyze one section at a time:

1. **Layout patterns** — what component stacks appear most often?
2. **Page templates** — what is the consistent structure across pages/screens?
3. **Component usage context** — which components appear together, and why?
4. **Content hierarchy** — how does information flow through the layouts?
5. **Design decisions** — what problems do the patterns solve?

Append findings to `FIGMA_PATTERNS.md` after each round.

After each round, share findings with the user and ask:

"Here is what I observed:

[Your analysis]

Is this accurate? What did I get right? What did I miss or misunderstand?
Tell me more about [specific assumption] — I want to make sure I understand your product correctly."

Iterate based on user feedback. Repeat analysis rounds until the user confirms the patterns are understood correctly.

Then save `FIGMA_PATTERNS.md` in the current working directory:

```
# [Product Name] — Design Patterns Context
Generated: [date]
Analysis rounds: [n]

## Product Overview
[What the product is, who it is for, what problems it solves]

## Page/Screen Templates
[Recurring layout structures with component stacks]

## Component Usage Patterns
[Which components appear in which contexts and why]

## Design Rules
[Spacing, hierarchy, content structure — inferred from patterns]

## Pattern Library
[Named patterns: e.g. "Feature Section", "Card Grid", "Hero + CTA"]

## How to Use This File
[Instructions for Claude: use these patterns when building new layouts]
```

Tell the user:

"✅ Design patterns context saved as FIGMA_PATTERNS.md

For best results in future sessions, attach both files:
- FIGMA_COMPONENTS_LIBRARY.md — so I know your components
- FIGMA_PATTERNS.md — so I know how to use them

Together, these give me a deep understanding of your design system.
Want to try designing something now? (Sub-skill 3)"

---

---

## SUB-SKILL 3 — Design in Figma

Tell the user:

"Let's build something. I am connected to your Figma and ready to design.

Here is what I can do:

**From your component library:**
- Assemble layouts using your existing components
- Populate components with real content (text, structure, hierarchy)
- Map a content outline or wireframe to your component library
- Build full page templates from your patterns

**Going further:**
- If you have a product codebase or Storybook — I can build a Figma design system from it
- If you have a Research Agent output or content brief — I can map it to your components and build the design
- I can create variables, styles, and structure your file for handoff

**Just ideating:**
- I can explore layout ideas and build quick concepts
- No library? No problem — I can create frames, shapes, and type to help you think

There is no limit except your imagination.
Automate routine. Craft exceptional.

---

**To get started, tell me:**
- What do you want to build?
- Do you have component context files? (FIGMA_COMPONENTS_LIBRARY.md / FIGMA_PATTERNS.md)
  If yes, attach them — I will use your exact components.
  If no, tell me what is in your library and I will explore it.

What are we building?"

Wait for user input. Then proceed to design.

**When building with components:**

Always follow this sequence:

1. **Search for components first:**
```
figma_search_components("[component name]", 10)
```

2. **Import by key for published libraries, by nodeId for local:**
```javascript
// Published library (preferred)
const component = await figma.importComponentByKeyAsync("component-key");
const instance = component.createInstance();

// Local component (fallback)
const node = await figma.getNodeByIdAsync("nodeId");
if (node && node.type === "COMPONENT") {
  const instance = node.createInstance();
}
```

3. **Always load fonts before creating text:**
```javascript
await figma.loadFontAsync({ family: "FontName", style: "Regular" });
```

4. **Always use async methods — never sync:**
```javascript
// CORRECT
const node = await figma.getNodeByIdAsync("20:62");

// WRONG — will fail
const node = figma.getNodeById("20:62");
```

5. **For gradients, always include alpha channel:**
```javascript
// CORRECT
gradientStops: [{ position: 0, color: { r: 0.95, g: 0.98, b: 0.92, a: 1 } }]

// WRONG — will throw error
gradientStops: [{ position: 0, color: { r: 0.95, g: 0.98, b: 0.92 } }]
```

6. **Always scroll to the result:**
```javascript
figma.viewport.scrollAndZoomIntoView([frame]);
```

After each build step, report to the user what was created and what is next.

---

---

## SUB-SKILL 4 — Troubleshoot Figma Console MCP

Tell the user:

"Let's diagnose the issue. I will run through the most common problems step by step."

**Step 1: Check connection status**

```
mcp__figma-console__figma_get_status
```

**If connected** — tell the user: "✅ Connection is active on port [port]. What specifically is not working?"

**If not connected** — proceed to Step 2.

---

**Step 2: Check for port conflicts**

Tell the user: "Let me clear any orphan MCP processes automatically."

Mac

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [designagentlab](https://github.com/designagentlab)
- **Source:** [designagentlab/skills](https://github.com/designagentlab/skills)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-designagentlab-skills-claude-to-figma
- Seller: https://agentstack.voostack.com/s/designagentlab
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.