# Claude Design

> Turning real codebases and brand guidelines into on-brand interactive prototypes, wireframes, decks, and product one-pagers—with live Control Knobs, inline comments, and Figma MCP or Claude Code handoffs.

- **Topic:** [Anthropic Claude](https://twelve-pages.com/topics/claude)
- **Web Edition:** https://twelve-pages.com/guides/claude/claude-design
- **Printable 12-Page PDF:** https://twelve-pages.com/guides/claude/claude-design/Claude_Design_Complete_How_To_Guide.pdf (3.1 MB)
- **Version:** v1.0 (Updated 2026-11)
- **Reading Time:** 12 minutes (12 pages)
- **Authorship:** AI-authored under human editorial direction & print QA (https://twelve-pages.com/editorial)
- **Tags:** Codebase & Brand Onboarding · 4 Visual Deliverable Modes · Live Studio Control Knobs · Inline Comments & Direct Tweaks · Figma MCP & Code Connect · Claude Code & Gamma Export

## Core Takeaways

- **Never Start Off-Brand:** Ingest React, Tailwind, shadcn/ui, tokens.json, and brand PDFs during onboarding so every frame uses your real system tokens.
- **Dial, Comment, Tweak Live:** Adjust layout density, dark mode, type scale, radii, and variants through live Control Knobs and inline pins without hand-editing code.
- **Round-Trip Everywhere:** Sync editable auto-layout layers via Figma MCP & Code Connect, hand components to Claude Code, or export to Gamma and headless stacks.

## 1. Bridging Conversation, Brand Systems, and Real Code

Generic AI UI generators invent throwaway buttons and mismatched fonts on every prompt. Anthropic Labs built Claude Design as an interactive visual prototyping studio grounded in your team’s living Design System—so conversational ideas look and behave like your actual product from Draft 1.

### Quick Navigation

### Why Token-First Visual Generation Changes Everything

Instead of treating every layout like a disconnected drawing, Claude Design separates visual authoring into two coordinated layers: a persistent **Design System Registry** (ingesting your color tokens, typography scale, spacing rhythm, and mapped React or Figma primitives) and a **Live Generative Canvas** powered by vision-capable Claude Opus models. Product managers, founders, designers, and engineers can co-create clickable prototypes, multi-screen wireframes, executive slide decks, and product one-pagers that remain strictly faithful to brand rules.

### Architecture: From Brand & Repo Onboarding to Bidirectional Handoffs

#### Not a Replacement for Figma or Engineering—The High-Speed Bridge Between Them

Claude Design eliminates blank-canvas bottlenecks and off-brand mockups: non-designers draft credible interactive concepts using approved company tokens, while designers and developers round-trip clean layers into Figma and production repositories.

## 2. Plans, Activation & Design Surface Decision Matrix

Born in Anthropic Labs, Claude Design operates across web (claude.ai and claude.ai/design), Claude Desktop (macOS and Windows), mobile review apps, and Claude Code workflows—powered by Anthropic’s vision-capable Claude Opus models.

#### 1 Availability Across Plans & Surfaces

- **Pro & Max Plans:** Available directly in your workspace and Artifacts studio; draws from your subscription's shared Claude Opus usage pool.
- **Team Plan:** Supports shared Design Systems, workspace-wide interactive review links, and inline commenting across colleagues.
- **Enterprise Plan:** Governed under `Organization settings → Artifacts` with org-locked brand kits, SSO-scoped previews, and MCP allowlists.
- **Web, Desktop & Mobile:** Build and dial Control Knobs on web or Desktop; tap through prototypes and post inline feedback from iOS/Android.

#### 2 Three Ways to Launch Claude Design

1. **Studio Onboarding (`claude.ai/design`):** Pick your role, upload brand guidelines or a Figma link, and build a reusable Design System before Screen 1.
2. **Codebase-First via Claude Code:** Run `/design-sync` in your frontend repo so Claude imports `tokens.json`, Tailwind config, and `shadcn/ui` primitives.
3. **In-Chat & Artifacts Picker:** Choose **Design** from the Artifacts studio or prompt inside a Claude Project already holding your product specs.

#### 60-Second Team Design System Setup

1. Connect GitHub frontend repo (or upload `tokens.json` + brand PDF). 2. Inspect extracted color palette, typography ramp, spacing scale, and component primitives. 3. Click **Publish to Team Workspace** so every teammate's prompts inherit approved brand styling automatically.

### Visual Workspace Decision Matrix: Choosing the Right Surface

| Tool / Surface | Best-Fit Output | Brand & Token Fidelity | Live Editing Controls | Handoff & Code Parity |
| --- | --- | --- | --- | --- |
| **Claude Design** *Visual Prototyping Studio* | Clickable prototypes, multi-screen wireframes, exec decks & one-pagers. | **Highest AI Fidelity:** Locked to ingested repo, `tokens.json` & brand PDFs. | **Live Control Knobs:** Density, theme, type scale, radii, variants + inline pins. | **Bidirectional:** Figma MCP / Code Connect, Claude Code, Gamma & web. |
| **Claude Whiteboards** *Spatial Thinking Canvas* | Voice-to-board brainstorms, sticky clusters, swimlanes & retros. | **Semantic Stickies:** Color-coded by risk, owner & team rather than brand UI. | **Region-Box AI:** Lasso corner clusters and co-edit stickies with live cursors. | **Planning Export:** Converts to Claude Docs, Slides, Lucid, Miro & Vani. |
| **Figma** *Canonical Design Suite* | Pixel-precision vector libraries, master design systems & multi-team critiques. | **Source of Truth:** Authoritative variables, branching & component specs. | **Manual Vector & Auto-Layout:** Full frame-by-frame designer control. | **MCP + Code Connect:** Feeds real components directly to Claude Design & Code. |
| **Standard React Artifacts** *Single-File Code Previews* | Quick calculators, data charts & single-turn functional utilities. | **Ad-Hoc Styling:** Uses default Tailwind classes unless manually pasted per chat. | **Re-Prompt Only:** No live Control Knobs panel or canvas element pinning. | **Copy-Paste JSX:** Single component snippet; no Figma or Gamma pipeline. |

#### Winning Sequence: Ideate in Whiteboards -> Prototype in Design -> Govern in Figma & Claude Code

Map messy product architecture in **Claude Whiteboards**, drop that flow into **Claude Design** to build a clickable prototype matched to your real `shadcn/ui` library, then export to **Figma** for polish or straight into **Claude Code** for production wiring.

## 3. Annotated Tour: Inside the Claude Design Studio

Every Claude Design session unites three live panels: a brand-aware prompt and comment stream on the left, an interactive clickable preview canvas in the center, and real-time Control Knobs on the right.

Acme • Billing_Flow Acme UI + tokens.json

Desktop / Mobile v3 Export: Figma / Code / Gamma

Chat & Inline Comment Thread

**You:** "Build a 2-step workspace upgrade modal using our Acme `Card` and `Badge` tokens."

**Pin #1 (Maya):** "Shorten Pro CTA copy and highlight annual savings pill."

**Claude:** Updated Pro card CTA and bound badge to `--accent-orchid`.

Prompt Studio Canvas...

"Add SSO seat counter step after plan click"

Interactive Preview Mode: **Prototype** • Step 1/2

Choose Your Team Tier

Billed annually • Instant seat provisioning

Save 20%

Starter Team

$25 / seat

Shared Design Systems & view links

Select Starter

Scale Pro

$48 / seat

Figma Code Connect + SSO locks

Upgrade Now ->

Click any element to edit or drop a pin WCAG AA: Pass

Control Knobs

Layout Density**Balanced**

Surface Polarity**Dark**

Light Dark

Typography Scale**1.12x**

Radius & Spacing**10px**

Component Variant**Elevated**

**Active Design System Pill:** Confirms which ingested codebase, `tokens.json`, or brand PDF governs every token and primitive on screen.

**Brand-Aware Chat & Comments:** Issue global instructions in plain English or resolve teammate feedback pins bound to exact components.

**Interactive Prototype Canvas:** Click buttons, switch tabs, and verify responsive desktop/mobile flows live—not static placeholder images.

**Inline Pins & Direct Canvas Tweaks:** Click any card or heading directly on canvas to edit microcopy inline or request a targeted component tweak.

**Dynamic Control Knobs Panel:** Slide layout density, toggle light/dark mode, scale typography, adjust corner radius, or swap variants without coding.

**Artifact Version Snapshots (`v1..vN`):** Every major iteration saves a non-destructive checkpoint so you can compare directions cleanly.

**Bidirectional Export & Handoff Menu:** Round-trip editable layers to **Figma** (via Figma MCP & Code Connect), hand JSX components into **Claude Code**, or export slide decks and pages to **Gamma**, `.pptx`, PDF, and headless web bundles.

## 4. Codebase & Brand Onboarding: Your Living Design System

The secret to shipping production-grade visuals in Claude Design happens in the first two minutes. During onboarding, Claude ingests your actual frontend codebase and brand assets to construct a reusable Design System that governs every prototype, deck, and one-pager.

*[Illustration: Isometric Plum-Obsidian Studio Showing Translucent Color Swatches and Grid Tiles Passing Through an Alignment Frame into Unified Component Cards]*

**From Raw Code & Brand PDFs to Unified Primitives:** Claude Design extracts semantic color variables, typography scales, spacing rhythm, and React/`shadcn/ui` component signatures into one persistent workspace Design System.

### The 4 Onboarding Sources That Eliminate Off-Brand Output

#### 1 Frontend Repo & `shadcn/ui` Primitives

Point onboarding at your React and Tailwind repository (or run `/design-sync` from Claude Code). Claude indexes your real `Button`, `Card`, `Input`, and `Dialog` props so prototypes mirror production components instead of inventing generic HTML tags.

#### 2 Token Files (`tokens.json` & CSS Vars)

Import W3C `tokens.json` or `globals.css` files. Claude locks semantic surfaces (`--bg-card`, `--accent-primary`), type ramps, 4px/8px spacing multiples, and border radii into the Design System registry.

#### 3 Brand Guidelines, Briefs & Decks

No code repo yet? Upload a brand guideline PDF, SVG logo marks, marketing brief, or two screenshots of your live app. Claude infers color roles, visual tone, and editorial hierarchy into a shareable starter kit.

#### 4 Explicit `DESIGN.md` Rule Layer

Attach crisp plain-English guardrails alongside tokens—for example, *"reserve berry-pink exclusively for primary CTAs, keep data tables borderless, and never use gradients behind body copy."*

```
<code># Recommended Onboarding Sequence (Codebase + Brand Brief):
1. Open Claude Code in your web repo and run: /design-sync (indexes tailwind.config, tokens.json, components/ui/*)
2. Upload Brand_Guidelines_2026.pdf + Product_Voice_Brief.md inside claude.ai/design onboarding
3. Inspect the generated Design System preview (Colors, Type Scale, Spacing, Primitives) → Click "Lock & Publish"</code>
```

#### Pro Tip: Organize Tokens by Semantic Intent, Not Literal Color Names

Map variables by role (`surface-subtle`, `border-focus`, `text-secondary`) rather than `pink-500` or `gray-100`. Semantic naming guarantees that toggling Light and Dark Control Knobs preserves accessible contrast automatically.

## 5. The 4 Deliverable Modes & 5-Part Prompt Anatomy

Once your Design System is locked in, a single workspace switches smoothly across four core output formats—serving product, design, engineering, and marketing workflows without shifting tools.

#### 1 Interactive Clickable Prototypes

Working multi-step web and app prototypes with real hover states, clickable tabs, conditional modals, and responsive mobile views—ideal for stakeholder demos, user testing, and direct **Claude Code** handoffs.

#### 2 Multi-Screen UX Wireframes

Rapid 4-to-12-screen architectural flows (such as Onboarding, Empty States, Error Recovery, and Checkout) focused on information hierarchy and navigation logic before investing in high-fidelity graphics.

#### 3 Executive Slide Decks

Board readouts, GTM launches, and customer pitch decks laid out with crisp KPI grids, visual comparison cards, and consistent brand headers—exportable directly to `.pptx`, PDF, or **Gamma**.

#### 4 Marketing & Product One-Pagers

High-polish launch briefs, pricing comparison pages, and solution summaries adhering strictly to brand typography and voice—exportable as print PDFs or clean headless web blocks.

### The 5-Part Claude Design Prompt Anatomy

Combining these five color-coded prompt blocks generates on-brand, interactive layouts with ready-to-use Control Knobs on the very first pass:

[1. Deliverable Mode & Viewport] Create a 4-screen interactive desktop + mobile UI prototype [2. Bound Design System] bound strictly to our Acme UI Design System (`shadcn/ui` Tabs, Card, Badge + `tokens.json`) [3. Screen Flow & Content] guiding a new workspace admin through Team Name -> Repo Sync -> Role Permissions -> Ready Confirmation with real Back/Continue navigation and realistic sample data. [4. Control Knob Defaults] Expose live Control Knobs for Layout Density (start Balanced), Light/Dark Mode, Typography Scale, Border Radius, and Card Variant. [5. Parity & Handoff Guardrail] Use zero custom hex overrides so every screen passes WCAG AA contrast and exports cleanly to Figma Code Connect and Claude Code.

| Prompt Component | What It Controls in the Studio | Failure Mode When Omitted |
| --- | --- | --- |
| Deliverable Mode & Viewport | Selects Prototype, Wireframe, Slide Deck, or One-Pager + target screen sizes. | Claude guesses a static marketing sheet when you wanted clickable app screens. |
| Bound Design System | Locks active palette, typography scale, and exact `shadcn/ui` or Figma primitives. | Generic blue buttons and unmapped CSS appear, breaking Code Connect parity. |
| Screen Flow & Content | Defines exact screen sequence, interactive states, and domain-specific sample data. | Outputs 1 disconnected screen filled with shallow placeholder copy. |
| Control Knob Defaults | Generates tailored live sliders and toggles in the right-hand inspector. | Requires manual chat prompts every time you want tighter padding or dark mode. |
| Parity & Handoff Guardrail | Enforces semantic tokens, accessibility contrast, and clean export structure. | Hard-coded colors break Dark Mode toggles and force manual rewrite in Claude Code. |

## 6. Refining Live: Control Knobs, Comments & Variants

Traditional AI chat tools punish small visual tweaks: asking to “make cards slightly tighter and softer” often triggers a slow full-screen rewrite that scrambles copy you already approved. Claude Design gives you three fast, surgical refinement levers.

#### 1 Live Control Knobs

Drag dynamic sliders generated directly alongside your preview to adjust layout density, light/dark polarity, type scale, corner radius, spacing rhythm, and component variants instantaneously—zero code edits needed.

#### 2 Inline Element Pins

Click any individual badge, navbar, or pricing card on canvas to attach a targeted comment pin. Claude modifies only that anchored element subtree while keeping surrounding screens untouched.

#### 3 Direct Canvas Tweaks

Click straight into headlines, button labels, or table columns to edit wording manually or reorder cards in place without spending another prompt turn.

### Mastering the 5 Core Studio Control Knobs

| Control Knob | Live Range / Options | When & Why to Dial It During Review |
| --- | --- | --- |
| **Layout Density** | `Compact ↔ Balanced ↔ Airy` | Slide toward **Compact** for dense B2B dashboards and data tables; slide to **Airy** for executive one-pagers and marketing heroes. |
| **Light / Dark Mode** | `Light` • `Dark` • `High-Contrast` | Test semantic `tokens.json` surface swaps live in front of stakeholders to catch unreadable borders or muted badge contrast early. |
| **Typography Scale** | `0.90x – 1.30x` ratio slider | Scale headline drama upward for slide decks and landing pages, or tighten heading ratios so multi-pane app screens fit without vertical scrolling. |
| **Radius & Spacing** | `2px Sharp – 16px Pill` | Tune corner softness and card-to-card gutter rhythm uniformly across every button, modal, and input box in a single drag. |
| **Component Variant** | `Minimal \| Elevated \| Outlined` | Cycle through mapped `shadcn/ui` or Figma Code Connect styles without rewriting component props or losing interactive states. |

#### Pro Habit: Explore 3 Structural Variants First, Then Fine-Tune With Knobs

Before dialing details, prompt: *"Generate 3 structural variants of this dashboard side by side: (A) left sidebar rail, (B) top tabbed bar, and (C) split master-detail drawer."* Pick the strongest layout skeleton, lock a `vN` snapshot, and only then refine proportions with Control Knobs and inline comment pins.

#### Keep Knobs Live by Avoiding Hard-Coded Hex Overrides in Chat

If you ask in chat to force an arbitrary hex like `#ff0099` on one card, that element stops responding smoothly to Light/Dark Mode knobs. Always request semantic overrides such as *"swap Card 2 border to `--border-accent-strong`."*

## 7. Bidirectional Handoffs: Figma, Claude Code & Web Stacks

Design momentum collapses when prototypes stay trapped as throwaway mockups. Claude Design provides clean round-trip bridges into Figma, Claude Code, Gamma, and modern headless web architectures.

*[Illustration: Central Luminous Orchid-Pink Prototype Slate Radiating Optical Bridges to Layered Auto-Layout Canvas Frames, Code Monoliths, Slide Stacks, and Responsive Web Grids]*

**One Token-Accurate Prototype, Four Downstream Pipelines:** Round-trip editable auto-layout layers via Figma MCP & Code Connect, hand JSX directly into Claude Code, export narrative decks to Gamma, or publish headless web blocks.

#### 1 Figma Round-Tripping (MCP + Code Connect)

- **Pull via Figma MCP Server:** Paste a Figma frame URL so Claude reads exact auto-layout constraints, variable collections, and component props before prototyping.
- **Code Connect Mapping:** Map Figma components directly to repo primitives (`<Button />`, `<DataTable />`) so generated prototypes use real production imports.
- **Push Editable Layers Back:** Export settled screens into Figma as structured, editable auto-layout frames via Figma MCP or HTML-to-Figma conversion layers—never flat bitmaps.

#### 2 Claude Code, Gamma & Headless Stacks

- **Direct to Claude Code:** Hand off finalized React, Tailwind, and `shadcn/ui` component bundles straight into a Claude Code session (or via `/implement-design`) to wire live APIs and tests.
- **Gamma & Slide Exports:** Push structured executive decks directly to **Gamma** (or download crisp `.pptx`, PDF, and Canva-ready assets) with slide hierarchy intact.
- **Headless Web Stacks:** Export clean HTML/CSS/JSX modules or structured JSON block payloads for Next.js, Astro, and headless CMS platforms (including Wix Headless).

### Ecosystem Export & Round-Trip Reference

| Target Platform | Recommended Handoff Trigger | What Carries Over & Ideal Next Step |
| --- | --- | --- |
| **Figma (Bidirectional)** | `Export → Send to Figma` (MCP / Auto-Layout) | Editable auto-layout frames, token variables, and Code Connect component links for design-system polish. |
| **Claude Code** | `Hand off to Claude Code` / `.zip` JSX bundle | Repo-matched React + Tailwind + `shadcn/ui` components ready for API wiring, state hooks, and PR review. |
| **Gamma / PPTX / PDF** | `Export → Gamma` or `.pptx` / Print PDF | Structured slide acts, narrative callouts, and brand-locked headers for leadership pitches and board meetings. |
| **Headless Web Stack** | `Export → HTML/JSON Bundle` | Clean semantic sections, responsive grid tokens, and reusable marketing blocks for Next.js or headless CMS stacks. |

## 8. 5 Real-World Copy-Paste Claude Design Recipes

Paste any recipe below into Claude Design with your published Design System active to produce high-precision prototypes, UX wireframes, slide decks, product one-pagers, or Figma-to-Code round-trips immediately.

| Recipe & Use Case | Copy-Paste Prompt (Zero Ambiguous Placeholders) | Output & Next Move |
| --- | --- | --- |
| **1. Repo-Synced Interactive Prototype** *Product & Eng* | `Build a 3-screen interactive Seat Billing & SSO Settings prototype bound to our Acme UI Design System (shadcn/ui Tabs, Table, Dialog + tokens.json). Include realistic member rows, an active seat-limit warning modal, and working Light/Dark, Density, and Radius Control Knobs. Keep all imports repo-valid for Claude Code handoff.` | Clickable React/`shadcn/ui` prototype; dial knobs live, then hand straight to Claude Code. |
| **2. Multi-Screen UX Wireframe Flow** *UX Architecture* | `Switch to Multi-Screen Wireframe mode and map a 6-screen responsive onboarding journey (Welcome → Connect GitHub → Pick Tokens → Preview Theme → Invite Team → Empty Dashboard). Include mobile breakpoints, loading skeletons, and explicit error-recovery states, with a Layout Density Control Knob.` | 6-screen desktop/mobile blueprint ready for inline pin critique before visual polish. |
| **3. Executive Launch Slide Deck** *Leadership & PM* | `Convert our Q3 Launch PRD attached in this Project into an 8-slide Executive Deck using our Brand Design System. Structure slides as: Title Hero, Customer Pain, Product Demo Flow, Adoption Metrics, Competitive Grid, Architecture Summary, GTM Timeline, and Budget Ask. Expose Type Scale and Density Control Knobs.` | Brand-locked 8-slide deck; export directly to **Gamma** or `.pptx` for VP readout. |
| **4. Product One-Pager & Pricing Sheet** *Product Marketing* | `Design a crisp 1-page Enterprise Security Datasheet and 3-tier Pricing Comparison bound to our official Brand PDF and tokens.json. Include a top value summary, 3 proof pillars, a clean feature comparison grid, and an executive CTA footer. Expose Compact/Airy Density and Card Variant Control Knobs.` | Sales-ready PDF one-pager + clean headless HTML/JSON section blocks for web launch. |
| **5. Figma Code Connect Round-Trip** *Design Systems* | `Read our linked Checkout Card frame via the Figma MCP server and match every button, badge, and input to our repo's Code Connect mappings. Generate 2 responsive interactive promo-code state variants using tokens.json only, then prepare an editable auto-layout export for Figma plus JSX diff for Claude Code.` | Bidirectional sync keeping Figma layers and production React primitives 100% aligned. |

#### Power Combo: Feed Whiteboards & PRDs Straight Into Recipe #1 or #2

Already mapped a user journey in **Claude Whiteboards** or drafted a spec in a **Claude Project**? Reference it directly in your prompt so every button label, edge case, and error message on screen matches real product requirements.

#### Snapshot Separate Desktop & Mobile Knob States

Before exporting a bundle to engineering, dial your Control Knobs for desktop spaciousness (save `v4`), then toggle mobile preview with tighter density (save `v5`) so developers inspect both responsive snapshots.

## 9. Collaboration, Org Governance & Sharing Permissions

Interactive prototypes often reveal unannounced features, pricing models, and proprietary design tokens. Claude Design enforces org-scoped sharing boundaries, role-based review controls, and Design System governance across every tier.

#### 1 Org-Scoped Sharing & Granular Roles

- **View, Comment & Edit Tiers:** Share prototypes as read-only **Viewers** for leadership demos, **Commenters** for inline element feedback pins, or **Editors** for live co-prompting and Control Knob adjustments.
- **SSO-Bounded Team & Enterprise Links:** Shared design URLs require authenticated workspace SSO login by default—preventing accidental public internet leaks of unreleased roadmaps.
- **Published Brand Locks:** Design leads lock foundational colors, logos, and typography rules inside shared Design Systems so teammates explore freely without drifting off-brand.

#### 2 Admin Policy & Connector Governance

- **Central Feature Controls:** Primary Owners manage studio access under `Organization settings → Artifacts`, custom RBAC roles, and shared Design System publishing permissions.
- **Zero Model Training Guarantee:** On Claude Team and Enterprise plans, ingested code repositories, `tokens.json` schemas, brand PDFs, and generated designs are **never** used to train Anthropic models.
- **Approved MCP Export Targets:** Security admins independently allowlist **Figma MCP**, Canva, Gamma, and headless CMS connectors to enforce strict data-egress boundaries.

### Permission & Governance Matrix Across Tiers

| Capability / Guardrail | Pro & Max | Team Plan | Enterprise Plan |
| --- | --- | --- | --- |
| **Studio Access & Roles** | Personal studio access | Org-wide toggle & shared Projects | RBAC role-scoped under `Org settings` |
| **Design System Governance** | Private reusable kits | Shared team brand & token libraries | Locked canonical systems + owner approval |
| **Prototype Link Scope** | Private or shareable preview link | Workspace-authenticated View/Comment/Edit | Strict SSO-only org scoping + audit logs |
| **Figma, Gamma & Code Sync** | User OAuth / local repo sync | Team connector policy | Admin MCP allowlist + DLP/egress controls |

#### Security Hygiene: Scope Codebase Onboarding Strictly to UI Directories

When syncing a repository via `/design-sync` or GitHub onboarding, include only frontend styling and primitive directories (`tokens.json`, `tailwind.config.*`, `src/components/ui/`). Never attach `.env` secrets, private backend credentials, or real customer database exports into a visual Design System context.

#### Sanitize Sample Data Before External Usability Testing

Before exporting standalone HTML or `.zip` bundles for external user research, instruct Claude Design: *"Replace all sample account names, revenue figures, and email strings with realistic synthetic fixtures."*

## 10. Cross-Tool Synergy: From Discovery to Shipped Code

Claude Design acts as the visual synthesis hub in Anthropic’s wider ecosystem—converting early strategy from Claude Meetings, Projects, and Whiteboards into living prototypes that flow smoothly into Figma, Gamma, Claude Code, and Claude Security.

### Walking the 4-Stage Pipeline in One Afternoon

#### 1 Meetings + Whiteboards -> Design Prompt

Take an approved user journey from **Claude Whiteboards** and customer insights from your **Claude Project**, then prompt Claude Design to render an interactive multi-screen flow locked to your active Design System.

#### 2 Control Knobs + Figma Code Connect

Tune layout density and dark mode live with stakeholders, drop inline pins on copy edge cases, and push editable auto-layout layers to **Figma** with real Code Connect mappings intact.

#### 3 Simultaneous Gamma Deck & One-Pager

In the same project thread, ask Claude Design to package the finalized product concept into an executive slide deck (exported to **Gamma** or `.pptx`) plus a headless web launch one-pager.

#### 4 Hand Off to Claude Code & Security

Send exported React + Tailwind + `shadcn/ui` components directly to **Claude Code** to wire live endpoints, then verify auth and XSS safety through **Claude Security** before merging.

#### Keep One Canonical Token File as Your Shared North Star

Whenever engineering updates spacing, fonts, or semantic colors in `tokens.json`, run `/design-sync` again so Claude Design, Figma Code Connect, and Claude Code never drift out of sync.

## 11. Troubleshooting Clinic & Pre-Flight Checklist

Use this diagnostic reference whenever generated screens drift off-brand, Control Knobs behave unexpectedly, or a Figma/Code handoff needs repair—followed by our 6-point launch checklist.

| Symptom / Issue | Root Cause | 10-Second Fix |
| --- | --- | --- |
| **1. Generated UI looks generic and ignores brand fonts/colors** | Prompted inside an isolated chat with no active Design System bound. | Complete codebase/brand onboarding (attach `tokens.json`, Tailwind config & brand PDF), select your published Design System pill, and regenerate. |
| **2. Dark Mode Control Knob leaves bright white blocks or unreadable text** | Hard-coded hex values (like `#ffffff`) injected during a manual chat tweak. | Prompt: *"Audit all components and replace hard-coded hex colors with semantic surface, border, and foreground variables from tokens.json."* |
| **3. Figma export lands as flat images instead of editable layers** | Downloaded static PNG/PDF snapshot or skipped Figma MCP / conversion bridge. | Connect the official **Figma MCP server**, enable **Code Connect** mappings, or export via the HTML-to-Figma auto-layout layer pipeline. |
| **4. Small copy or card tweak accidentally rewrote surrounding screens** | Issued a broad conversational prompt instead of targeting one element. | Step back one version via the `v1..vN` selector, click directly on the target component to drop an **Inline Comment Pin**, and re-apply locally. |
| **5. Expected Control Knobs sliders are missing from the right panel** | Initial prompt omitted adjustable design parameters. | Ask in chat: *"Expose live Control Knobs for layout density, light/dark mode, typography scale, border radius, and card variant."* |
| **6. Claude Code rewrites exported JSX instead of reusing repo components** | Design System lacked exact component paths or Code Connect signatures. | Run `/design-sync` inside your frontend repo to index `shadcn/ui` and local component props, then re-export the React bundle. |
| **7. Reviewer hits "Access Denied" on a shared prototype link** | Org-scoped SSO protection blocked a personal account or external email. | Ask the reviewer to sign in with corporate SSO, or request an Enterprise admin to approve external View/Comment link sharing if policy allows. |

### 6-Point Claude Design Pre-Flight Checklist

✓

**1. Bind Design System First:** Verify `tokens.json`, Tailwind config, and brand PDFs are active before generating Screen 1.

✓

**2. Name Deliverable Mode Clearly:** Specify Prototype, Wireframe, Slide Deck, or One-Pager up front.

✓

**3. Enforce Semantic Token Roles:** Avoid hard-coded hex values so Light/Dark Control Knobs stay WCAG AA compliant.

✓

**4. Use Inline Pins for Local Tweaks:** Anchor comments to specific elements instead of triggering full-flow rewrites.

✓

**5. Checkpoint Before Bold Variants:** Lock a `vN` snapshot prior to testing extreme knob settings or new layouts.

✓

**6. Validate Handoff Parity:** Check Figma Code Connect component names, Gamma slide breaks, or Claude Code imports pre-export.

#### Final Takeaway: Speak Product Intent, Let Your Design System Govern the Pixels

When your codebase tokens, brand guidelines, and Figma Code Connect sit underneath Claude Design, every creative conversation produces cohesive, interactive, ship-ready artifacts—compressing the trip from early sketch to production code into a single afternoon.

---

## Edition Note & Attribution

This 12-page handbook, its topic structure, and its illustrations were generated with AI under human editorial direction and print-layout QA. Verify commands, pricing tiers, and security settings against official vendor documentation before production use.

- AI & Editorial Disclosure: https://twelve-pages.com/editorial
- Terms & Licensing: https://twelve-pages.com/terms
- Privacy & Cookie Notice: https://twelve-pages.com/privacy
