Published: Reading time: 12 min read

Which AI app builders actually use your design system? (2026)

Summarize with AI

Table of contents
  1. How we compared
  2. The seven tools at a glance
  3. Tokens and drift, in the docs’ own words
  4. Lovable: the only one that checks every generation
  5. v0: your package as a skill, your CI as the check
  6. Bolt: a generated Storybook, no automatic check
  7. Cursor: your repo, your rules, your hooks
  8. Claude Code: the same, with a documented lint loop
  9. Figma Make: a Make kit, with tokens flattened
  10. Replit: its own design system, not yours
  11. How to make any of them stick
  12. Which one should you use
  13. When the drift is already in the code
  14. FAQs

Lovable is the only AI app builder that checks every generation against your design system and retries when it breaks the rules. v0, Bolt, Figma Make and Replit can import your system, but they only steer the model with instructions, so drift is caught by you, not the tool. Cursor and Claude Code build from your own repo, so they use your real components and tokens, and with hooks and lint rules you can make drift fail a check before it ships.

We read each tool’s own docs, help centre, changelog and pricing page on 12 November 2026. Where a doc says nothing, we say “not documented” rather than guess. Full disclosure: DesignMe designs design systems and fixes AI-built products, and we build our own site with Claude Code. We don’t sell or resell any of these tools.

How we compared

We asked the same four questions of every tool:

  1. Import. Can it take your design tokens (from Figma variables or a tokens file) and your existing component library?
  2. Sticking. Does generated UI keep to the system, and what do the docs admit about drift?
  3. Rules. Where do you write the rules, and does it read files you already have, such as AGENTS.md or CLAUDE.md?
  4. Enforcement. Is anything automatic, such as a scan, a lint step or a CI check, or is it up to you?

If you’re new to the parts of an agent-ready system, start with design systems AI agents can build with. This article is about which tools actually use one.

The seven tools at a glance

Tool Your components Figma Rules Automatic check
Lovable npm package or public Git repo, copied in (React only) Plugin, desktop MCP, .fig upload Instructions, AGENTS.md, CLAUDE.md Yes, scans and retries
v0 npm package, .tgz or GitHub repo, saved as a skill Link on paid plans Instructions, skills No, but runs your CI on GitHub
Bolt npm, public GitHub or Storybook (Teams plan) One frame, via Anima Knowledge, agents.md No, an audit prompt
Cursor Already in your repo Figma MCP server .cursor/rules, AGENTS.md Hooks can run your linter
Claude Code Already in your repo Figma MCP server CLAUDE.md, .claude/rules, AGENTS.md Hooks can run your linter and block
Figma Make npm package in a Make kit Library variables and styles guidelines folder Not documented
Replit Its own Replit Design system One frame replit.md, custom instructions Not documented

Tokens and drift, in the docs’ own words

Tool Where your tokens come from What the docs say about drift
Lovable CSS variables, tailwind.config or a theme file in the source The scanner catches most violations; point out misses in chat
v0 globals.css and Tailwind config; loose files become a package v0 should not use anything it can’t verify from your sources
Bolt Your files, site, repo or package; no tokens import A help section on why output doesn’t match your system
Cursor Your repo; a rule points at the tokens file No page on drift
Claude Code Your repo; CLAUDE.md points at the tokens file CLAUDE.md is context, not enforced configuration
Figma Make A subset of library variables, as raw CSS values Kits don’t fully extract design tokens
Replit tokens.json feeding CSS variables If old styling reappears, flag it in chat

Lovable: the only one that checks every generation

Lovable docs, Design systems: create reusable design systems to standardize React component libraries, styling guidelines and setup, available on all paid plans
Screenshot: docs.lovable.dev/features/design-systems, captured 12 November 2026

What it imports. A Lovable design system is its own project, built from an npm package, a public Git repo or files you upload. There’s no fetch from a private repo, so you export the files yourself. It’s React only. When you connect it, the components are copied into your project under src/design-system/, with rule files and a machine-readable design-system.json next to them. Figma comes in three ways: a plugin, a live MCP connection in the desktop app, and a .fig upload that pulls variables, colours, typography and frames but not components.

Does it stick? This is the one tool with a documented check. Every generation in a connected project is scanned for raw colour values where a token belongs, one-off values, inline style overrides and local versions of components the system already has. If it finds any, Lovable retries before it finishes. The docs are honest that it catches most violations, not all.

