
figma-designer
Analyzes Figma designs into implementation-ready visual evidence, tokens, component specifications, and interaction states for handoff to planning or development.
- Installs
- 809
- Last 24h
- —
- Trending rank
- —
- Security
- Not audited
Install
Works with every agent the skills CLI supports.
npx skills add https://github.com/zhaono1/agent-playbook --skill figma-designer- 01
Install
Run the command in your project. The CLI asks which agents to install for.
- 02
Describe the task
Ask your agent for something this skill covers. It loads figma-designer automatically when relevant.
- 03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.
SKILL.md
The instructions your agent reads when the skill is triggered.
Figma Designer
"Transform Figma designs into implementation-ready specifications with pixel-perfect accuracy"
Overview
This skill analyzes Figma designs through the available Figma integration and
produces design evidence. prd-planner owns product requirements and technical
PRD methodology; this skill supplies visual facts and unresolved design gaps.
Prerequisites
Figma MCP Server
Ensure the host exposes a Figma MCP server or plugin before using this skill. Tool names vary by host and plugin version, so inspect the available Figma tools in the current session instead of assuming fixed names. The required capability set is:
- Read file or page metadata
- Read selected nodes or node details
- Read component and style information when available
When This Skill Activates
Activates when you:
- Provide a Figma link (
https://www.figma.com/file/...) - Upload a design screenshot and mention "Figma"
- Say "analyze this design" or "extract design specs"
- Ask to "create PRD from Figma"
Design Analysis Workflow
Phase 1: Fetch Design Data
Input: Figma URL or File Key
↓
Extract File Key from URL
↓
Call the available Figma metadata tool
↓
Call the available Figma node/detail tool
↓
Parse frame, component, and text nodes
Phase 2: Extract Design Tokens
Create a comprehensive design token inventory:
// Design Token Structure
interface DesignTokens {
colors: {
primary: string[];
secondary: string[];
neutral: string[];
semantic: {
success: string;
warning: string;
error: string;
info: string;
};
};
typography: {
fontFamilies: Record<string, string>;
fontSizes: Record<string, number>;
fontWeights: Record<string, number>;
lineHeights: Record<string, number>;
letterSpacing: Record<string, number>;
};
spacing: {
scale: number; // 4, 8, 12, 16, etc.
values: Record<string, number>;
};
borders: {
radii: Record<string, number>;
widths: Record<string, number>;
};
shadows: Array<{
name: string;
values: string[];
}>;
}
Phase 3: Analyze Component Hierarchy
File
├── Frames (Pages/Screens)
│ ├── Component Instances
│ │ ├── Primary Button
│ │ ├── Input Field
│ │ └── Card
│ └── Text Layers
│ ├── Headings
│ ├── Body
│ └── Labels
For each component, extract:
- Props: Size, variant, state
- Layout: Flex direction, alignment, gap, padding
- Styles: Fill, stroke, effects
- Content: Text content, icons, images
- Constraints: Responsive behavior
Phase 4: Generate Visual Specifications
Use this template for each screen:
## Screen: [Screen Name]
### Layout Structure
┌─────────────────────────────────────────┐ │ [Header/Nav] │ ├─────────────────────────────────────────┤ │ │ │ [Main Content] │ │ ┌───────────┐ ┌───────────┐ │ │ │ Card 1 │ │ Card 2 │ │ │ └───────────┘ └───────────┘ │ │ │ ├─────────────────────────────────────────┤ │ [Footer] │ └─────────────────────────────────────────┘
### Design Specifications
#### Colors
| Token | Value | Usage |
|-------|-------|-------|
| Primary | `#007AFF` | Primary buttons, links |
| Background | `#FFFFFF` | Screen background |
| Surface | `#F5F5F7` | Cards, sections |
| Text Primary | `#1C1C1E` | Headings, body |
| Text Secondary | `#8E8E93` | Captions, labels |
#### Typography
| Style | Font | Size | Weight | Line Height | Letter Spacing |
|-------|------|------|--------|------------|---------------|
| Display Large | SF Pro Display | 28px | Bold (700) | 34px | -0.5px |
| Heading 1 | SF Pro Display | 24px | Bold (700) | 32px | -0.3px |
| Heading 2 | SF Pro Display | 20px | Semibold (600) | 28px | -0.2px |
| Body Large | SF Pro Text | 17px | Regular (400) | 24px | -0.4px |
| Body | SF Pro Text | 15px | Regular (400) | 22px | -0.3px |
| Caption | SF Pro Text | 13px | Regular (400) | 18px | -0.1px |
#### Spacing
| Token | Value | Usage |
|-------|-------|-------|
| xs | 4px | Icon padding |
| sm | 8px | Tight spacing |
| md | 12px | Card padding |
| lg | 16px | Section spacing |
| xl | 24px | Large gaps |
| 2xl | 32px | Page margins |
#### Component: Primary Button
```typescript
interface PrimaryButtonProps {
size?: 'small' | 'medium' | 'large';
variant?: 'primary' | 'secondary' | 'tertiary';
disabled?: boolean;
}
// Sizes
size.small = {
height: 32px,
paddingHorizontal: 12px,
fontSize: 15,
iconSize: 16,
}
size.medium = {
height: 40px,
paddingHorizontal: 16px,
fontSize: 15,
iconSize: 20,
}
size.large = {
height: 48px,
paddingHorizontal: 24px,
fontSize: 17,
iconSize: 24,
}
// Variants
variant.primary = {
backgroundColor: '#007AFF',
color: '#FFFFFF',
}
variant.secondary = {
backgroundColor: '#F5F5F7',
color: '#007AFF',
}
variant.tertiary = {
backgroundColor: 'transparent',
color: '#007AFF',
}
Constraints & Responsive Behavior
| Element | Constraints | Responsive Behavior |
|---|---|---|
| Header | Left, Right, Top | Sticky on scroll |
| Sidebar | Left, Top, Bottom | Collapses to drawer on mobile |
| Content | Left, Right (16px) | Full width on mobile |
Interaction States
| Element | Default | Hover | Pressed | Disabled |
|---|---|---|---|---|
| Primary Button | opacity: 1 | opacity: 0.8 | opacity: 0.6 | opacity: 0.4 |
| Icon Button | opacity: 1 | background: rgba(0,0,0,0.05) | background: rgba(0,0,0,0.1) | opacity: 0.3 |
| Card | shadow: sm | shadow: md | - | opacity: 0.6 |
## Output Formats
### Option 1: Visual Spec Document (Default)
Generates a design specification document:
docs/{feature}-design-spec.md
### Option 2: PRD Evidence Pack
Provide screen intent, design tokens, component states, responsive rules,
accessibility observations, and open product questions as inputs to
`prd-planner`. Do not invent business requirements from visual design alone.
## Quick Reference: Design Token Categories
### Always Extract These
| Category | What to Extract | Why |
|----------|----------------|-----|
| **Colors** | Hex/RGBA values | Theme consistency |
| **Typography** | Font family, size, weight, spacing | Text hierarchy |
| **Spacing** | Padding, margin, gap values | Layout alignment |
| **Borders** | Radius, width values | Shape consistency |
| **Shadows** | Offset, blur, spread, color | Depth perception |
| **Icons** | Name, size, color | Visual consistency |
| **Images** | URL, dimensions, fit mode | Asset management |
## Design Review Checklist
Before generating design evidence, verify:
- [ ] All screens are accounted for
- [ ] Design tokens are extracted
- [ ] Component variants are documented
- [ ] Responsive behavior is specified
- [ ] Interaction states are defined
- [ ] Accessibility (WCAG) is considered
- [ ] Color contrast ratio ≥ 4.5:1
- [ ] Touch targets ≥ 44x44px
- [ ] Focus indicators visible
## Frame Analysis Template
For each frame/screen in the Figma file:
```markdown
## Frame: {Frame Name}
### Purpose
{What this screen does}
### Elements
| Element | Type | Styles | Props |
|---------|------|--------|-------|
| {Name} | {Component/Text/Vector} | {css} | {props} |
| {Name} | {Component/Text/Vector} | {css} | {props} |
### Layout
- Container: {width, height, fill}
- Position: {absolute/relative}
- Constraints: {left, right, top, bottom}
- Auto Layout: {direction, spacing, padding, alignment}
### Content Hierarchy
1. {Primary element}
2. {Secondary element}
3. {Tertiary element}
### Notes
{Any special considerations}
Integration with Other Skills
Typical Workflow
Figma URL → figma-designer → Visual Specs
↓
prd-planner → PRD
↓
implementation → Code
↓
code-reviewer → Quality Check
Handoff to Development
After generating specifications:
## Developer Handoff
### Design Files
- Figma: {url}
- Design Spec: {link}
### Design Tokens
- Generated: `tokens.ts`
- Color palette: `colors.ts`
- Typography: `typography.ts`
### Component Library
- Storybook: {url}
- Component docs: {link}
### Assets
- Icons: {folder}
- Images: {folder}
- Exports: {format}
Best Practices
DO
✅ Extract exact pixel values for critical dimensions ✅ Document component variants and states ✅ Include responsive breakpoints ✅ Note any platform differences (iOS vs Android) ✅ Include accessibility considerations ✅ Export design tokens as constants
DON'T
❌ Round spacing values (use exact 4px/8px/12px) ❌ Ignore hover/focus states ❌ Skip constraint behavior ❌ Forget about empty states ❌ Omit loading states ❌ Assume platform defaults without verification
Examples and Platform Notes
See references/example-output.md for a full sample output and platform-specific considerations.
FAQ
What does the figma-designer skill do?
Analyzes Figma designs into implementation-ready visual evidence, tokens, component specifications, and interaction states for handoff to planning or development.
How do I install figma-designer?
Run npx skills add https://github.com/zhaono1/agent-playbook --skill figma-designer in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/figma-designer/ (personal) or .claude/skills/figma-designer/ (project).
Which AI agents can use figma-designer?
Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.
Is figma-designer safe to install?
No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.
Who maintains figma-designer?
It is published by zhaono1 in zhaono1/agent-playbook. It has 809 recorded installs.
More from zhaono1/agent-playbook
self-improving-agent
zhaono1/agent-playbook
Use after a failure, user correction, repeated workflow problem, or validated success reveals a reusable lesson. Captures bounded redacted candidates, runs executable behavior evals, and separates validation from application in durable guidance.
planning-with-files
zhaono1/agent-playbook
Uses persistent markdown files for general planning, progress tracking, and knowledge storage (Manus-style workflow). Use for multi-step tasks, research projects, or general organization WITHOUT mentioning PRD. For PRD-specific work, use prd-planner skill instead.
security-auditor
zhaono1/agent-playbook
Security vulnerability expert covering OWASP Top 10 and common security issues. Use when conducting security audits or reviewing code for vulnerabilities.
architecting-solutions
zhaono1/agent-playbook
Designs technical solutions and architecture. Use when user says "design solution", "architecture design", "technical design", or "方案设计" WITHOUT mentioning PRD. For PRD-specific work, use prd-planner skill instead.
skill-router
zhaono1/agent-playbook
Routes an agent request to the narrowest matching portable skill when the user asks which skill to use or needs help selecting one across supported hosts.
workflow-orchestrator
zhaono1/agent-playbook
Coordinates multi-skill workflows and records or runs follow-up actions when the host runtime supports them. Use when completing PRD creation, implementation, or any milestone that should be evaluated for additional skills.
Popular frontend & design skills
setup-matt-pocock-skills
mattpocock/skills
Configure this repo for the engineering skills: set up its issue tracker, triage label vocabulary, and domain doc layout. Run once before first use of the other engineering skills.
frontend-design
anthropics/skills
Guidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.
hyperframes-animation
heygen-com/hyperframes
All animation knowledge for HyperFrames — atomic motion rules, multi-phase scene blueprints, scene transitions, broader motion-design techniques, AND the seven runtime adapters (GSAP default, plus Lottie, Three.js, Anime.js, CSS keyframes, Web Animations API, TypeGPU). Use for any motion or animation task: pick 2-4 rules and compose, or load a blueprint, or look up runtime-specific API (e.g. GSAP eases / Lottie player / Three.js mixer). Also covers auditing an existing composition's choreography (animation map) and 24 named text-animation effects. HyperFrames-native: single paused timeline, seek-safe, deterministic.
prototype
mattpocock/skills
Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.
hyperframes-core
heygen-com/hyperframes
The HyperFrames composition contract — build one renderable project. Use for composition structure, the data- timing attributes, class="clip", tracks, sub-compositions, variables, framework-owned media playback, deterministic-render rules, and validation. Read before writing composition HTML.
vercel-react-best-practices
vercel-labs/agent-skills
React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.