Figma Design Skills
jeltehomminga/figma-design-skills
Extraia specs exatas do Figma e verifique se o app renderizado bate com elas
Ver no GitHubDuas skills compostas para garantir fidelidade design-to-code: extrai valores exatos de componentes Figma em uma tabela de specs, depois verifica se a aplicação rodando realmente corresponde a essas especificações. Funciona com web (getComputedStyle) e mobile (native props).
Instalação
npx convez-ai jeltehomminga/figma-design-skills1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Validar pixel-perfect entre design e código implementado
- Extrair tokens de design (cores, tipografia, espaçamento) direto do Figma
- Detectar desvios entre design e app rodando com feedback medido
Veredito

Skill sólida que resolve um problema real de engenharia: elimina screenshots imprecisas e checks visuais, substituindo-os por extração estruturada de tokens e verificação medida. Bem pensada para web e mobile, com composição clara entre extract e verify.
README
A tradução para o português deste README ainda está na fila.
figma-design-skills
Two composable, tool-agnostic skills for design-to-code fidelity — get the real design out of Figma, then prove the running app actually matches it. Packaged as a Claude Code plugin, and usable in OpenAI Codex, Cursor, GitHub Copilot, and any agent that reads AGENTS.md — see Use with other agents.
Most "is it pixel-perfect?" checks fail the same two ways: the design is read off a screenshot (so a 4px gap or a 600→400 weight slips through), and "looks done" is treated as a check (no measured feedback loop). These skills fix both — one extracts exact values, the other verifies them by measurement.
┌─────────────────────────┐ ┌──────────────────────────┐
│ figma-design-extract │ spec │ design-fidelity-verify │
│ read Figma → spec table │ ──────► │ measure app → PASS/FAIL │
└─────────────────────────┘ table └──────────────────────────┘
exact tokens, not pixels computed values, not glances
The two skills
| Skill | One-liner |
|---|---|
| figma-design-extract | Pull exact tokens, sizes, and structure out of a Figma node via the Figma MCP into a build-ready design-spec table — element | property | Figma exact value | repo token | source component. Maps each Figma variable to your design tokens; logs drift instead of hardcoding. |
| design-fidelity-verify | Run a bounded vision + numeric loop (~3 iterations) that reads the actually rendered values off the live app and walks every spec row to PASS/FAIL + delta. Works for web (getComputedStyle) and mobile (native view props via Argent or similar). |
They compose: figma-design-extract produces the spec table; design-fidelity-verify consumes it. Use either alone, or together for a full design→code→verified pipeline.
The workflow
- Extract. Share a Figma node URL. The extract skill reads structured values (
get_variable_defs,get_metadata,get_design_context,get_screenshot) and produces a spec table mapped to your tokens. The screenshot is a visual reference only — never measured. - Build. Implement the component from the table, reusing existing primitives. Every value is a token reference, not a literal.
- Verify. The verify skill runs the app, captures full-resolution, reads computed/native values, and compares each spec row to the live render — fixing the highest-severity drift first, bounded to ~3 iterations, and reporting any residuals honestly.
Install
/plugin marketplace add jeltehomminga/figma-design-skills
/plugin install figma-design-skills@figma-design-skills
Both skills load on demand from their trigger phrases (e.g. a figma.com URL, or "verify the design"). You can also clone this repo and drop either skills/<name>/ folder into your ~/.claude/skills/ (personal) or .claude/skills/ (project).
Any agent, one command — the skills.sh CLI installs these into the right place for Claude Code, Cursor, Codex, Copilot, Windsurf, Gemini, or Cline:
npx skills add jeltehomminga/figma-design-skills
Use with other agents
Cursor · OpenAI Codex · GitHub Copilot · Gemini CLI · Aider · Zed · and any agent that reads
AGENTS.md.
The SKILL.md bodies are plain, tool-neutral markdown — the only Claude-specific part is auto-triggering via the description. To use a skill elsewhere, wire its body into your tool's instruction format. Every tool below speaks MCP, so the Figma / Playwright / Argent references work once you've configured those servers in that tool.
Easiest — npx skills add (skills.sh)
The skills.sh CLI installs these into the right format for whichever agent you use — Claude Code, Cursor, Codex, Copilot, Windsurf, Gemini, Cline:
npx skills add jeltehomminga/figma-design-skills
It discovers both skills from this repo's skills/ layout and .claude-plugin/ manifest automatically. The steps below are the manual fallback if you'd rather wire them in by hand.
Any tool — AGENTS.md (broadest reach)
This repo ships a root AGENTS.md that summarizes both skills and points to the full bodies. Tools that read AGENTS.md — Codex, Cursor, Copilot's coding agent, Gemini CLI, Aider, Jules, Zed, Windsurf, and 20+ others — pick it up automatically. Copy it (or the relevant parts) into your own project's AGENTS.md. (VS Code Copilot: enable the chat.useAgentsMdFile setting.)
OpenAI Codex — native skills
Codex reads the same SKILL.md format from .agents/skills/. From your project:
mkdir -p .agents/skills
cp -r path/to/figma-design-skills/skills/* .agents/skills/
Invoke with /skills or $figma-design-extract, or let Codex match on the description.
Cursor — project rule
Cursor uses .cursor/rules/*.mdc. Create one per skill — paste the skill body under MDC frontmatter:
---
description: <paste the skill's description>
alwaysApply: false
---
<paste the body of skills/figma-design-extract/SKILL.md>
Leave globs empty and @-mention it (@figma-design-extract), or set globs: "**/*.tsx" to auto-attach on relevant files.
GitHub Copilot — instructions file
Create .github/instructions/figma-design-extract.instructions.md:
---
applyTo: "**"
---
<paste the body of the skill>
Honored in VS Code and by the Copilot cloud agent. For always-on guidance instead, append the body to .github/copilot-instructions.md.
Configure the MCP servers (per tool)
The skills call MCP servers; each tool configures them separately:
| Tool | MCP config |
|---|---|
| Claude Code | .mcp.json / .claude/mcp.json |
| OpenAI Codex | ~/.codex/config.toml — [mcp_servers.<name>] |
| Cursor | .cursor/mcp.json |
| GitHub Copilot | .github/mcp.json (Agent mode; root key servers) |
Requirements
- An agent — Claude Code, OpenAI Codex, Cursor, GitHub Copilot, or any MCP-capable coding agent (see Use with other agents).
- Figma MCP server (Dev Mode MCP) — for
figma-design-extract. - App-driving tooling — for
design-fidelity-verify:- Web: a browser/Playwright/Chrome MCP that can run JS in the page and screenshot.
- Mobile: Argent (recommended), agent-device, or a lighter iOS-simulator MCP.
Tool- and stack-agnostic
The skills name specific tools (Tailwind, NativeWind, Restyle, Playwright, Argent) only as examples. The principles are what matter:
- A value bound to a Figma variable maps to a named token in your code — never a hardcoded literal.
- Fidelity is measured (computed styles / native props), never eyeballed from a screenshot.
- Adapt the token syntax and the device tooling to whatever your repo already uses.
Background — why measured fidelity (and where it's debated)
This approach reflects current Figma guidance and practitioner consensus, with the honest caveats:
- Tokens/variables are the source of truth. Figma: "Figma knows which specific token is used, and can provide the name of that variable to the LLM." (Figma blog). Reuse via Code Connect is "the #1 way to get consistent component reuse."
- Don't measure from a screenshot. Vision-language models are measurably weak at fine-grained pixel distances (spatial-reasoning survey), so exact values come from structured data and the running app is measured, not eyeballed. The blind spot this closes is real — AI "has no visibility into the final, rendered output of its own code" (Builder.io).
- Bounded loop. Self-correcting agents saturate fast: "beyond the third attempt, new plans recycle prior tool sequences" (study) — hence the ~3-iteration cap.
- "Pixel-perfect" is contested framing. A credible camp argues the term is meaningless/harmful and the real goal is "intentional fidelity to design decisions" (Smashing Magazine, Josh Comeau). These skills keep "pixel-perfect" only as a trigger phrase; the pass/fail unit is the token, not the literal pixel.
- Complement, don't replace, visual regression. Computed-style diffing verifies a first build (no baseline exists yet); tools like Chromatic / Percy / Applitools / Playwright
toHaveScreenshotcatch ongoing regressions. Use both.
License
MIT © Jelte Homminga