home / skills / davila7 / claude-code-templates / design-to-code

This skill converts Figma designs to production-ready React + TypeScript components with pixel-perfect accuracy and robust scaffolding.

npx playbooks add skill davila7/claude-code-templates --skill design-to-code

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
4.9 KB
---
name: design-to-code
description: Pixel-perfect Figma to React conversion using coderio. Generates production-ready code (TypeScript, Vite, TailwindCSS V4) with high visual fidelity. Features robust error handling, checkpoint recovery, and streamlined execution via helper script.
---

# Design to Code

High-fidelity UI restoration from Figma designs to production-ready React + TypeScript components.
This SKILL uses a **robust helper script** to minimize manual errors and ensure pixel-perfect results.

## Prerequisites

1.  **Figma API Token**: Get from Figma → Settings → Personal Access Tokens
2.  **Node.js**: Version 18+
3.  **coderio**: Installed in `scripts/` folder (handled by Setup phase)

## Workflow Overview

```
Phase 0: SETUP    → Create helper script and script environment
Phase 1: PROTOCOL → Generate design protocol (Structure & Props)
Phase 2: CODE     → Generate components and assets
```

---

# Phase 0: Setup

## Step 0.1: Initialize Helper Script

**User Action**: Run these commands to create the execution helper and isolate its dependencies.

```bash
mkdir -p scripts

# 1. Copy script files
# Note: Ensure you have the 'skills/design-to-code/scripts' directory available
cp skills/design-to-code/scripts/package.json scripts/package.json
cp skills/design-to-code/scripts/coderio-skill.mjs scripts/coderio-skill.mjs

# 2. Install coderio in scripts directory (adjust version if needed)
cd scripts && pnpm install && cd ..
```

## Step 0.2: Scaffold Project (Optional)

If starting a new project:

1.  Run: `node scripts/coderio-skill.mjs scaffold-prompt "MyApp"`
2.  **AI Task**: Follow the instructions output by the command to create files.

---

# Phase 1: Protocol Generation

## Step 1.1: Fetch Data

```bash
# Replace with your URL and Token
node scripts/coderio-skill.mjs fetch-figma "https://figma.com/file/..." "figd_..."
```

**Verify**: `process/thumbnail.png` should exist.

## Step 1.2: Generate Structure

1.  **Generate Prompt**:

    ```bash
    node scripts/coderio-skill.mjs structure-prompt > scripts/structure-prompt.md
    ```

2.  **AI Task (Structure)**:
    - **ATTACH**: `process/thumbnail.png` (MANDATORY)
    - **READ**: `scripts/structure-prompt.md`
    - **INSTRUCTION**: "Generate the component structure JSON based on the prompt and the attached thumbnail. Focus on visual grouping. **Use text content to name components accurately (e.g. 'SafeProducts', not 'FAQ').**"
    - **SAVE**: Paste the JSON result into `scripts/structure-output.json`.

3.  **Process Result**:
    ```bash
    node scripts/coderio-skill.mjs save-structure
    ```

## Step 1.3: Extract Props (Iterative)

1.  **List Components**:

    ```bash
    node scripts/coderio-skill.mjs list-components
    ```

2.  **For EACH component in the list**:

    a. **Generate Prompt**:

    ```bash
    node scripts/coderio-skill.mjs props-prompt "ComponentName" > scripts/current-props-prompt.md
    ```

    b. **AI Task (Props)**:
    - **ATTACH**: `process/thumbnail.png` (MANDATORY)
    - **READ**: `scripts/current-props-prompt.md`
    - **INSTRUCTION**: "Extract props and state data. Be pixel-perfect with text and image paths."
    - **SAVE**: Paste the JSON result into `scripts/ComponentName-props.json`.

    c. **Save & Validate**:

    ```bash
    node scripts/coderio-skill.mjs save-props "ComponentName"
    # If this fails, re-do step 'b' with better attention to the thumbnail
    ```

---

# Phase 2: Code Generation

## Step 2.1: Plan Tasks

```bash
node scripts/coderio-skill.mjs list-gen-tasks
```

This outputs a list of tasks with indices (0, 1, 2...).

## Step 2.2: Generate Components (Iterative)

**For EACH task index (starting from 0)**:

1.  **Generate Prompt**:

    ```bash
    node scripts/coderio-skill.mjs code-prompt 0 > scripts/code-prompt.md
    # Replace '0' with current task index
    ```

2.  **AI Task (Code)**:
    - **ATTACH**: `process/thumbnail.png` (MANDATORY)
    - **READ**: `scripts/code-prompt.md`
    - **INSTRUCTION**: "Generate the React component code. Match the thumbnail EXACTLY. **Use STRICT text content from input data, do not hallucinate.**"
    - **SAVE**: Paste the code block into `scripts/code-output.txt`.

3.  **Save Code**:
    ```bash
    node scripts/coderio-skill.mjs save-code 0
    # Replace '0' with current task index
    ```

## Step 2.3: Final Integration

Inject the root component into `App.tsx`. Use the path found in the last task of Phase 2.1.

---

# Troubleshooting

- **"Props validation failed"**: The AI generated empty props. Check if `process/thumbnail.png` was attached and visible to the AI. Retry the props generation step.
- **"Module not found"**: Ensure `node scripts/coderio-skill.mjs save-code` was run for the child component before the parent component. Phase 2 must be done in order (0, 1, 2...).
- **"Visuals don't match"**: Did you attach the thumbnail? The AI relies on it for spacing and layout nuances not present in the raw data.

Overview

This skill automates pixel-perfect conversion of Figma designs into production-ready React components using coderio. It outputs TypeScript + Vite + TailwindCSS V4 code with robust error handling, checkpoint recovery, and a helper script to streamline execution. The workflow enforces visual fidelity and strict use of source text to avoid hallucinations.

How this skill works

The helper script isolates coderio and runs a three-phase pipeline: SETUP (prepare scripts), PROTOCOL (generate component structure and props using the Figma thumbnail), and CODE (produce components and integrate them into the app). Each AI task requires attaching process/thumbnail.png, saving AI outputs to designated files, and then invoking save commands to persist results and recover from failures. Built-in checks guard against missing props, module order problems, and visual mismatches.

When to use it

  • Converting Figma UIs to production React with strict visual fidelity
  • Bootstrapping a TypeScript + Vite + Tailwind project from design assets
  • Generating component structure and explicit prop contracts from complex layouts
  • Automating iterative code generation with checkpointed saves
  • Recovering interrupted design-to-code processes without restarting

Best practices

  • Always attach process/thumbnail.png to every AI task; thumbnails drive spacing and layout decisions
  • Run Phase 2 tasks in numeric order and save each child component before its parent to avoid module-not-found errors
  • Validate structure-output.json and each ComponentName-props.json before running save commands
  • Use the helper script inside scripts/ to keep coderio dependencies isolated and reproducible
  • When props validation fails, re-run the props extraction step with clearer attention to visible text and image paths

Example use cases

  • Full conversion of a Figma landing page into modular React components ready for integration
  • Iterative generation of reusable UI primitives (buttons, cards, headers) with explicit props JSON
  • Scaffolding a new Vite + TypeScript + Tailwind project and injecting the generated root component into App.tsx
  • Recovering a partially completed conversion after an interrupted run using checkpoint files and save commands

FAQ

What prerequisites do I need to run this skill?

You need a Figma personal access token, Node.js 18+, and the helper script plus coderio installed under scripts/ via pnpm install.

Why is the thumbnail required for every AI task?

The thumbnail conveys spacing, alignment, and visual cues absent from raw design nodes; omitting it often produces incorrect props or layout.