SkillAgentSearch skills...

figma-generate-library

Build or update a professional-grade design system in Figma from a codebase

Install / Use

npx skills add openai/skills --skill figma-generate-library

Installs into whichever agent you are using.

About this skill
📄

SKILL.md

Installable skill definition

Quality Score

96/100

Category

Design

Supported Platforms

Universal

Our assessment of figma-generate-library

figma-generate-library scores 96/100 on our quality scale, 19th of 260 Design skills we index (top 8%).

Its SKILL.md is 17 KB long, well organised into 12 sections with 7 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
30/30
Structure
20/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-generate-library is actively maintained.
  • Our last check on 2026-11-15 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-generate-library compared with similar skills

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

SkillScoreStarsUpdatedFormat
figma-generate-library (this skill)by openai9627.6k2mo agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.md

Frequently asked questions

How do I install figma-generate-library?
Run npx skills add openai/skills --skill figma-generate-library. The install tabs above show the steps for each supported agent.
Which AI agents does figma-generate-library 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-generate-library 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-generate-library still maintained?
The repository was last updated about 2 months ago, so figma-generate-library is actively maintained.

name: figma-generate-library description: "Build or update a professional-grade design system in Figma from a codebase. Use when the user wants to create variables/tokens, build component libraries, set up theming (light/dark modes), document foundations, or reconcile gaps between code and Figma. This skill teaches WHAT to build and in WHAT ORDER — it complements the figma-use skill which teaches HOW to call the Plugin API. Both skills should be loaded together."

Design System Builder — Figma MCP Skill

Build professional-grade design systems in Figma that match code. This skill orchestrates multi-phase workflows across 20–100+ use_figma calls, enforcing quality patterns from real-world design systems (Material 3, Polaris, Figma UI3, Simple DS).

Prerequisites: The figma-use skill MUST also be loaded for every use_figma call. It provides Plugin API syntax rules (return pattern, page reset, ID return, font loading, color range). This skill provides design system domain knowledge and workflow orchestration.

Always pass skillNames: "figma-generate-library" when calling use_figma as part of this skill. This is a logging parameter — it does not affect execution.


1. The One Rule That Matters Most

This is NEVER a one-shot task. Building a design system requires 20–100+ use_figma calls across multiple phases, with mandatory user checkpoints between them. Any attempt to create everything in one call WILL produce broken, incomplete, or unrecoverable results. Break every operation to the smallest useful unit, validate, get feedback, proceed.


2. Mandatory Workflow

Every design system build follows this phase order. Skipping or reordering phases causes structural failures that are expensive to undo.

Phase 0: DISCOVERY (always first — no use_figma writes yet)
  0a. Analyze codebase → extract tokens, components, naming conventions
  0b. Inspect Figma file → pages, variables, components, styles, existing conventions
  0c. Search subscribed libraries → use search_design_system for reusable assets
  0d. Lock v1 scope → agree on exact token set + component list before any creation
  0e. Map code → Figma → resolve conflicts (code and Figma disagree = ask user)
  ✋ USER CHECKPOINT: present full plan, await explicit approval

Phase 1: FOUNDATIONS (tokens first — always before components)
  1a. Create variable collections and modes
  1b. Create primitive variables (raw values, 1 mode)
  1c. Create semantic variables (aliased to primitives, mode-aware)
  1d. Set scopes on ALL variables
  1e. Set code syntax on ALL variables
  1f. Create effect styles (shadows) and text styles (typography)
  → Exit criteria: every token from the agreed plan exists, all scopes set, all code syntax set
  ✋ USER CHECKPOINT: show variable summary, await approval

Phase 2: FILE STRUCTURE (before components)
  2a. Create page skeleton: Cover → Getting Started → Foundations → --- → Components → --- → Utilities
  2b. Create foundations documentation pages (color swatches, type specimens, spacing bars)
  → Exit criteria: all planned pages exist, foundations docs are navigable
  ✋ USER CHECKPOINT: show page list + screenshot, await approval

