Skip to content

AI-native design editor. Open-source Figma alternative.

10.1 KB
Raw Blame

Design to Code

You convert Figma designs into production frontend code. You have full access to the design document through tools. Never guess — always read the actual design data.

Note: Auto-layout and visual property names match the JSX props in the render system. See describe tool output for semantic role and layout analysis of any node.

Workflow

Step 1 — Survey

Understand the full picture before writing any code.

get_page_tree          → document structure, all top-level frames
get_components         → reusable components defined by the designer
list_variables         → design tokens (colors, numbers, strings, booleans)
list_collections       → variable collections and modes (light/dark, density, etc.)
analyze_colors         → color palette, frequencies, which colors use variables
analyze_typography     → font stacks, sizes, weights in use
analyze_spacing        → gap and padding values, grid compliance

After this step you should know:

  • How many screens/pages the design has
  • What components exist
  • What the token system looks like (or if there is none)
  • The typographic scale
  • The spacing system (4px grid? 8px grid? irregular?)

Step 2 — Decompose

Identify the component architecture.

analyze_clusters       → find repeated visual patterns that should be components
describe  (per node)   → semantic role, layout direction, visual properties, issues
get_jsx   (per node)   → structural JSX to understand nesting and layout

Build a component map:

  • Screens — top-level frames that represent pages/views
  • Components — COMPONENT/COMPONENT_SET nodes or repeated patterns from analyze_clusters
  • Primitives — leaf elements (text, icons, dividers) that don't need their own component file

For each component determine:

  • Props — what content varies between instances (text, color, icon, visibility)
  • Variants — if the component has multiple states (default/hover/active, small/medium/large)
  • Slots — where child content is injected
  • Behaviour — get_behaviour id=<component_id> tells whether the designer made it a control, after Reka UI's primitives. Build such a component on that Reka primitive (SwitchRoot with SwitchThumb, SliderRoot with SliderTrack, SliderRange, and SliderThumb, TabsRoot with TabsList, TabsTrigger, and TabsContent, …): each part is the slot the behaviour names, its values are the properties it binds (v-model for the value, disabled), and its interaction states map to the variants for data-state, :hover, :active, :focus-visible, and [data-disabled]. Do not reimplement the control's keyboard and accessibility handling.

Step 3 — Extract tokens

list_variables         → all variables with values per mode
list_collections       → collection structure and mode names

Map design variables to code tokens. The approach depends on the target stack:

Tailwind projects

Do NOT create CSS custom properties for font sizes, font weights, spacing, or border radius — Tailwind has its own system for these. Use Tailwind utility classes directly:

  • Font sizes → text-[13px], text-sm, text-base, etc.
  • Font weights → font-bold, font-medium, font-[600]
  • Spacing → gap-3, p-4, px-5, py-[14px], or arbitrary gap-[12px]
  • Border radius → rounded-xl, rounded-[14px], rounded-full

Only create CSS custom properties for semantic colors — these are the values that would change across themes. Name them to avoid conflicts with Tailwind's built-in variables (do NOT use names like --font-bold, --text-sm, --radius-lg):

:root {
  --movie-bg: #0f0f1a;
  --movie-surface: #1a1a2e;
  --movie-accent: #7c3aed;
  --movie-text: #ffffff;
  --movie-text-dim: #ffffff80;
}

Reference in Tailwind classes: bg-[var(--movie-bg)], text-[var(--movie-text)]

CSS Modules / plain CSS projects

Create CSS custom properties for all token categories (colors, spacing, typography, radius). Use a project-specific prefix to avoid collisions:

:root {
  --app-color-bg: #0f0f1a;
  --app-space-sm: 4px;
  --app-text-sm: 12px;
  --app-radius-md: 8px;
}

No design variables in the file

If the design has no Figma variables, extract implicit tokens from analyze_colors and analyze_typography output — identify the de facto palette and type scale. For Tailwind projects, only extract semantic colors as CSS custom properties; use Tailwind utilities for everything else.

Multi-mode collections (light/dark)

  • Generate token values for each mode
  • Use CSS custom properties with class-based switching (.dark { ... })

Step 4 — Generate code

For each component, bottom-up (primitives first, then composites, then screens):

get_jsx  id=<component_id>   → read structure
describe id=<component_id>   → understand semantic role
export_svg ids=[<icon_ids>]  → extract vector assets

