figma-design-to-code

name	figma-design-to-code
description	Implement or update project-consistent UI code from a Figma selection or nodeId using TemPad Dev MCP. Use when the user wants visible Figma UI recreated, ported, or integrated into the target project's framework, styling system, tokens, and existing components when available. Do not use for design critique, product invention, generic code review, or for guessing hidden states, responsiveness, or behavior not shown in design or project evidence.
metadata	{"version":"4.3"}

TemPad Dev: Figma Design to Code

Use this skill to turn TemPad Dev design evidence into project-consistent UI code.

TemPad Dev MCP must be available and able to provide trustworthy design evidence for the current selection or provided nodeId. If not, stop and tell the user to enable or reconnect TemPad Dev MCP.

Within this skill, TemPad Dev MCP is the authoritative source of design evidence. Treat:

• project files and project instructions as implementation truth when available
• TemPad Dev output as design truth
• the user as the source of truth for missing product or implementation decisions

Do not infer project conventions before reading local evidence.

For concerns orthogonal to Figma-to-code translation, follow project instruction files such as AGENTS.md and other project instructions instead of defining new policy in this skill. If such a concern is unspecified there and would materially change the implementation, ask the user or stop.

Evidence model

Use three evidence channels for different jobs:

• Project evidence: AGENTS.md or equivalent project instruction files, design-system docs, token/theme docs, component docs, existing primitives, nearby implementations, framework/styling config, asset rules, and project scripts
• Design evidence: tempad-dev:get_code first for markup, styles, tokens, assets, warnings, and codegen facts; tempad-dev:get_structure only for hierarchy, geometry, overlap, and retry targeting
• User input: missing behavioral intent, responsive intent, target file, acceptable tradeoffs, asset or dependency decisions, or other product or implementation decisions that cannot be recovered from project or design evidence

What TemPad Dev can and cannot prove

TemPad Dev can prove:

• the visible structure of the current selection or a provided nodeId
• explicit layout, spacing, typography, color, radius, borders, shadows, gradients, masks, filters, compositing, and other rendered visual details
• token references and values when present
• exported assets and whether an SVG may safely adopt one contextual color channel via themeable
• codegen facts such as actual output language, cssUnit, scale, and rootFontSize

TemPad Dev cannot prove:

• hidden, hover, active, loading, error, empty, disabled, or responsive states unless separately evidenced
• non-visual product requirements such as behavior, business logic, validation, navigation, or analytics
• project conventions, file placement, component boundaries, primitive-reuse policy, token-mapping policy, or asset workflow beyond what the project already establishes
• missing style truth from get_structure; it is only a structure aid

Default operating rules

Do not output data-hint-* attributes.

Never invent visual details or behavior not evidenced, including color, typography, spacing, radius, borders, shadows, gradients, opacity, overlays, blur, hidden states, responsive behavior, interactions, or asset semantics.

Treat advanced or uncommon style output from TemPad Dev as intentional unless project constraints force an adaptation.

Only ask the user when the answer would materially change the implementation and cannot be established from project or design evidence. Typical blockers:

• more than one plausible target file or component boundary
• more than one plausible existing primitive or abstraction to reuse
• missing behavior, state, or responsive intent
• asset, dependency, or token workflow requiring a product decision

If a gap is minor and non-blocking, proceed with a clearly stated inference.

Prefer the smallest safe change. Do not perform unrelated refactors or add new abstractions unless project patterns clearly call for them.

Do not enter open-ended visual tuning loops without new evidence. If remaining differences cannot be proved from project or design evidence, warn clearly and stop or hand off for user validation.

Workflow

1. Read local evidence first

Read local evidence before implementing. Prioritize, in order:

1. AGENTS.md or equivalent project instruction files
2. relevant design-system, token, and component docs
3. existing primitives/components and nearby implementations
4. config files and scripts that constrain output

Establish at least:

• framework/runtime and file conventions
• styling rules, including whether utilities are used and how classes are ordered or formatted
• token/theme system and mode handling
• asset and icon pipeline
• reusable primitives/components, file placement, and import path conventions
• the narrowest established project checks for this change, if any

Only if the project actually uses Tailwind or Tailwind-compatible tooling, detect Tailwind version and config before changing class syntax or ordering.

For Tailwind projects, also inspect the local theme scales relevant to exact- value mapping, especially spacing, sizing, radius, and typography.

If a material implementation constraint is still missing after local evidence, ask the user instead of inferring it.

