· 5 min read · Design systems, AI
Multibrand design systems with AI, part 3: AI and the code side

AI is good for the boring parts of a design system, like audits, boilerplate, docs and checks. It's bad at deciding what the system should be. Below is where I'd use it, a few ways to wire design and code together, and why I care more about where the truth lives than about which tool you use.
This is part 3. Part 1 covers whether it's worth it and which tool to pick. Part 2 covers structure and variables.
What AI is good at
Think of it as a fast junior: quick, willing, and in need of review. Actually, don't think of it like that. Think of it as AI. It can do stuff fast, but it doesn't really know what it's doing, because it's a dumb computer. It can:
- Audits. Point it at a codebase and ask for every hard-coded color and spacing value, grouped by how often they repeat. That's what we need for a design system.
- Migrations. Replace old values with token references across hundreds of files. Boring, mechanical. I tried that a year ago and it couldn't do it reliably. Mid-2026 it can.
- Boilerplate. Component code, stories, prop tables, usage docs, changelog entries.
- Checks. Contrast, missing labels, tokens that are defined but never used.
- PR review. "Does this change use tokens, or does it add a raw hex value?"
What it should not decide
- Names and structure. I wrote about this in understanding the structure first. Naming is a team argument about what the system is. AI will happily come up with a tidy scheme that's wrong, and it can wander off from your conventions between runs. Give it your rules and make it follow them. Don't ask it to invent them. The trick here is to learn from experience. Or don't, just rely on AI, you can fix it later if needed.
- Brand judgment. Whether a brand's blue still feels like that brand is not a pattern-matching problem. You are the designer, it doesn't know anything.
- Inventing tokens. Hallucinations, bla bla bla.
Connecting design to code
There are a few pieces you'll keep running into, whichever way you set it up.
Figma Code Connect links components in your repo to components in Figma. Dev Mode then shows your real code instead of generated guesses. You write small template files with the CLI, or connect through the Figma UI with GitHub. It's brilliant. AI works better too, because it gets direct access to exactly the right code.
The Figma MCP server lets an AI agent pull design context from Figma, like variables, components and layout. (MCP is an open standard that lets AI tools talk to other systems.)
Storybook is the catalogue on the code side. It shows every component in every state, and supports accessibility and visual testing. It has an MCP server too, so an agent can look up your real components. Storybook itself calls that one experimental.
A token pipeline is the last piece, if you want one. Tokens Studio syncs tokens from Figma to a Git repo, and has a setting for the DTCG format. Style Dictionary turns those files into CSS, iOS, Android and more. It has had first-class DTCG support since v4, but not for the newest 2025.10 version yet. And the DTCG spec is still a community group draft, not a standard. Multibrand fits in nicely here, with one set of semantic names, one token file per brand and one CSS output per brand.
Here's how that can look in three setups.
With Figma only
Code Connect, the Figma MCP server and Storybook.
- Designers edit tokens in Figma.
- Sync pushes them to a Git repository, ideally as a pull request.
- Storybook shows each component under each brand.
- A coding agent such as Claude Code reads the Figma and Storybook servers, builds or updates a component, and opens a PR.
- A human reviews the PR, with contrast and token checks running in CI.
With Tokens Studio
All four pieces: Code Connect, the Figma MCP server, the token pipeline and Storybook.
- Designers edit tokens in Figma or Tokens Studio.
- Sync pushes them to a Git repository, ideally as a pull request.
- CI runs Style Dictionary and builds one CSS file per brand.
- Storybook shows each component under each brand.
- A coding agent such as Claude Code reads the Figma and Storybook servers, builds or updates a component, and opens a PR.
- A human reviews the PR, with contrast and token checks running in CI.
With code
Design lives in code. You still have the Figma MCP server and Storybook.
- Designers edit in code.
- Storybook shows each component under each brand.
- A coding agent such as Claude Code reads the Figma and Storybook servers, builds or updates a component, and opens a PR.
- A human reviews the PR, with contrast and token checks running in CI.
Do you need Figma at all?
Honestly, not always. It depends on where the truth lives. If the tokens live in Git, the design tool is just a view of them. I think that's the safer setup, and it's why I'd treat the token file as the source of truth, not the Figma file.
So you can stay with Figma and use Code Connect and MCP. Or go code-first, with Storybook as the only catalogue. That works for small teams of developers, but it gets harder if designers need to explore without writing code.
Risks
- Design and code drift apart quietly. Mappings and CI checks help, but they won't stop it completely.
- Code Connect and Figma-specific variables tie you to one vendor. Plain DTCG-style JSON in Git keeps the exit open.
- Dev seats and plan tiers cost money, and it adds up.
- Keep Figma access tokens out of repos and prompts, and give them as little access as possible. MCP's own security guidance warns about local servers running with your privileges. Only install servers you trust.
End thoughts
Setting up a multibrand design system is a big project. Even if the plan is not extensive, you will need a few people who at least understand it and know where to look when something goes wrong, or when a client wants something that's not in the system.
But once it's set up and working, it makes everything easier and faster. That's it.
Sources
- Figma Code Connect docs - what it is, plans, frameworks, how mapping works
- Figma MCP server docs - remote vs desktop, plans, what it extracts
- Model Context Protocol: introduction - what MCP is
- MCP security best practices - local server and scope risks
- Design Tokens Community Group format (draft) - spec status and features
- Style Dictionary - token transformation tool and outputs
- Style Dictionary and DTCG - DTCG support level
- Tokens Studio docs - GitHub sync, DTCG setting, Style Dictionary page, paid features
- Storybook: why Storybook - stories, docs, accessibility testing
- Storybook MCP server docs - agent access, experimental status
- Design tokens: understand the structure first - why naming is a human decision
Comments