Rules. Instructions (renamed from Knowledge in October 2026) at workspace, project and personal level, up to 10,000 characters each. Lovable also reads AGENTS.md and CLAUDE.md at the top of the project with every message.

Tradeoffs. One design system per project, and edits to the copied files are overwritten on the next update. Wrapping an npm package without copying it is Enterprise only. Git sync always creates a new repo, so an existing codebase comes in as a ZIP upload. Design systems are on all paid plans, with Pro from $25 a month.

Verdict: the best built-in protection against drift, if your system is React and you’re happy for Lovable to own a copy of it.

v0: your package as a skill, your CI as the check

v0 docs, Design Systems 2.0: teach v0 your design system once, so chats can build with your real components, tokens and conventions
Screenshot: v0.app/docs/design-systems-2, captured 12 November 2026

What it imports. Design Systems 2.0 takes an npm package or .tgz, GitHub repos (including a real app that uses the system), Storybook or docs links, and Figma frames as visual reference. v0 builds a starter app from it and waits for your approval before saving it as a skill, which every new app then starts from. A Figma link on its own (paid plans) gives v0 the file’s variables, styles and component names.

Does it stick? The docs say v0 grounds itself in your sources and should not use a component, prop or token it can’t verify there. That’s a promise about behaviour, not a scan. Its older registry docs also warn that v0 is trained on default shadcn/ui components and may struggle with customised ones. Existing projects don’t pick up a new version of the system automatically.

Rules. Instructions are saved to your account (a title and a rule) and applied when you tick them. v0’s docs don’t say it reads AGENTS.md or CLAUDE.md.

Enforcement. This is where v0 is strong. It imports any GitHub repo you can access, works on a branch per chat, publishes through a pull request and follows your branch protection and required checks. It shows CI status and offers Fix CI, so a lint rule in your pipeline becomes the check.

Tradeoffs. Legacy themes are retired on 30 November 2026, so older setups need migrating. Plus is $30 per user a month.

Verdict: a good fit for a shadcn/ui or Next.js based system, as long as your CI is the thing that says no.

Bolt: a generated Storybook, no automatic check

Bolt Help Center, design system overview: build on-brand projects with a design system in Bolt, compiled from your own sources
Screenshot: support.bolt.new/design-system, captured 12 November 2026

What it imports. On paid Teams plans ($30 per member a month), Bolt builds a Storybook of your system from npm (including private registries), a public GitHub repo, a Storybook, a website or files. It takes 45 to 60 minutes, and each team can add or sync 10 systems a week. The docs warn that a docs website alone gives you a theme, not reusable components. Chakra, Material UI and Shadcn come pre-loaded for everyone.

Does it stick? Bolt says it uses your system as a reference for every UI decision. There’s no automatic scan. Instead it gives you an “audit the project” prompt that hunts for hard-coded colours, spacing and font sizes. Its best-practices page has a whole section on why output doesn’t match your system: incomplete sources, broad prompts, an outdated sync, or not using its Max agent.

Rules. Knowledge at project, account and team level, per-package instructions for teams, and an agents.md file that Bolt finds automatically.

Tradeoffs. Figma import is one frame at a time through Anima, and with a design system attached you have to choose Screenshot mode, because Code mode ignores your system. GitHub sync is two-way but tied to the main branch.

Verdict: usable when you have a published package and a Teams plan. Plan on running the audit prompt yourself.

Cursor: your repo, your rules, your hooks

Cursor docs, Rules: project rules, user rules, team rules and AGENTS.md, the four types of rules Cursor supports
Screenshot: cursor.com/docs/rules, captured 12 November 2026

What it imports. Nothing, because Cursor works in your repo. Your tokens file and components are already there. Figma comes in through Figma’s MCP server, which lists Cursor as a supported client.

Does it stick? Cursor’s docs don’t discuss drift. Its advice is to write a rule that points the agent at your components, and to keep rules under 500 lines. Design Mode lets you annotate your running app, and the agent gets each element’s computed styles and component name. Nothing in it is token-aware.

Rules. Project rules in .cursor/rules (they must be .mdc files), user rules, team rules on Team and Enterprise, and AGENTS.md in the root and subfolders. The old .cursorrules file is legacy and will be deprecated.

Enforcement. Hooks in .cursor/hooks.json can run after a tool call and add context to the conversation, or send a follow-up message when the agent stops. That’s enough to run your linter and hand the errors back, though the docs don’t show a lint example. Bugbot reviews pull requests against its own rules file.