2. Fetch the top-level design snapshot

Call tempad-dev:get_code first.

Use these defaults:

• resolveTokens: false
• pass nodeId only when the user provided one; otherwise use the current selection
• set preferredLang to match the project target, such as jsx or vue

Use TemPad's default vector behavior unless the user explicitly asks for asset-preserving vector fidelity and the current MCP version clearly supports it.

Use resolveTokens: true only when the user explicitly does not want design-token usage.

Treat returned lang as authoritative because TemPad Dev plugin or config may override preferredLang.

Record these as design facts:

• code
• lang
• warnings
• assets, if present
• tokens, if present
• codegen

Use codegen.config.{cssUnit,rootFontSize,scale} as the authoritative unit context for exact-value mapping.

Prefer fetching the full requested top-level selection first so parent composition and containment are not lost.

3. Resolve incomplete or conflicting evidence before implementing

If get_code warns or fails, narrow uncertainty instead of guessing.

• depth-cap: keep the returned top-level result as the source of parent layout and composition, then use returned data-hint-id values to choose narrower get_code follow-ups for the subtrees you still need.
• budget overflow or shell response: keep the returned parent shell as the composition source of truth, then fetch omitted child subtrees separately and fill them into that known shell. Prefer the smallest parent container that still preserves the shared layout for the child subtrees you must assemble. Do not treat plain string truncation as usable evidence.
• layout, hierarchy, or overlap uncertainty: call tempad-dev:get_structure, but use it only to resolve hierarchy or geometry, or to choose a narrower parent-shell retry target. Do not treat it as missing style truth.
• remaining contradiction: if project evidence, design evidence, and structure evidence still conflict after narrowing, stop.
• untrustworthy parent recovery: if you still cannot obtain a trustworthy parent shell or parent composition via get_code, stop full implementation and ask the user to narrow scope or choose the highest-priority subtree.

Retry policy:

• retry once only for transient transport or connectivity failures
• do not blind-retry deterministic issues such as invalid selection, hidden node, wrong file, depth-cap, budget overflow, or unreadable target; change scope or inputs first

If TemPad MCP appears unavailable, inactive, or pointed at the wrong file, stop and tell the user to:

• enable MCP access in TemPad Dev Preferences > Agent integration
• keep the correct TemPad Dev / Figma tab active
• use the MCP badge in the TemPad Dev panel to activate the correct file if multiple Figma tabs are open

If asking the user to narrow scope because of budget overflow, report the current consumption, limit, and overage from the error text.

4. Implement code in the established project style

Translate TemPad Dev output into the implementation's established patterns.

• Reuse existing primitives and abstractions when they fit without guessing.
• Keep the established framework and styling system. Do not introduce a second one.
• Follow established file placement and import conventions.
• If the implementation is utility-first, keep utilities and match existing conventions. Otherwise translate generated utilities into the established styling approach while preserving values.
• Preserve exact values. Do not coarsen arbitrary values such as py-[4px], text-[12px], or font-[600] into named utilities unless local project evidence proves the same rendered value; for rem output, use codegen.config.{cssUnit,rootFontSize,scale} to convert exactly. Apply this to spacing, sizing, inset, gap, radius, font-size, line-height, letter-spacing, and font-weight.
• Implement the base state only unless variants, interactions, or responsive behavior are evidenced.
• Preserve emitted pseudo-elements. If TemPad output includes before:, after:, content-*, or equivalent CSS, keep them or use an established equivalent with the same rendered result.
• Preserve other high-fidelity details from get_code, including pseudo- classes, filters, masks, blend or backdrop effects, and other non-default visual properties, unless implementation constraints require adaptation.
• New runtime or build dependencies require user confirmation unless explicitly waived.
• Extract new abstractions only when repetition plus established patterns justify it.
• If multiple plausible primitives, layout abstractions, or delivery strategies fit and evidence does not decide, ask the user instead of guessing.

Assets

Follow the established asset policy first.

• Download bytes only from TemPad-provided asset.url. Never substitute public internet assets.
• Treat assets as files to save or reference, not as text evidence to parse.
• If policy forbids storing assets, you may reference TemPad URLs, but you must warn that the output depends on the local TemPad asset server.
• If a vector is emitted as <svg data-src="..."> in code, treat that placeholder markup as the current design truth for structure, sizing, and instance color evidence. data-src points at the uploaded SVG asset. Only refactor delivery when the implementation already has another established SVG policy.
• If TemPad falls back to inline SVG because asset upload failed, treat that inline markup as the design truth for that vector instead of re-synthesizing the shape from the asset metadata.
• Do not introduce a new SVG pipeline if one is already established.
• Preserve vector semantics:
  • themeable: true means one context-driven color channel, typically via currentColor
  • drive that color from the established wrapper or component styling rather than inventing a new icon API
  • vectors without themeable: true keep their internal palette
