SkillAgentSearch skills...

figma-implement-design

Translates Figma designs into production-ready application code with 1:1 visual fidelity

Install / Use

npx skills add openai/skills --skill figma-implement-design

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

93/100

Category

Automation

Supported Platforms

Universal

Our assessment of figma-implement-design

figma-implement-design scores 93/100 on our quality scale, 615th of 2,780 Automation skills we index (top 23%).

Its SKILL.md is 11 KB long, well organised into 34 sections with 2 code examples: a thorough specification that gives an agent plenty to work with.

With 27,599 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
29/30
Structure
18/20
Description
12/15
Adoption
19/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated about 2 months ago, so figma-implement-design is actively maintained.
  • Our last check on 2026-10-03 found the source still online.
  • No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
  • Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-09-26. Automated pattern scan on 2026-09-26. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

figma-implement-design compared with similar skills

All 4 of these similar skills score higher than figma-implement-design; compare them before choosing.

SkillScoreStarsUpdatedFormat
figma-implement-design (this skill)by openai9327.6k2mo agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10039.7k7d agoCLAUDE.md

Frequently asked questions

How do I install figma-implement-design?
Run npx skills add openai/skills --skill figma-implement-design. The install tabs above show the steps for each supported agent.
Which AI agents does figma-implement-design work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is figma-implement-design safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is figma-implement-design still maintained?
The repository was last updated about 2 months ago, so figma-implement-design is actively maintained.

name: figma-implement-design description: Translates Figma designs into production-ready application code with 1:1 visual fidelity. Use when implementing UI code from Figma files, when user mentions "implement design", "generate code", "implement component", provides Figma URLs, or asks to build components matching Figma specs. For Figma canvas writes via use_figma, use figma-use.

Implement Design

Overview

This skill provides a structured workflow for translating Figma designs into production-ready code with pixel-perfect accuracy. It ensures consistent integration with the Figma MCP server, proper use of design tokens, and 1:1 visual parity with designs.

Skill Boundaries

  • Use this skill when the deliverable is code in the user's repository.
  • If the user asks to create/edit/delete nodes inside Figma itself, switch to figma-use.
  • If the user asks to build or update a full-page screen in Figma from code or a description, switch to figma-generate-design.
  • If the user asks only for Code Connect mappings, switch to figma-code-connect-components.
  • If the user asks to author reusable agent rules (CLAUDE.md/AGENTS.md), switch to figma-create-design-system-rules.

Prerequisites

  • Figma MCP server must be connected and accessible
  • User must provide a Figma URL in the format: https://figma.com/design/:fileKey/:fileName?node-id=1-2
    • :fileKey is the file key
    • 1-2 is the node ID (the specific component or frame to implement)
  • OR when using figma-desktop MCP: User can select a node directly in the Figma desktop app (no URL required)
  • Project should have an established design system or component library (preferred)

Required Workflow

Follow these steps in order. Do not skip steps.

Step 1: Get Node ID

Option A: Parse from Figma URL

When the user provides a Figma URL, extract the file key and node ID to pass as arguments to MCP tools.

URL format: https://figma.com/design/:fileKey/:fileName?node-id=1-2

Extract:

  • File key: :fileKey (the segment after /design/)
  • Node ID: 1-2 (the value of the node-id query parameter)

Note: When using the local desktop MCP (figma-desktop), fileKey is not passed as a parameter to tool calls. The server automatically uses the currently open file, so only nodeId is needed.

Example:

  • URL: https://figma.com/design/kL9xQn2VwM8pYrTb4ZcHjF/DesignSystem?node-id=42-15
  • File key: kL9xQn2VwM8pYrTb4ZcHjF
  • Node ID: 42-15

Option B: Use Current Selection from Figma Desktop App (figma-desktop MCP only)

When using the figma-desktop MCP and the user has NOT provided a URL, the tools automatically use the currently selected node from the open Figma file in the desktop app.

Note: Selection-based prompting only works with the figma-desktop MCP server. The remote server requires a link to a frame or layer to extract context. The user must have the Figma desktop app open with a node selected.

Step 2: Fetch Design Context

Run get_design_context with the extracted file key and node ID.

get_design_context(fileKey=":fileKey", nodeId="1-2")

This provides the structured data including:

  • Layout properties (Auto Layout, constraints, sizing)
  • Typography specifications
  • Color values and design tokens
  • Component structure and variants
  • Spacing and padding values

If the response is too large or truncated:

  1. Run get_metadata(fileKey=":fileKey", nodeId="1-2") to get the high-level node map
  2. Identify the specific child nodes needed from the metadata
  3. Fetch individual child nodes with get_design_context(fileKey=":fileKey", nodeId=":childNodeId")

Step 3: Capture Visual Reference

Run get_screenshot with the same file key and node ID for a visual reference.

get_screenshot(fileKey=":fileKey", nodeId="1-2")

This screenshot serves as the source of truth for visual validation. Keep it accessible throughout implementation.

Step 4: Download Required Assets

Download any assets (images, icons, SVGs) returned by the Figma MCP server.

IMPORTANT: Follow these asset rules:

  • If the Figma MCP server returns a localhost source for an image or SVG, use that source directly
  • DO NOT import or add new icon packages - all assets should come from the Figma payload
  • DO NOT use or create placeholders if a localhost source is provided
  • Assets are served through the Figma MCP server's built-in assets endpoint

Step 5: Translate to Project Conventions

Translate the Figma output into this project's framework, styles, and conventions.

Key principles:

  • Treat the Figma MCP output (typically React + Tailwind) as a representation of design and behavior, not as final code style
  • Replace Tailwind utility classes with the project's preferred utilities or design system tokens
  • Reuse existing components (buttons, inputs, typography, icon wrappers) instead of duplicating functionality
  • Use the project's color system, typography scale, and spacing tokens consistently
  • Respect existing routing, state management, and data-fetch patterns