Verdict: it uses your real system with no import step. How strict it is depends on the rules and hooks you write.

Claude Code: the same, with a documented lint loop

Claude Code docs, How Claude remembers your project: CLAUDE.md or AGENTS.md files, auto memory and path-scoped rules in .claude/rules
Screenshot: code.claude.com/docs/en/memory, captured 12 November 2026

What it imports. Like Cursor, nothing: it reads your repo, your tokens and how your existing components are built. Figma comes in through the same MCP server.

Does it stick? Anthropic says Claude converges on generic output unless it’s steered, and its frontend-design skill is about avoiding a generic look in new designs, not following yours. The steering comes from your files. Anthropic’s docs are clear that CLAUDE.md is context, not enforced configuration, and they suggest keeping each file under 200 lines.

Rules. CLAUDE.md at managed, user, project and local level, path-scoped rules in .claude/rules that load only for matching files, and skills. Claude Code reads AGENTS.md when there’s no CLAUDE.md, or you can import it from one.

Enforcement. Hooks are documented for exactly this. A hook after each edit that exits with an error shows its output to Claude, so a stylelint or ESLint rule that bans raw hex values gets fixed in the same turn. A Stop hook can refuse to let Claude finish until checks pass. The docs’ own advice: if something has to happen every time, make it a hook.

Tradeoffs. It’s a terminal and IDE tool, so someone on the team has to run it. It’s on Pro ($20 a month, $17 billed annually) and above.

Verdict: the tightest loop we found between your rules and a failing check. We use it for our own site, so weigh that.

Figma Make: a Make kit, with tokens flattened

Figma Learn, Get started with Make kits: npm packages, variables and styles from published libraries, and guidelines, on Professional, Organization and Enterprise plans
Screenshot: help.figma.com/hc/articles/39241689698839, captured 12 November 2026

What it imports. Make kits bundle an npm package, variables and styles from a published Figma library, and guideline files. They need a Professional plan or above (a Full seat is $16 a month on Professional). Library components aren’t documented as becoming code components; components come from your npm package, which has to build with Vite.

Does it stick? Figma’s docs say kits don’t fully extract design tokens. Make pulls a subset of your variables into a global CSS file with raw values, so your token names don’t survive. Its example guidelines warn against hard-coded spacing, which tells you what happens without them.

Rules. Guidelines.md in a guidelines folder, which Make reads first. No size limit, just advice to keep files short.

Tradeoffs. GitHub push is one-way and only to repos Make creates. Working in an existing codebase is a closed beta. No lint or check is documented.

Verdict: fine for prototypes from your Figma library. Expect to rebuild the styling layer before production.

Replit: its own design system, not yours

Replit docs, Create a design system: build one from a prompt or extract it from a mockup, then save it to your workspace
Screenshot: docs.replit.com/design/create-a-design-system, captured 12 November 2026

What it imports. Replit Design (live since 31 July 2026) creates a design system of its own: a tokens.json that feeds CSS variables, two or three example components and a DESIGN.md. You can seed it from a Figma URL, a website, code, images or an existing DESIGN.md. Importing your npm or Storybook component library isn’t documented, and a Figma import brings in one frame.

Does it stick? Applying a system to an existing app rebuilds its styling layer, and the docs say to flag it in chat if old styling comes back.

Rules. replit.md in the project root, plus workspace custom instructions on Pro and Enterprise.

Enforcement. App Testing clicks through your app in a real browser, but it checks behaviour, not the design system.

Verdict: good for a new product with no system yet. Not the tool for one you already have.

How to make any of them stick

The tools differ, but drift stops the same way everywhere:

  1. Tokens in code, with names. CSS variables or a theme file the agent can read, not values in someone’s Figma.
  2. One component per job. If the repo has five card styles, the agent picks one at random or writes a sixth.
  3. Rules in the file the tool reads. CLAUDE.md, AGENTS.md, .cursor/rules, Instructions or Knowledge. Short, specific, and about what never to create.
  4. A check that fails. A lint rule against raw colours and font sizes, run by a hook, in CI, or by Lovable’s scanner. Rules alone are guidance.
  5. A person before it ships. A preview, both themes and a phone width.

The full checklist is in our guide to design systems AI agents can build with.

For steps 4 and 5 in more depth, our free guide to a design system Claude can build with covers the lint rule against raw values and the review loop we run on every change.

