---
title: From Figma to the design reference without redrawing
description: Import Figma frames as design steps with their text, type and variables, make them the design reference and check every implementation run against them.
seo_title: Import Figma frames as the design reference
seo_description: Figma frames become design steps with their text layers and variables as tokens, so every implementation run is checked against the approved design.
query: check implementation against Figma design
kind: use-case
order: 63
updated: 2026-10-03
demo: false
---
The design is in Figma, approved, and the implementation is on staging. Somebody has to put the two side by side and say where the padding drifted. Kaloko imports the frames, so the comparison runs on every pull request instead of once before launch.

## The problem

Figma shows what was meant, the browser shows what was built, and nothing connects the two. Handoff notes go stale, and checking the result against the frames is a job for a designer with two windows open.

## What changes with Kaloko

`kaloko design import figma` turns frames into design steps of the same scenario that development and QA use. Each step gets the frame image and, under it, the frame's text layers as real text with their typography and colours. The file's variables (or its styles) become `tokens.json`. Once the team accepts the version, it is the design reference, and implementation runs with the design pack are checked against it.

## How it works

1. **Get a token**: a Figma personal access token with read access to file content, in the `FIGMA_TOKEN` variable. No token? Export the frames from Figma as PNG (1× and 2×) or SVG into a folder and import the folder.
2. **Import**: `kaloko design import figma "https://www.figma.com/design/<key>/Shop" --scenario qa/flows/checkout.yml`. Frames match steps by name (`Payment / mobile`, `payment@desktop`); `--map frames.json` handles the rest, `--dry-run` shows the matches first.
3. **Publish a version**: walk and share as usual, or add `--publish`. Each version gets notes on what changed per step (text, viewports that look different, tokens); `kaloko share --notes-preview` shows them before you publish.
4. **Make it the reference**: after the team accepts the version, `kaloko reference --design --version 2` sets it.
5. **Check the build**: implementation runs with `packs: [design]` compare pixels, structure and tokens with the frames; `kaloko drift` lists expected token against actual value per element.

## Skills and prompts

```
Import the checkout frames from our Figma file into the Kaloko design scenario, show me which frame went to which step, and publish a version only after I confirm.
```

Expected outcome: a dry run with the matches, then the import, then a version with notes once you agree.

```
Implement the payment step from the approved design and fix what kaloko drift reports.
```

Expected outcome: the agent reads `kaloko spec payment`, builds with the tokens it names, walks with the design pack and leaves only the differences a person has to decide.

## What you get

- The Figma design as steps of the same flow the product is tested on, with the same step ids.
- Tokens from the file's variables, ready for the step spec and the drift report.
- A check of every implementation run against the approved frames.

## FAQ

### Does anything go back to Figma?

No. The import is one way: prototype links, components, auto layout and interactions stay in Figma.

### What if we import again after the design changes?

The import replaces what the last import wrote; steps written by hand stay unless you pass `--force`. Unchanged frames give the same files, so the next version shows them as unchanged.

### Which plan do we need?

Design scenarios are in every plan within its limits. Token sets, the design pack and drift checks come with Business; see [pricing](/pricing).