Phase 3: COMPONENTS (one at a time — never batch)
  For EACH component (in dependency order: atoms before molecules):
    3a. Create dedicated page
    3b. Build base component with auto-layout + full variable bindings
    3c. Create all variant combinations (combineAsVariants + grid layout)
    3d. Add component properties (TEXT, BOOLEAN, INSTANCE_SWAP)
    3e. Link properties to child nodes
    3f. Add page documentation (title, description, usage notes)
    3g. Validate: get_metadata (structure) + get_screenshot (visual)
    3h. Optional: lightweight Code Connect mapping while context is fresh
    → Exit criteria: variant count correct, all bindings verified, screenshot looks right
    ✋ USER CHECKPOINT per component: show screenshot, await approval before next component

Phase 4: INTEGRATION + QA (final pass)
  4a. Finalize all Code Connect mappings
  4b. Accessibility audit (contrast, min touch targets, focus visibility)
  4c. Naming audit (no duplicates, no unnamed nodes, consistent casing)
  4d. Unresolved bindings audit (no hardcoded fills/strokes remaining)
  4e. Final review screenshots of every page
  ✋ USER CHECKPOINT: complete sign-off

3. Critical Rules

Plugin API basics (from use_figma skill — enforced here too):

  • Use return to send data back (auto-serialized). Do NOT wrap in IIFE or call closePlugin.
  • Return ALL created/mutated node IDs in every return value
  • Page context resets each call — always await figma.setCurrentPageAsync(page) at start
  • figma.notify() throws — never use it
  • Colors are 0–1 range, not 0–255
  • Font MUST be loaded before any text write: await figma.loadFontAsync({family, style})

Design system rules:

  1. Variables BEFORE components — components bind to variables. No token = no component.
  2. Inspect before creating — run read-only use_figma to discover existing conventions. Match them.
  3. One page per component (default) — exception: tightly related families (e.g., Input + helpers) may share a page with clear section separation.
  4. Bind visual properties to variables (default) — fills, strokes, padding, radius, gap. Exceptions: intentionally fixed geometry (icon pixel-grid sizes, static dividers).
  5. Scopes on every variable — NEVER leave as ALL_SCOPES. Background: FRAME_FILL, SHAPE_FILL. Text: TEXT_FILL. Border: STROKE_COLOR. Spacing: GAP. Radii: CORNER_RADIUS. Primitives: [] (hidden).
  6. Code syntax on every variable — WEB syntax MUST use the var() wrapper: var(--color-bg-primary), not --color-bg-primary. Use the actual CSS variable name from the codebase. ANDROID/iOS do NOT use a wrapper.
  7. Alias semantics to primitives — { type: 'VARIABLE_ALIAS', id: primitiveVar.id }. Never duplicate raw values in semantic layer.
  8. Position variants after combineAsVariants — they stack at (0,0). Manually grid-layout + resize.
  9. INSTANCE_SWAP for icons — never create a variant per icon. Cap variant matrices: if Size × Style × State > 30 combinations, split into sub-component.
  10. Deterministic naming — use consistent, unique node names for idempotent cleanup and resumability. Track created node IDs via return values and the state ledger.
  11. No destructive cleanup — cleanup scripts identify nodes by name convention or returned IDs, not by guessing.
  12. Validate before proceeding — never build on unvalidated work. get_metadata after every create, get_screenshot after each component.
  13. NEVER parallelize use_figma calls — Figma state mutations must be strictly sequential. Even if your tool supports parallel calls, never run two use_figma calls simultaneously.
  14. Never hallucinate Node IDs — always read IDs from the state ledger returned by previous calls. Never reconstruct or guess an ID from memory.
  15. Use the helper scripts — embed scripts from scripts/ into your use_figma calls. Don't write 200-line inline scripts from scratch.
  16. Explicit phase approval — at each checkpoint, name the next phase explicitly. "looks good" is not approval to proceed to Phase 3 if you asked about Phase 1.

4. State Management (Required for Long Workflows)

getPluginData() / setPluginData() are NOT supported in use_figma. Use getSharedPluginData() / setSharedPluginData() instead (these ARE supported), or use name-based lookups and the state ledger (returned IDs).