• Use asset.themeable only after accounting for the project's existing SVG delivery policy.
• Do not invent multi-color SVG props or custom CSS variables unless the implementation already has an established icon API that requires them.

Tokens

Preserve design-token usage by default.

Token evidence may be either direct values or mode-specific values keyed by Collection:Mode. Preserve references between variables when present.

• Prefer existing tokens only when equivalence is justified by value, references, and semantics, not by name alone.
• If the implementation can safely carry design-token references for this change, preserve TemPad token references until they are mapped through the normal token workflow.
• Add new tokens only when there is already an established process for doing so and this change is expected to use it.
• If token landing, mode selection, or mapping remains ambiguous or unsupported, use explicit values and warn.
• Hints may be used only for reasoning about mode selection; never output hint attributes.

Semantics and accessibility

When not already using an appropriate primitive or component:

• use native elements where appropriate, such as button, a, input, and label
• preserve keyboard interaction and focusability
• add accessible names when needed, such as aria-label or alt

Assume the existing CSS reset or normalize strategy. Do not add new reset libraries or global CSS unless there is already a defined pattern for it.

5. Project checks and handoff

Project checks are project-defined, not skill-defined.

• Follow project instruction files such as AGENTS.md, local docs, and existing project scripts for any lint, format, typecheck, build, test, preview, screenshot, or design-comparison steps relevant to this change.
• Run the narrowest relevant checks that the project already defines and the current host or client can actually execute.
• If those checks fail, repair obvious implementation issues when feasible and re-run the relevant checks.
• Do not invent a default verification matrix just because this is a Figma-to-code task.
• If no established or runnable check path exists for this change, say the output is unverified.
• If shell recovery or subtree stitching was involved and no existing project check can confirm the resulting layout, explicitly call out the remaining visual risk.
• Do not claim visual or design-complete verification unless the project already has a normal preview, screenshot, or design-comparison workflow. Otherwise ask the user to visually validate the result against Figma.

Stop conditions

Stop instead of shipping code when:

• TemPad Dev MCP is unavailable, unauthorized, disconnected, inactive on the correct file, or otherwise cannot provide trustworthy design evidence
• the target cannot be read or is not visible
• project, design, and user evidence still conflict after narrowing
• a missing user decision would materially change the implementation and cannot be safely inferred
• required implementation constraints are missing and cannot be safely inferred from project or design evidence
• a trustworthy parent composition cannot be recovered after depth-cap, shell response, or budget overflow
• required assets cannot be retrieved or stored under the established policy
• new dependencies would be required and user confirmation has not been obtained

Output contract

When shipping code, end with:

• what was implemented and where
• evidence caveats, warnings, any stated inference, and whether shell recovery or subtree stitching was used
• asset handling, including whether assets were stored locally or still depend on TemPad URLs
• token handling, including mapped tokens, preserved references, or explicit fallback values
• dependency notes, including whether any were added and whether approval was obtained
• project-check status, including commands run if any, what passed or failed, and what remains unverified
• any residual visual risk and the visual confirmation the user should still perform

If blocked, provide at most 3 concrete next items needed from the user.

Examples

Example: over-budget parent with recoverable shell

• get_code returns a parent shell and a shell warning
• keep that shell as the composition source of truth
• fetch missing child subtrees with get_code
• insert them into the known parent structure
• do not rebuild sibling layout from guesswork
• if no trustworthy parent shell can be recovered, stop and ask for a narrower scope instead of reconstructing parent layout from guesses
• report any remaining visual risk if project checks cannot confirm the layout

Example: SVG marked themeable: true

• first check the established icon or SVG delivery policy
• if the implementation already uses contextual icon color, adapt the SVG to one color channel, usually currentColor
• do not invent multi-color props or a custom icon API
• if more than one delivery strategy is plausible and evidence does not decide, ask the user

Example: token mapping is ambiguous

• preserve TemPad token references if the implementation can safely carry them
• map to existing tokens only when value plus semantic equivalence is justified
• if mode selection or landing zone is still unclear, use explicit values and warn instead of inventing a mapping