Step 6: Achieve 1:1 Visual Parity

Strive for pixel-perfect visual parity with the Figma design.

Guidelines:

  • Prioritize Figma fidelity to match designs exactly
  • Avoid hardcoded values - use design tokens from Figma where available
  • When conflicts arise between design system tokens and Figma specs, prefer design system tokens but adjust spacing or sizes minimally to match visuals
  • Follow WCAG requirements for accessibility
  • Add component documentation as needed

Step 7: Validate Against Figma

Before marking complete, validate the final UI against the Figma screenshot.

Validation checklist:

  • [ ] Layout matches (spacing, alignment, sizing)
  • [ ] Typography matches (font, size, weight, line height)
  • [ ] Colors match exactly
  • [ ] Interactive states work as designed (hover, active, disabled)
  • [ ] Responsive behavior follows Figma constraints
  • [ ] Assets render correctly
  • [ ] Accessibility standards met

Implementation Rules

Component Organization

  • Place UI components in the project's designated design system directory
  • Follow the project's component naming conventions
  • Avoid inline styles unless truly necessary for dynamic values

Design System Integration

  • ALWAYS use components from the project's design system when possible
  • Map Figma design tokens to project design tokens
  • When a matching component exists, extend it rather than creating a new one
  • Document any new components added to the design system

Code Quality

  • Avoid hardcoded values - extract to constants or design tokens
  • Keep components composable and reusable
  • Add TypeScript types for component props
  • Include JSDoc comments for exported components

Examples

Example 1: Implementing a Button Component

User says: "Implement this Figma button component: https://figma.com/design/kL9xQn2VwM8pYrTb4ZcHjF/DesignSystem?node-id=42-15"

Actions:

  1. Parse URL to extract fileKey=kL9xQn2VwM8pYrTb4ZcHjF and nodeId=42-15
  2. Run get_design_context(fileKey="kL9xQn2VwM8pYrTb4ZcHjF", nodeId="42-15")
  3. Run get_screenshot(fileKey="kL9xQn2VwM8pYrTb4ZcHjF", nodeId="42-15") for visual reference
  4. Download any button icons from the assets endpoint
  5. Check if project has existing button component
  6. If yes, extend it with new variant; if no, create new component using project conventions
  7. Map Figma colors to project design tokens (e.g., primary-500, primary-hover)
  8. Validate against screenshot for padding, border radius, typography

Result: Button component matching Figma design, integrated with project design system.

Example 2: Building a Dashboard Layout

User says: "Build this dashboard: https://figma.com/design/pR8mNv5KqXzGwY2JtCfL4D/Dashboard?node-id=10-5"

Actions:

  1. Parse URL to extract fileKey=pR8mNv5KqXzGwY2JtCfL4D and nodeId=10-5
  2. Run get_metadata(fileKey="pR8mNv5KqXzGwY2JtCfL4D", nodeId="10-5") to understand the page structure
  3. Identify main sections from metadata (header, sidebar, content area, cards) and their child node IDs
  4. Run get_design_context(fileKey="pR8mNv5KqXzGwY2JtCfL4D", nodeId=":childNodeId") for each major section
  5. Run get_screenshot(fileKey="pR8mNv5KqXzGwY2JtCfL4D", nodeId="10-5") for the full page
  6. Download all assets (logos, icons, charts)
  7. Build layout using project's layout primitives
  8. Implement each section using existing components where possible
  9. Validate responsive behavior against Figma constraints

Result: Complete dashboard matching Figma design with responsive layout.

Best Practices

Always Start with Context

Never implement based on assumptions. Always fetch get_design_context and get_screenshot first.

Incremental Validation

Validate frequently during implementation, not just at the end. This catches issues early.

Document Deviations

If you must deviate from the Figma design (e.g., for accessibility or technical constraints), document why in code comments.

Reuse Over Recreation

Always check for existing components before creating new ones. Consistency across the codebase is more important than exact Figma replication.

Design System First

When in doubt, prefer the project's design system patterns over literal Figma translation.

Common Issues and Solutions

Issue: Figma output is truncated

Cause: The design is too complex or has too many nested layers to return in a single response. Solution: Use get_metadata to get the node structure, then fetch specific nodes individually with get_design_context.

Issue: Design doesn't match after implementation

Cause: Visual discrepancies between the implemented code and the original Figma design. Solution: Compare side-by-side with the screenshot from Step 3. Check spacing, colors, and typography values in the design context data.

Issue: Assets not loading

Cause: The Figma MCP server's assets endpoint is not accessible or the URLs are being modified. Solution: Verify the Figma MCP server's assets endpoint is accessible. The server serves assets at localhost URLs. Use these directly without modification.

Issue: Design token values differ from Figma

Cause: The project's design system tokens have different values than those specified in the Figma design. Solution: When project tokens differ from Figma values, prefer project tokens for consistency but adjust spacing/sizing to maintain visual fidelity.

Understanding Design Implementation

The Figma implementation workflow establishes a reliable process for translating designs to code:

For designers: Confidence that implementations will match their designs with pixel-perfect accuracy. For developers: A structured approach that eliminates guesswork and reduces back-and-forth revisions. For teams: Consistent, high-quality implementations that maintain design system integrity.

By following this workflow, you ensure that every Figma design is implemented with the same level of care and attention to detail.

Additional Resources

Related Skills

View on GitHub
GitHub Stars27.6k
CategoryAutomation
Updated2mo ago
Forks1.9k

Languages

Python

Trust signals

88/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 medium