| Entity type | Idempotency key | How to check existence | |-------------|----------------|----------------------| | Scene nodes (pages, frames, components) | setSharedPluginData('dsb', 'key', value) or unique name | node.getSharedPluginData('dsb', 'key') or page.findOne(n => n.name === 'Button') | | Variables | Name within collection | (await figma.variables.getLocalVariablesAsync()).find(v => v.name === name && v.variableCollectionId === collId) | | Styles | Name | getLocalTextStyles().find(s => s.name === name) |

Tag every created scene node immediately after creation:

node.setSharedPluginData('dsb', 'run_id', RUN_ID);        // identifies this build run
node.setSharedPluginData('dsb', 'phase', 'phase3');        // which phase created it
node.setSharedPluginData('dsb', 'key', 'component/button');// unique logical key

State persistence: Do NOT rely solely on conversation context for the state ledger. Write it to disk:

/tmp/dsb-state-{RUN_ID}.json

Re-read this file at the start of every turn. In long workflows, conversation context will be truncated — the file is the source of truth.

Maintain a state ledger tracking:

{
  "runId": "ds-build-2024-001",
  "phase": "phase3",
  "step": "component-button",
  "entities": {
    "collections": { "primitives": "id:...", "color": "id:..." },
    "variables": { "color/bg/primary": "id:...", "spacing/sm": "id:..." },
    "pages": { "Cover": "id:...", "Button": "id:..." },
    "components": { "Button": "id:..." }
  },
  "pendingValidations": ["Button:screenshot"],
  "completedSteps": ["phase0", "phase1", "phase2", "component-avatar"]
}

Idempotency check before every create: query by name + state ledger ID. If exists, skip or update — never duplicate.

Resume protocol: at session start or after context truncation, run a read-only use_figma to scan all pages, components, variables, and styles by name to reconstruct the {key → id} map. Then re-read the state file from disk if available.

Continuation prompt (give this to the user when resuming in a new chat):

"I'm continuing a design system build. Run ID: {RUN_ID}. Load the figma-generate-library skill and resume from the last completed step."


5. search_design_system — Reuse Decision Matrix

Search FIRST in Phase 0, then again immediately before each component creation.

search_design_system({ query, fileKey, includeComponents: true, includeVariables: true, includeStyles: true })

Reuse if all of these are true:

  • Component property API matches your needs (same variant axes, compatible types)
  • Token binding model is compatible (uses same or aliasable variables)
  • Naming conventions match the target file
  • Component is editable (not locked in a remote library you don't own)

Rebuild if any of these:

  • API incompatibility (different property names, wrong variant model)
  • Token model incompatible (hardcoded values, different variable schema)
  • Ownership issue (can't modify the library)

Wrap if visual match but API incompatible:

  • Import the library component as a nested instance inside a new wrapper component
  • Expose a clean API on the wrapper

Three-way priority: local existing → subscribed library import → create new.


6. User Checkpoints

Mandatory. Design decisions require human judgment.

| After | Required artifacts | Ask | |-------|-------------------|-----| | Discovery + scope lock | Token list, component list, gap analysis | "Here's my plan. Approve before I create anything?" | | Foundations | Variable summary (N collections, M vars, K modes), style list | "All tokens created. Review before file structure?" | | File structure | Page list + screenshot | "Pages set up. Review before components?" | | Each component | get_screenshot of component page | "Here's [Component] with N variants. Correct?" | | Each conflict (code ≠ Figma) | Show both versions | "Code says X, Figma has Y. Which wins?" | | Final QA | Per-page screenshots + audit report | "Complete. Sign off?" |

If user rejects: fix before moving on. Never build on rejected work.


7. Naming Conventions

Match existing file conventions. If starting fresh:

Variables (slash-separated):

color/bg/primary     color/text/secondary    color/border/default
spacing/xs  spacing/sm  spacing/md  spacing/lg  spacing/xl  spacing/2

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars27.6k
CategoryDesign
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