Which one should you use

If you need Use Why
A tool that catches drift for you Lovable The only built-in scan and retry
Your package, checked by your own CI v0 Branch and pull request flow, Fix CI
Your exact repo, with hooks you control Claude Code or Cursor No import, and lint can block the agent
A prototype from your Figma library Figma Make Make kits read library variables
A system for a product that has none Replit Replit Design builds one for you

When the drift is already in the code

If an AI-built product already has three button styles and spacing that changes page to page, a new tool won’t fix it. “Styles that drift” is one of the six signs in our AI MVP cleanup: one set of components replaces the generated styles, and the rules and checks go in so it stays that way. If you need the system designed first, that’s product design, in Figma and in code.

DesignMe designs product UI and design systems for funded SaaS and AI companies, in Figma and in code, so your team and your agents ship on-brand. If your AI-built product keeps drifting, send us a link and we’ll reply within one business day:

designme.agency/intro

Sources

  1. Lovable, Design systems (accessed 12 November 2026) (opens in a new tab)docs.lovable.dev
  2. Lovable, Instructions, formerly Knowledge (accessed 12 November 2026) (opens in a new tab)docs.lovable.dev
  3. Lovable, Figma integration (accessed 12 November 2026) (opens in a new tab)docs.lovable.dev
  4. Lovable, GitHub integration (accessed 12 November 2026) (opens in a new tab)docs.lovable.dev
  5. Lovable, Plans (accessed 12 November 2026) (opens in a new tab)docs.lovable.dev
  6. Lovable, Changelog (accessed 12 November 2026) (opens in a new tab)docs.lovable.dev
  7. v0, Design Systems 2.0 (accessed 12 November 2026) (opens in a new tab)v0.app
  8. v0, Design systems (legacy registry) (accessed 12 November 2026) (opens in a new tab)v0.app
  9. v0, Migrate legacy themes (accessed 12 November 2026) (opens in a new tab)v0.app
  10. v0, Figma (accessed 12 November 2026) (opens in a new tab)v0.app
  11. v0, Instructions (accessed 12 November 2026) (opens in a new tab)v0.app
  12. v0, GitHub (accessed 12 November 2026) (opens in a new tab)v0.app
  13. v0, Git import (accessed 12 November 2026) (opens in a new tab)v0.app
  14. v0, Pricing (accessed 12 November 2026) (opens in a new tab)v0.app
  15. Bolt, Design systems (accessed 12 November 2026) (opens in a new tab)support.bolt.new
  16. Bolt, Add a design system (accessed 12 November 2026) (opens in a new tab)support.bolt.new
  17. Bolt, Use a design system (accessed 12 November 2026) (opens in a new tab)support.bolt.new
  18. Bolt, Design system best practices (accessed 12 November 2026) (opens in a new tab)support.bolt.new
  19. Bolt, Figma (accessed 12 November 2026) (opens in a new tab)support.bolt.new
  20. Bolt, Git (accessed 12 November 2026) (opens in a new tab)support.bolt.new
  21. Bolt, Manage context (accessed 12 November 2026) (opens in a new tab)support.bolt.new
  22. Bolt, Pricing (accessed 12 November 2026) (opens in a new tab)bolt.new
  23. Cursor, Rules (accessed 12 November 2026) (opens in a new tab)cursor.com
  24. Cursor, Rules help, .cursorrules is legacy (accessed 12 November 2026) (opens in a new tab)cursor.com
  25. Cursor, Hooks (accessed 12 November 2026) (opens in a new tab)cursor.com
  26. Cursor, Design Mode (accessed 12 November 2026) (opens in a new tab)cursor.com
  27. Cursor, Web development cookbook (accessed 12 November 2026) (opens in a new tab)cursor.com
  28. Cursor, Bugbot (accessed 12 November 2026) (opens in a new tab)cursor.com
  29. Anthropic, Claude Code memory, CLAUDE.md and AGENTS.md (accessed 12 November 2026) (opens in a new tab)code.claude.com
  30. Anthropic, Claude Code hooks guide (accessed 12 November 2026) (opens in a new tab)code.claude.com
  31. Anthropic, Claude Code hooks reference (accessed 12 November 2026) (opens in a new tab)code.claude.com
  32. Anthropic, Claude Code best practices (accessed 12 November 2026) (opens in a new tab)code.claude.com
  33. Anthropic, "Improving frontend design through Skills" (12 November 2025) (opens in a new tab)claude.com
  34. Anthropic, Pricing (accessed 12 November 2026) (opens in a new tab)claude.com
  35. Figma, MCP server (accessed 12 November 2026) (opens in a new tab)developers.figma.com
  36. Figma, MCP tools and prompts (accessed 12 November 2026) (opens in a new tab)developers.figma.com
  37. Figma, Code Connect (accessed 12 November 2026) (opens in a new tab)developers.figma.com
  38. Figma, Get started with Make kits (accessed 12 November 2026) (opens in a new tab)help.figma.com
  39. Figma, Bring your design system package to a Make kit (accessed 12 November 2026) (opens in a new tab)help.figma.com
  40. Figma, Write design system guidelines for Make kits (accessed 12 November 2026) (opens in a new tab)help.figma.com
  41. Figma, Push from Figma Make to GitHub (accessed 12 November 2026) (opens in a new tab)help.figma.com
  42. Figma, Pricing (accessed 12 November 2026) (opens in a new tab)figma.com
  43. Replit, What is Replit Design (accessed 12 November 2026) (opens in a new tab)docs.replit.com
  44. Replit, Create a design system (accessed 12 November 2026) (opens in a new tab)docs.replit.com
  45. Replit, Apply a design system (accessed 12 November 2026) (opens in a new tab)docs.replit.com
  46. Replit, Import Figma designs (accessed 12 November 2026) (opens in a new tab)docs.replit.com
  47. Replit, replit.md (accessed 12 November 2026) (opens in a new tab)docs.replit.com
  48. Replit, Custom instructions (accessed 12 November 2026) (opens in a new tab)docs.replit.com
  49. Replit, App Testing (accessed 12 November 2026) (opens in a new tab)docs.replit.com
  50. Replit, Pricing (accessed 12 November 2026) (opens in a new tab)replit.com