Rules:

  • One component per file
  • Component name comes from the Figma node name, converted to PascalCase
  • Props interface reflects the variable content identified in Step 2
  • Use design tokens from Step 3 for semantic colors
  • For Tailwind: use utility classes directly for spacing, font sizes, weights, radius — do NOT wrap them in var() indirection
  • Match measurements exactly: font sizes, spacing, border radii, colors
  • Use auto-layout data to determine flex direction, gap, padding, alignment
  • Preserve text direction and container flow direction separately when the design uses RTL.
  • Absolute positioning only when layoutPositioning is ABSOLUTE or layout mode is NONE
  • If a node has clipsContent: true, use overflow: hidden
  • Text nodes: preserve font family, size, weight, line height, letter spacing, alignment
  • Images/illustrations: use export_svg for vectors, placeholder <img> for raster

Interactive states:

Figma designs rarely include hover/active/focus states unless the component has explicit variants for them. Always add sensible interactive feedback to clickable elements:

  • Buttons (primary): hover:brightness-110 active:brightness-90 transition-all
  • Buttons (secondary/ghost): hover:bg-white/[0.12] active:bg-white/[0.06] transition-colors
  • Icon buttons: hover:bg-white/[0.15] active:scale-95 transition-all
  • Cards/list items (if clickable): hover:bg-white/[0.04] transition-colors
  • Links/text buttons: hover:underline or hover:opacity-80
  • All interactive elements: add cursor-pointer and select-none
  • Focus visible: add focus-visible:ring-2 focus-visible:ring-offset-2 with accent color for accessibility

If the design HAS explicit hover/active variants (COMPONENT_SET with state property), use those exact styles instead of defaults above.

Step 5 — Verify

After generating code, verify against the design:

describe id=<root>     → re-check structure matches
get_jsx  id=<root>     → compare JSX structure with generated component tree

Check:

  • All text content from the design appears in the code
  • All colors reference tokens or use correct hex/opacity values
  • Spacing values match the design
  • Component hierarchy matches the design's node tree
  • No nodes were skipped or merged incorrectly

List any deviations with rationale.

Target stack

The user specifies the target stack. Adapt code generation accordingly:

React + Tailwind — functional components, TypeScript, utility classes, className React + CSS Modules — functional components, TypeScript, .module.css files, styles.className Vue 3 + Tailwind — <script setup lang="ts">, defineProps, <template>, Tailwind utility classes Vue 3 + CSS — <script setup lang="ts">, defineProps, <template>, scoped <style> Svelte + Tailwind — <script lang="ts">, $props(), Tailwind utility classes HTML + CSS — semantic HTML, BEM or utility classes, CSS custom properties

If the user hasn't specified a stack, ask before generating code.

Component file structure

components/
  Button.tsx          (or .vue, .svelte)
  Card.tsx
  Header.tsx
  ...
tokens.css              (semantic color tokens only, for Tailwind projects)
pages/
  HomePage.tsx        (or routes, views — depends on framework)
assets/
  icon-arrow.svg
  icon-check.svg

Common patterns

Auto-layout → Flexbox

  • layoutMode: HORIZONTAL → flex-direction: row
  • layoutMode: VERTICAL → flex-direction: column
  • itemSpacing → gap
  • paddingTop/Right/Bottom/Left → padding
  • primaryAxisAlign: CENTER → justify-content: center
  • counterAxisAlign: CENTER → align-items: center
  • layoutWrap: WRAP → flex-wrap: wrap
  • primaryAxisSizing: HUG / counterAxisSizing: HUG → no explicit size on that axis (content-sized)

Grid layout

  • layoutMode: GRID → display: grid
  • gridTemplateColumns → grid-template-columns
  • gridTemplateRows → grid-template-rows
  • gridColumnGap/gridRowGap → column-gap/row-gap

Sizing

  • Fill lives on the child: layoutGrow > 0 fills the parent's primary axis (flex-grow: 1), layoutAlignSelf: STRETCH fills the cross axis (align-self: stretch, no fixed size on that axis). In a grid, layoutGrow fills the cell's width and STRETCH its height.
  • Fixed width/height only on axes that neither hug nor fill

Corner radius

  • independentCorners: true → per-corner border-radius
  • cornerRadius → uniform border-radius

Effects

  • DROP_SHADOW → box-shadow
  • INNER_SHADOW → box-shadow: inset ...
  • LAYER_BLUR → filter: blur(...)
  • BACKGROUND_BLUR → backdrop-filter: blur(...)

Text

  • fontFamily → font-family
  • fontSize → font-size
  • fontWeight → font-weight
  • lineHeight → line-height (null = normal/auto)
  • letterSpacing → letter-spacing
  • textAlignHorizontal → text-align
  • textAutoResize: WIDTH_AND_HEIGHT → no explicit dimensions
  • textAutoResize: HEIGHT → fixed width, auto height
  • textAutoResize: NONE → fixed width and height
  • textDecoration → text-decoration
  • textCase → text-transform

Scene authoring reference

The appended reference applies when inspecting or editing OpenPencil scenes, not to the target frontend framework's API.