Home
cd ../playbooks
Developer ToolsIntermediate

Designer's Figma-to-Production Workflow

A structured discuss-plan-execute-verify loop that takes a designer from a Figma file to a deployed, pixel-perfect production site — using Claude Code plus the GSD meta-prompting system, no traditional coding required.

20 minutes
By Tommaso NervegnaSource
#figma#design-to-code#designers#no-code#gsd#vercel#prototyping#design-system#portfolio

You hand off a Figma file and three weeks later the hover states are wrong, the spacing doesn't match, and 'close enough' shipped instead of your actual design — because every handoff loses fidelity somewhere between your file and their code.

Who it's for: designers who want to ship real, deployed products without becoming full-time developers, design directors evaluating whether their team can self-serve implementation, freelance designers wanting to offer functional prototypes instead of static mockups, product designers tired of fidelity loss in developer handoff, anyone with design intuition who's been putting off learning to code

Example

"Build my Figma portfolio design into a live site" → A locked requirements doc splitting scope into V1/V2/out-of-scope, phase-by-phase design decisions captured with exact specs ("hover is transform: translateY(-2px), disabled is exactly 40% opacity"), parallel-executed atomic commits per task, a verification pass checking the deployed site against Figma side-by-side, and a live Vercel URL — a full dashboard built in two days by one designer, per the source workflow

CLAUDE.md Template

New here? 3-minute setup guide → | Already set up? Copy the template below.

Or install from your terminal:
npx ccplaybooks add designer-figma-to-production-workflow
# Designer's Figma-to-Production Workflow

## Your Role

You help a designer — not a developer — ship real, deployed, functional software directly from their design intent, without them learning to code in the traditional sense. The core idea: designers already think in requirements, constraints, and edge cases. The gap has always been translation into working software. Your job is to close that gap by questioning assumptions before building, capturing exact design decisions, and executing in verified phases rather than one long unstructured session.

This workflow pairs Claude Code with **GSD (Get Shit Done)**, a meta-prompting system that structures the discuss → plan → execute → verify loop so context stays fresh and decisions stay traceable.

---

## Setup

Get new playbooks like this one

One email a week with new Claude Code workflows. Free, like everything here.

No spam. Unsubscribe anytime.

README.md

What This Does

A structured build loop — discuss, plan, execute, verify — that lets a designer go from a Figma file (or even just a described concept) to a deployed, functioning site without writing code in the traditional sense. Built on Claude Code plus GSD (Get Shit Done), a meta-prompting layer that questions assumptions before building, locks requirements before execution, and verifies every phase against concrete yes/no deliverables instead of a vague "does this look right."

The Figma-specific path uses MCP integration to pull exact design tokens, component specs, and layout values directly from the file — so the output matches pixel-for-pixel instead of approximating from a screenshot.


Quick Start

Step 1: Create a Project Folder

mkdir my-design-project && cd my-design-project

Step 2: Download the Template

Click Download above, then:

mv ~/Downloads/CLAUDE.md ./

Step 3: Set Up GSD and Start

npx get-shit-done-cc
claude --dangerously-skip-permissions

Then run: /gsd:new-project


The Loop

Discuss → Plan → Execute → Verify
   ↑                          │
   └──── next phase ──────────┘
Step Command What happens
New project /gsd:new-project Interrogates the concept, researches in parallel, produces locked REQUIREMENTS.md and ROADMAP.md
Discuss /gsd:discuss-phase N Surfaces every decision point for the phase — layout, spacing, hover behavior — captured as exact specs, not vibes
Plan /gsd:plan-phase N Research + atomic task plans, verified against requirements before execution starts
Execute /gsd:execute-phase N Parallel/sequential waves, fresh 200k-token context per task, one atomic commit per task
Verify /gsd:verify-work N Concrete yes/no deliverable checklist, auto-diagnosed fix plans for anything failing

Figma-Specific Path

  1. Design in Figma with real structure — named tokens, component variants, Auto Layout
  2. Initialize referencing the file directly, with Figma MCP integration specified
  3. Phase 1 extracts the design system into code, matching Figma exactly
  4. Phase 2 builds components pixel-for-pixel, with exact interaction specs
  5. Later phases build screens using the established design system and components
  6. Verify by comparing the deployed site against Figma with DevTools measurements, not by eye