Press Escape to close.

Need more info?

Questions about AI app builders and design systems

Adrian

Can't find your answer?

Book a call and let's talk.

Or email us  hello@designme.agency

Which AI app builders preserve brand styles and design tokens when generating interfaces?

On 12 November 2026, Lovable was the only builder whose docs describe an automatic check: every generation in a project with a connected design system is scanned for raw colours, one-off values, inline overrides and home-made copies of library components, and Lovable retries to fix them. v0, Bolt, Figma Make and Replit import a design system but rely on instructions, so output can still drift. Cursor and Claude Code use the tokens and components already in your repo, and you can enforce them with lint rules run by hooks.

How do I enforce a design system's font tokens in AI-generated components?

Write the rule down and then make breaking it fail a check. Put the font tokens in code (CSS variables or a theme file), tell the agent in its rules file (CLAUDE.md, AGENTS.md, .cursor/rules or the builder's instructions) to use only those tokens, and add a lint rule that rejects raw font families and pixel font sizes. In Claude Code or Cursor, a hook can run that linter after every edit and send the errors back to the agent. In Lovable, a connected design system scans for one-off values automatically.

Which AI app builders can turn a Figma design system into production-ready UI code?

None of the seven tools we compared documents turning Figma library components into code components. v0 reads a Figma file's variables, styles and component names. Lovable's .fig upload brings in variables, colours and typography but not components. Figma Make kits pull a subset of library variables into raw CSS values, with components coming from an npm package. The most reliable route is a component library in code linked to Figma with Code Connect, read through Figma's MCP server in Cursor or Claude Code.

Which AI app builders read AGENTS.md or CLAUDE.md?

Lovable reads AGENTS.md and CLAUDE.md at the top of a project with every message, and subfolder files when it edits that folder. Bolt reads an agents.md file automatically. Cursor supports AGENTS.md in the root and subfolders. Claude Code reads CLAUDE.md, and reads AGENTS.md when there is no CLAUDE.md or when a CLAUDE.md imports it. Replit uses its own replit.md, Figma Make uses a guidelines folder, and v0's docs don't say it reads either file.

Why does AI-generated UI drift from the design system?

Each screen is generated on its own, and without a system the model falls back on the patterns it has seen most, such as default shadcn/ui components. Rules files help, but they are guidance: Anthropic's docs call CLAUDE.md context, not enforced configuration. Drift stops when the tokens and components are in code the agent can read, and a check rejects raw values before anything ships.

You've reached the end, so now…

Tell us what you’re building.

We’ll help you map the right scope, team, timeline, and next steps.

Book a call