How do I get Cursor and Claude Code to follow our design system?

Short answer

Put the design system where the tools can read it, and write it as rules with reasons. That means design values and components in code, an instructions file that tells the tool which files to read for which job, and each rule written with why it exists and what wrong looks like. Then test it: give a fresh agent a fixed task and see whether the output would ship without edits.

Why do Cursor and Claude Code ignore our design system?

Because they can’t see it.

The system lives in a Figma library, a few people’s heads and some old chat threads. A coding tool can’t open any of those. So it builds from the average of everything it has seen, and you get a clean, reasonable screen that belongs to no product in particular.

Ask for the same screen five times and you’ll get five different products. The tool is doing its job. It has nothing of yours to read.

What do the tools need to read?

What Where it lives What it tells the tool
Design values One file in the repo Colour, type and spacing as named values
Components The codebase What already exists, so it reuses before it invents
Rules Plain Markdown guide files How to use all of it, with reasons
Instructions file The root of the repo What to read for this job, what to check, when to stop and ask

Claude Code reads a CLAUDE.md file at the start of a session. Cursor reads project rules. Both are plain text you keep in the repository, next to the code.

How do you set it up?

1. Move the design values into code

Name them by purpose. “Surface”, “border”, “text muted”. A tool told to use the muted text colour will get it right. A tool handed a hex code will pick a similar one next time.

2. Write every rule in the same shape

The rule, why it exists, what wrong looks like, and an example. An instruction on its own gets followed loosely. Give an agent the reason and both examples and it can apply the rule to a screen nobody planned for. So can a new hire.

3. Add reading lists

Don’t make the tool read everything every time. Tell it which files matter for the job in front of it: these three for a settings page, these two for an empty state. Short, relevant context beats a long dump.

4. Say when to stop and ask

A tool that isn’t sure will guess. Tell it what to do when a component doesn’t exist or two rules conflict. Stopping is a valid outcome.

5. Test it like code

Give a fresh agent a fixed task and only the system. A pass means the output would ship without edits. Nearly right is a fail. Run the same tests whenever the system changes.

What does this look like in real work?

Ours is called Halaska OS. It has two layers.

Underneath is our foundation: 300+ rules from 20+ years of product design, covering usability, how AI features should behave, every state of every screen, interface writing and accessibility. On top is the company’s own layer: strategy, voice, art direction, product priorities and decisions. Where the two disagree, the company’s layer wins.

It’s plain files the team owns, read by Claude Code, Cursor and Lovable. We build it alongside the product design work, so it’s proven on real screens before we hand it over. More on agentic systems.

How does it stay right after we set it up?

Changes are approved and logged with the reason. Nobody, person or agent, quietly undoes a decision that was made for a good reason. The foundation moves forward in versions, and your layer stays untouched when it does.

How do you check your own setup?

  • Ask your tool for the same screen five times. How different are the five?
  • Open your instructions file. Does it mention design at all?
  • Pick one design rule. Is the reason written down anywhere a tool can read?
  • When the tool isn’t sure, does it stop and ask, or guess?

Who can set this up for us?

Look for someone who designs products and works in code, and who can show you the tests their system has to pass. A document of guidelines isn’t the same thing as a system a tool can build from.

Halaska is an embedded product design partner for funded AI, crypto and fintech teams. Everything we make lives in a design system your team and your AI tools can build from. See agentic systems or get in touch.

FAQ

Can Cursor follow a design system? Yes, if the system is in the repository as design values, components and written rules, and the project rules point to them.

What should go in CLAUDE.md for design? How to run the project, which design files to read for which kind of task, what to check before finishing and when to stop and ask.

Do we need new software for this? No. It’s plain files in your own repository, read by tools you already use such as Claude Code, Cursor and Lovable.

Do our brand guidelines still matter? Yes. Existing brand guidelines are the starting point. They get rewritten so a tool can follow them.

Who is Halaska? Halaska is an embedded product design partner for funded AI, crypto and fintech teams, based in Dubai. It’s founded and directed by Chris Halaska, who has 20+ years designing products, including six at Google.

Embedded product design partner for funded tech teams

hello@halaska.com

Based in Dubai, working worldwide