Tips & Best Practices

  • Never skip the discuss step to save time. Vague direction produces generic output that has to be redone — the discussion itself is the fast path, not an obstacle to it.
  • Lock requirements before execution and resist scope creep mid-phase. The whole structure exists to prevent "just one more feature" from derailing a phase that was already planned and verified.
  • Give exact specs, not descriptions. "Hover is transform: translateY(-2px), disabled is exactly 40% opacity" produces a correct result. "Make the hover subtle" produces a guess.
  • Verify against concrete yes/no deliverables, not a vibe check. "Does this look right?" lets real gaps through — "Do cards lift with shadow on hover? Do they stack on mobile below 768px?" doesn't.
  • Never commit .env. Set up .gitignore to exclude it before the first commit, not as a fix after a credential leaks into git history.

Limitations

  • Depends on the third-party get-shit-done-cc package for the actual /gsd:* slash commands and phase orchestration — this is a real dependency to install, not pure prompt engineering
  • The --dangerously-skip-permissions flag that makes the workflow efficient also means autonomous git commits and file operations without a per-action confirmation — understand what it grants before enabling it
  • The Figma-specific path assumes a genuinely well-structured Figma file (real tokens, proper component variants, sensible naming) — a messy file produces messy extraction regardless of how good the prompting is
  • Best suited for designers building a real product surface (portfolio, dashboard, marketing site) rather than a one-off static mockup, where the phase/verification overhead pays for itself

$Related Playbooks

Developer Tools

Distinctive Frontend Design

Design lead guidance for building frontends that don't read as AI-generated — deliberate palette, typography, and layout choices grounded in the actual subject, with a built-in self-critique pass before you write code.

5 minutes
Intermediate
Developer Tools

Network Issue Debugging

Apply falsification-first, layered isolation to pin down the responsible network layer for connection resets, SSE stalls, and fixed-time drops — instead of stacking assumptions.

20 minutes
Advanced
Developer Tools

Docs Cleaner

Consolidate redundant documentation while preserving all valuable content — merge overlapping files, reduce sprawl, and cut bloat without losing anything important.

10 minutes
Beginner
Developer Tools

Database Sync Manager

Automate database synchronization, replication, migration, and cross-platform data integration

10 minutes
Advanced
Developer Tools

Developer Presentation Builder

Create developer-focused presentations with live code demos and diagrams using Slidev.

10 minutes
Advanced
Developer Tools

DevOps Automation Assistant

DevOps and IT Ops automation - CI/CD, monitoring, incident management, and infrastructure workflows

10 minutes
Advanced
Developer Tools

Discord Bot Builder

Discord bot development - community management, moderation, notifications, and AI integration

10 minutes
Advanced
Developer Tools

Docker Containerization

Containerize applications with production-ready Dockerfiles, Docker Compose configurations, and deployment scripts for Next.js, React, and Node.js projects.

15 minutes
Intermediate
Developer Tools

DevOps Server Manager

Manage servers, Docker containers, VMs, and network infrastructure through Claude Code via SSH. Keep your entire infrastructure documented in markdown files.

15 minutes
Advanced
Developer Tools

Embedding Strategies for RAG

Choose and optimize embedding models for semantic search and RAG — a model comparison table, the query/document prefixes that make-or-break BGE and E5, Matryoshka dimension reduction, four chunking strategies, and a retrieval-quality evaluation harness (precision@k, recall@k, MRR, nDCG@k) so you measure an embedding change instead of guessing at it.

10 minutes
Intermediate
Developer Tools

ETL Pipeline Builder

Design and automate Extract, Transform, Load data pipelines for data integration and analytics

10 minutes
Advanced
Developer Tools

Error Message Explainer — Decode Any Error in Plain English

Paste any error message and get a plain-English explanation, root cause diagnosis, and step-by-step fix. Works with Python, JavaScript, Docker, Git, and any CLI error.

5 minutes
Beginner

Browse all Developer Tools playbooks →