To map design components to code components, pick a tool by where the map lives: on the design file, in an index of your repo, or nowhere. Code Connect, Zeplin and Storybook Connect annotate the design file. Builder.io, Kombai and Claude Design index the repo, and UXPin Merge, Builder Code, Onlook and Modeinspect render your real components.
The first two kinds are how a design file connects to a GitHub repository, and someone keeps that link current. The third has nothing to map. The comparison table lists eleven tools by where the map lives and the plan it needs, with Code Connect in both its forms. Five steps after it link a Figma library to GitHub today.
Key takeaways
- Component mapping tools differ by where the map lives: on the design file, in an index of the repo, or nowhere, because the canvas renders the code components.
- A published map is a second description of every component. It is wrong from the moment a prop or a file path changes until someone republishes it.
- The fastest start is Figma's Code Connect UI with a GitHub connection, which links a library component to a file path. Prop mapping takes the command-line version.
- A canvas on real components needs no map, but it does not carry a Figma library across. Teams whose design system lives in Figma libraries still need a published map.
Component mapping tools compared by where the map lives
Three mechanisms connect a design component to a code component. An annotation map on the design file says "this Figma Button is src/components/Button.tsx". An index reads your repo and matches components while it generates code. A canvas on your codebase renders the components themselves.
| Tool | How it maps | Where the map lives | GitHub connection | After a prop is renamed | Plan the mapping needs (November 2026) |
|---|---|---|---|---|---|
| Figma Code Connect, command line | Annotation | Template files in your repo, published to Figma | Files sit in the repo, published from CI | An engineer edits the file and republishes | Dev or Full seat on Professional and up, one library and one framework on Professional. Dev seat $12 a month billed annually |
| Figma Code Connect UI | Annotation | The Figma library file | Optional, autocompletes paths and names | The file path stays right, props are not stored | Same as above |
| Zeplin Connected Components | Annotation | Zeplin, sent by the Zeplin CLI | Links to Storybook and GitHub on each component | Run zeplin connect again | Every plan, free for one project |
| Storybook Connect | Annotation | A link from a Figma component to a story | Through Chromatic's builds of a branch | The link follows the branch's latest build | Chromatic free plan |
| Builder.io component indexing | Index | Builder's index of the repo | index-repo from the CLI or CI | Run index-repo again | Enterprise |
| Kombai | Index | Kombai's index of the repo, npm or Storybook | Works in your local checkout | No published map, it reads the repo | Free, Pro $20 a month |
| Claude Design | Index | A design system built by /design-sync | Run from Claude Code in the repo | Run /design-sync again | Design systems in beta on Pro, Max, Ultra, Team and Enterprise |
| Figma Make | Index | A Make kit's npm packages, or a cloned repo | Clones from GitHub, works in branches | Update the package in the kit | Make kits on Professional and up |
| UXPin Merge | Canvas | Nowhere, the canvas renders your components | Git integration | No map to update | Storybook on Growth, Git on Enterprise |
| Builder Code | Canvas | Nowhere, it works from your components | Pull requests | No map to update | Free, Pro $24 per user a month |
| Onlook | Canvas | Nowhere, it edits your code | Writes to your code | No map to update | Free download, team plans priced on request |
| Modeinspect | Canvas | Nowhere, React components found after setup | Pull requests on GitHub | No map to update | Free Hobby, Pro $20 a month per person |
Of the published maps, Code Connect is the one Figma's MCP server passes to a coding agent. An index and a canvas read the repo itself. Modeinspect is a canvas of that kind: it finds your React components after setup, so there is no map to keep current (see how it works).
What's the fastest way to map design components to code components?
The fastest way is Figma's Code Connect UI with a GitHub connection, because it runs inside Figma and needs no command line. It links each library component to a file path and a component name in your repo.
It needs a Figma library file with published components, and a Dev or Full seat on Professional, Organization or Enterprise (Figma developer docs). To connect a file to GitHub, you must be the file's owner, or an organization admin on Organization and Enterprise.
- Open the library file in Figma and switch to Dev Mode.
- From the dropdown next to the file name, choose Library, then Connect components to code. The list of published components opens.
- Click the Settings icon, choose Connect to GitHub, and authorize the GitHub account or organization that can see the repository.
- Pick the repository, or several with the + button. Figma says "Component mapping fields will autocomplete with file paths and component names from your repository" (Figma developer docs).
- For each component, pick its file, such as
src/components/Button.tsx, and its name. Start with the five components your screens use most.
"Connecting to GitHub is optional" (Figma Help Center). Without it, you type the path by hand. GitHub Enterprise Server is not supported.
Speed has a cost. "Components connected using Code Connect UI do not display code snippets in the Inspect panel" (Figma developer docs). They show the file and the component name. The mapping is shared with the Figma MCP server, so a coding agent learns which file to import, but not which prop a Figma variant becomes.
Props take the command-line version. An engineer writes one template file per component and publishes it with npx figma connect publish (Figma developer docs). Figma's own CI example publishes again "when any PR is merged to the main branch" (Figma developer docs).
A Code Connect template names your Button three times, and each name has to stay right.
// url=https://figma.com/design/a1b2c3/Library?node-id=12-40// source=src/components/Button.tsximport figma from 'figma'const instance = figma.selectedInstanceconst label = instance.getString('Label')const variant = instance.getEnum('Variant', {Primary: 'primary',Secondary: 'secondary',})export default {example: figma.code`<Button variant="${variant}">${label}</Button>`,imports: ['import { Button } from "@/ui"'],id: 'button',}
- The Figma component the map belongs to. Move the component to another library and the link breaks.
- The prop name, written into every snippet. Rename
variantin code and this line still writes the old name. - The import path. Move the file and the snippet points at a path that no longer exists.
Example. A template file for a Button, in the format Figma documents for Code Connect.
Maps on the design file: Code Connect and its alternatives
Four tools keep a map on the design file, and which one is a Figma Code Connect alternative depends on the reader. Zeplin and Storybook Connect show developers the real component next to the design, and Locofy swaps your components into the code it generates. Only Code Connect feeds the map to an agent through Figma's MCP server. Which agent reads what is the subject of design tools for AI coding agents.
Figma Code Connect
Code Connect is the map Figma's MCP server hands to a coding agent, because "Once mapped, this information is shared with the Figma MCP server" (Figma Help Center). It is "Available on a Dev or Full seat on the Professional, Organization, and Enterprise plans". And "Professional plans can have one active library and one active framework" (Figma developer docs). A team that ships React and SwiftUI needs Organization or Enterprise to map both.
Template files are now the format to write. Figma says "we are no longer updating or actively maintaining the legacy parsers" as of August 2026, and npx figma connect migrate converts older files (Figma developer docs). How an agent uses the map on a real frame is in the Figma MCP server guide.
Zeplin Connected Components
"Connected Components in Zeplin enable engineers to access components in their codebase right on the designs" (Zeplin). It covers React, Angular, Swift and Vue, with links to Storybook and GitHub on each component. Engineers run the Zeplin CLI with zeplin connect to send the components. Zeplin lists code-connected components on every plan, including the free one.
Locofy custom components
Locofy keeps a map too. On Enterprise it "replaces your Figma components with your actual custom component code and wires the correct props automatically" (Locofy docs).
Storybook Connect
"Storybook Connect is a Figma plugin that allows you to link stories to Figma components" (Chromatic docs). You paste a story's URL onto a selected component, and the live story opens inside Figma. Chromatic "automatically updates your linked stories to reflect the latest build on the designated branch", so the link survives a rebuild. It needs a Storybook published on Chromatic, which has a free plan.
Repo indexes: Builder.io, Kombai, Claude Design and Figma Make
An index skips the hand-made map. The tool reads your repo, finds the components and matches them while it generates code.
- Builder.io. "Builder.io is transitioning from manual component mapping to Component indexing" (Builder.io docs). "Running index-repo requires an Enterprise plan", and you run it again "whenever you add new components or change component architecture" (Builder.io docs).
- Anima Frontier. Anima's VS Code extension "matches Figma components with corresponding elements in your codebase" (Anima docs).
- Kombai. "Kombai consistently reuses components, tokens, and hooks from your repo, npm package, or Storybook" (Kombai). It runs in your editor, and committing stays with you.
- Claude Design. "If your design system already exists as React components, run /design-sync in Claude Code. It reads your tokens and components directly" (Anthropic Help Center).
- Figma Make. A Make kit bundles "npm packages for code context" (Figma Help Center). Make can also clone a repository from GitHub and work in branches (Figma Help Center).
An index is current as of its last run, and its matches are guesses. A wrong match shows up in the diff, so read the first diffs closely. How generated UI picks up a design system, rules files included, is in AI and design systems.
Your real components on the canvas: UXPin Merge, Builder Code, Onlook and Modeinspect
The third kind removes the map. The canvas renders the components from code, so the component you place is the one that ships.
UXPin Merge lets you "Import React or Web components from any Git repository" and design with them (UXPin). Builder Code says it will "Use your components, tokens, and usage patterns so new UI follows the system your team already ships with", and "Approved changes become pull requests" (Builder.io). Onlook "writes the underlying TypeScript directly back to your code" (Onlook). Each tool's fit for an existing React app is in the React visual editor checklist.
Modeinspect works on Next.js React codebases that use Tailwind. After setup it finds the team's React components, and you drag them onto the canvas, mention them in chat and edit their props. Changes leave as a pull request on GitHub. A pasted Figma frame is a starting point: component instances arrive as plain layers, not linked to the team's code components.
A canvas on code does not take a Figma library across. If your design work lives in Figma libraries and your engineers build from them with agents, a published map is still the tool for that file.
Why every component map goes stale
Maybe you own the design system, with two designers and twelve engineers. Code Connect covers your most-used components and the snippets look right in Dev Mode. Engineers still paste a prop that changed last sprint.
A map is a second description of your design system. Code Connect and Zeplin each hold one, and it is correct only as of its last publish. Storybook Connect's link follows the branch's latest build, but the stories are one more copy someone keeps. Rename variant to intent on the Button, and every snippet built from the old map shows a prop the component no longer takes.
Rename a prop in code, and the published map keeps the old name until someone republishes it.
type ButtonProps = { intent: 'primary' | 'secondary' }<Button variant="${variant}"><Button variant="primary">Save</Button>intent="primary"- The map still writes the old prop. It changes when someone edits the file and publishes it again.
- The snippet now passes a prop the Button no longer takes, and the review catches it, or nobody does.
Example. Switch between the states to see which copy follows the code.
The Thoughtworks Technology Radar put Code Connect in Trial, for "mapping Figma components directly to production UI components in code". It adds that "Maintaining mappings for every variant also requires ongoing effort" (Thoughtworks).
Drift does not need Figma to start. We hear the same thing on our calls with customers: the components in Storybook stop matching the ones in production.
A map also stops at props. "Code Connect files are not executed" (Figma developer docs), so a map can say Save takes disabled, but not when. In your code, the form's state sets it.
Every copy of a component is a place it can be wrong. A published map is one more copy, an index is a fresh guess each run, and a canvas on the code has no copy to keep. The production environment beats a better map.
How can designers see what components exist in our codebase while designing?
Designers see the codebase's components when a tool reads the repo, not the library: Storybook for the components that have stories, or a canvas on your codebase.
- Code Connect UI, while you map, lists the library's published components and, with GitHub connected, autocompletes file paths and component names from the repo.
- Storybook lists the components someone wrote stories for, which is a subset of the repo.
- A canvas on your codebase places components from the code, so there is nothing to look up.
The Figma library and the repo list different components. The repo's list is the one that ships.
- Library/
- Button
- Card
- Modalnamed Dialog in code
- Toast
- Avatarnot built
- components/ui/
- button.tsx
- card.tsx
- dialog.tsx
- toast.tsx
- badge.tsxnot drawn
- data-table.tsxnot drawn
- Same component, two names. A map has to link
Modaltodialog.tsxby hand. - Drawn in Figma, never built. There is nothing in the repo to map it to.
- Built in code, never drawn. A designer working from the library does not know they exist.
Example. A typical library and a typical components folder, before anyone maps them.
A Figma library and a repo grow apart in both directions. A component drawn in Figma may never be built, and an engineer adds a DataTable no designer has drawn. Before you map anything, list both sides and mark the gaps.
Which mapping fits your team
- Your design system lives in Figma libraries and engineers build with agents. Code Connect, starting in Code Connect UI with a GitHub connection, then template files for the components where props matter.
- Developers inspect designs in Zeplin. Zeplin Connected Components, with
zeplin connectrun again whenever components change. - Your components already have stories on Chromatic. Storybook Connect, so designers see the live component next to the frame.
- Engineers generate UI with a tool that reads the repo. An index: Builder.io on Enterprise, Kombai, or Claude Design's
/design-sync. - Designers change a React app that already ships. A canvas on your components, such as UXPin Merge, Builder Code, Onlook or Modeinspect. Design to code tools compared sets them beside converters and agents.
Mapping is one step in every route from a design to a pull request. Tokens drift the same way, covered in the design tokens guide. Servers that hand a design system to an agent, such as Storybook's and shadcn's, are in Storybook MCP, shadcn MCP and Figma MCP.
This week, list the ten components your screens use most, once from the Figma library and once from components/ in the repo. Mark each name that differs and each component missing on one side. If most rows match, map them in Code Connect UI. If most differ, design on the components in the repo instead.
Frequently asked questions
Any recommendations for a tool that can map design components to code components?
Figma Code Connect, if your design system lives in Figma libraries. It links each component to its file and props, and coding agents read the map through Figma's MCP server. Zeplin Connected Components and Storybook Connect show developers the real component beside the design. Builder.io, Kombai and Claude Design index your repo instead, and canvases such as UXPin Merge, Builder Code and Onlook use the components directly.
Is there software that can map design components to code components?
Yes, in three kinds. Annotation maps such as Figma Code Connect, Zeplin Connected Components and Storybook Connect link a design component to its code. Repo indexes such as Builder.io's component indexing and Kombai find matches while generating code. Canvas tools such as UXPin Merge and Builder Code render the code components, so nothing needs mapping.
Which platform is best if I want to map design components to code components?
The one that matches where your components are designed. If designers work in Figma libraries, Figma Code Connect is the map Figma's MCP server passes to coding agents, from Professional with a Dev or Full seat. If developers inspect in Zeplin, its Connected Components are on every plan. If designers change a React app that already ships, a canvas on your components needs no map. The fastest start in Figma is Code Connect UI with a GitHub connection, which needs no command line.
Is there a Figma Code Connect alternative?
Yes. Zeplin Connected Components link Zeplin components to React, Angular, Swift and Vue code, on every Zeplin plan. Storybook Connect links Figma components to stories published on Chromatic. Builder.io's component indexing replaces manual mapping on its Enterprise plan. Only Code Connect passes the map to coding agents through Figma's MCP server.
How do I connect a Figma design file to a GitHub repository?
Use Code Connect UI. In the library file's Dev Mode, choose Library, then Connect components to code, open Settings and choose Connect to GitHub. You must own the file, or be an organization admin on Organization and Enterprise. It needs a Dev or Full seat on Professional and up. Figma Make can also clone a GitHub repository, but that connects a Make file, not your design library.
What design-to-code tools integrate with React and GitHub workflows?
Code Connect, Builder.io component indexing and canvas tools such as Builder Code, Onlook and Modeinspect work with React and GitHub, each in a different place. Code Connect template files live in your React repo and publish from GitHub Actions on merge. Code Connect UI reads a connected GitHub repo to autocomplete paths, and Builder.io runs index-repo in CI. Builder Code and Modeinspect open pull requests on your GitHub repo, and Onlook writes back to your code. Converters and agents are compared in design to code tools compared.
Which tool keeps a design system synced with React code?
A canvas that renders your React components stays in step, because there is no second copy to sync. Code Connect and Zeplin stay current only when someone republishes the map after a change, and Code Connect can do that from CI on each merge. Storybook Connect follows the latest Chromatic build of a branch.
Does Code Connect work on the Figma Professional plan?
Yes, with a Dev or Full seat. Professional allows one active library and one active framework, so a team with React and SwiftUI components maps only one of them. Organization and Enterprise allow several. The Dev seat is $12 a month billed annually on Professional (Figma pricing).
