---
title: "Design System UnityUI · AI-ready — Maximilian Dahl"
description: "Product design case study by Maximilian Dahl: how zvoove's design system UnityUI became readable for every AI tool, from Figma Make through Claude Code, Cursor, Lovable and the Figma agent to Claude Design as everyone's prototyping tool, backed by Storybook and QA skills."
url: https://max.does.systems/en/work/unityui/
lang: en
---

Initiative case · Design system · AI prototyping · zvoove · staffing software · 2025 – 2026

# A design system every AI tool understands

AI tools at zvoove built fast, but around UnityUI: hard-coded colours, wrong components, invented props. Together with the frontend lead, I made the design system AI-ready, early and on our own initiative, across Figma Make, Claude, Cursor and more. When the VP of Engineering and the VP of Product made Claude Design everyone's prototyping tool, the system was ready: rebuilt in Claude Design's structure, checked against Storybook and QA skills.

Read the case · RJump to results

Role in the project · With the frontend lead · Senior product designer (principal scope): experiments, skills, rules and prototyping setup

Setting · Own initiative · Started in autumn 2025, without a brief

Responsibility · Skills, rules, package route · Guidelines for Figma Make, skills repository, QA skill; the frontend lead built the release pipeline

Status · Live · +2 · As of September 2026 · Live · UnityUI package internally and publicly on npm, through the frontend lead’s release pipeline · Decided · Claude Design as everyone’s prototyping tool, autumn 2026 · Open · Impact not measured; two-way sync between Figma and Storybook planned · and 2 more states

As of September 2026

**Live · +2**

As of September 2026

- Live
   UnityUI package internally and publicly on npm, through the frontend lead’s release pipeline

- Decided
   Claude Design as everyone’s prototyping tool, autumn 2026

- Open
   Impact not measured; two-way sync between Figma and Storybook planned

We didn’t wait for the right tool. We made the system readable for every tool and were ready when the decision came.

Design System UnityUI · AI-ready

## At a glance

- 63
   component skills from one file
   **63**component skills from one file · Plus one shared rules file

- 10
   review phases in the QA skill

- 16 screens
   a login flow in three layouts in one day
   **16 screens**a login flow in three layouts in one day · Built in Cursor

1. Problem
   The AI didn’t know the system
   Prototypes came together in hours, but with wrong components and invented props.

2. Intervention
   One source for every tool
   One file produces skills, rules and guidelines. A QA skill checks in ten phases.

3. Outcome
   In the end, one tool for everyone
   The VP of Engineering and the VP of Product chose Claude Design. The system was ready for it.

Role in the project**With the frontend lead**Senior product designer (principal scope): experiments, skills, rules and prototyping setup

Setting**Own initiative**Started in autumn 2025, without a brief

Responsibility**Skills, rules, package route**Guidelines for Figma Make, skills repository, QA skill; the frontend lead built the release pipeline

02 · The problem

## AI built fast, but around the system

Product managers and designers started prototyping ideas with AI tools. It took hours instead of weeks, but the result had little to do with UnityUI: made-up colour values, rebuilt components, props that don't exist, icons that crashed at runtime. Every prototype had to be rebuilt for the product.

The core was the same for everyone: results already made of UnityUI. Per role, it looked like this:

- **Product manager**Job story
   When · I need to validate fast,
   I want · very fast, life-like prototypes,
   so · the results stay as close to reality as possible and I can hand them to the teams or to design.

- **Engineer**Job story
   When · a small change comes up,
   I want · the AI to take it on and integrate UnityUI without errors,
   so · I no longer write every little thing by hand.

- **Designer**Job story
   When · I build for several teams as the only designer,
   I want · to build faster and hand over more easily,
   so · I have more time for quality and for users' voices.

- **Dark Factory**Job story
   When · agents implement a ticket on their own,
   I want · a harness that works,
   so · they use UnityUI perfectly.

Written from the roles' requirements, as of my last information.

Context

The decision

I set out to teach the AI the system instead of banning the AI. The tools weren't the problem; the problem was that they didn't know UnityUI. So I described the system in a way any tool can read. The cost: rules, examples and exceptions had to be written down precisely, more precisely than for people.

03 · Figma Make

## Figma Make was the first teacher, and the first student

I started in autumn 2025 with Figma Make. The first prototypes, a new shell and a handbook for the AI assistant, took hundreds of prompts. Without guidance, Make wrote its own CSS and its own classes. Every correction became a piece of the rulebook: which component for what, which spacing, which exceptions.

That turned into guidelines and skills for Make. The first sentence in the zAIn prototype was then no longer an idea but a condition: use the design system from the package.

04 · The package

## The system has to go where things get built

Make could only really use UnityUI once the package arrived there. I tried the route myself: got access keys from the VP of Engineering, brought the package into the Figma registry and documented the hurdles. Once it was clear it worked, I handed everything to the frontend lead. He turned it into the release pipeline that publishes the package internally and publicly on npm at the same time.

Context

The decision

I unblocked first, then handed over. I could have waited for approval. Instead I delivered the proof myself and handed ownership to where it belongs. That didn't build the pipeline faster, but it answered whether it was worth building.

05 · Tool path

## Every tool exposed a gap, until a decision was made

The path through the tools · autumn 2025 to autumn 2026

1. Autumn 2025
   Figma Make
   Prototypes in hours, plus the first guidelines and skills.
   Gap: doesn't know the code

2. Claude Code
   A skills repository for knowledge, QA, migration and the route from Figma to UnityUI.
   Gap: terminal only

3. Claude
   The same skill in the app, even without a code environment.
   Gap: rules maintained twice

4. Cursor
   A login flow with 16 screens in three layouts in one day.
   Gap: one rules file per tool

5. Lovable
   Prototypes by the innovation hub. We picked up their results, which helped make Code Connect feasible.
   Gap: no bridge to Figma

6. Figma agent
   Builds designs with the Figma library. A skill of mine adds the design part, prompt included, to every technical PM ticket; the agent builds the base, I refine it.
   Gap: many tools, no shared choice

7. Autumn 2026 · decision
   Claude Design
   Result: one tool for everyone
   The VP of Engineering and the VP of Product make Claude Design everyone's prototyping tool. We rebuild the system for it, in Claude Design's structure.
   - Storybook checks against it
   - QA skill in ten phases
   - Quality gates in the workflow
   - Skills in the zvoove skills library

Every switch solved one problem and exposed the next. A decision for everyone was only possible at the end because by then the system was already described for machines.

My part

The Figma Make experiments, the skills and rules, the first route into the Figma package and the prototyping setup are mine. The frontend lead and I owned the chain together; he built the release pipeline. The Lovable prototypes came from the innovation hub.

Learning

Every switch of tools cost us rules. What survived every switch was the single description of the system.

06 · One source

## One source, and in the end one tool for everyone

A single file in the repository describes the system for machines. One command generates component skills for Claude, Cursor and other agents from it, another a rules file that CLAUDE.md, Cursor, Windsurf and Copilot rules point to. Figma Make gets guidelines, the Claude app a skill. Most recently, the main target was Claude Design.

One source, every tool · Live on this site

max.does.systems · UnityUI · Live · explainer · explainer · Runs on the real system of this site: the same tokens, components and rules.[UnityUI on npm](https://www.npmjs.com/package/@zvoove/unity-ui)

Switch tools: the rules stay the same, only the format changes.

In autumn 2026 the VP of Engineering and the VP of Product decided that Claude Design would be everyone’s prototyping tool. We rebuilt the components for it; since then the system has followed Claude Design’s structure completely. Storybook still checks against it, agents query the real documentation through an MCP server instead of guessing props, and QA and quality checks run in the workflow.

Context

The decision

When the choice fell on Claude Design, we rebuilt the components in the tool’s own structure instead of adapting them. The cost: they were built a second time. Storybook and the QA skills stayed in place as the cross-check.

On the Figma side, components are linked through Code Connect. The Figma agent builds with the Figma library, and a skill of mine adds the design part with a matching prompt to every technical PM ticket. That way the design starts out with every skill it needs, and I refine it afterwards.

07 · QA skill

## A skill that says no

Rules alone aren't enough; you have to check them. The QA skill runs every piece of generated code through ten phases, from imports and forbidden HTML through hard-coded values, tokens and icons to dark mode and accessibility. Every phase comes from a real bug that AI code caused in production.

Without the skill, with the skill · Live on this site

max.does.systems · UnityUI · Live · explainer · explainer · Runs on the real system of this site: the same tokens, components and rules.

Toggle and see which checks typical AI code fails.

### Accessibility

The last of the ten phases checks accessibility. If it is missing, the QA skill rates it as P2.

Phase 10 · Accessibility · 9 checks

1 · Perceivable · 4

- Images with alt text · Or deliberately marked as decorative.WCAG 1.1.1 · A

- Headings in order · No level skipped.WCAG 1.3.1 · A

- Colour never alone · A state needs more than a colour.WCAG 1.4.1 · A

- Text contrast at least 4.5:1 · From the engineers' review skill.WCAG 1.4.3 · AA

2 · Operable · 2

- Everything reachable by keyboard · Every interactive element, without a mouse.WCAG 2.1.1 · A

- Visible focus · Keyboard users see where they are.WCAG 2.4.7 · AA

3 · Understandable · 1

- Form fields with a label · No field with a placeholder only.WCAG 3.3.2 · A

4 · Robust · 2

- Icon buttons have a name · Otherwise a screen reader only reads “button”.WCAG 4.1.2 · A

- Dialogs with a title · So it is clear what has opened.WCAG 4.1.2 · A

Checks from the QA skill and the review skill; the mapping to WCAG success criteria is mine.

08 · Live prototypes

## Prototypes that are already product

Most recently, prototypes came from two places. The team built new ideas in Claude Design, straight from UnityUI. Alongside, the screens in Storybook stayed: the shell, the AI assistant, the notification centre and the settings could be clicked through like the real application. Designers and engineers had their own profiles, so everyone only saw the tools they needed.

Context

What that changes

A prototype is no longer a throwaway. Whatever convinces customers in a conversation is already made of the right components and can move into the product. Flows stay in Figma, components go straight into the repository.

See also:[max.system, max.zeichen and max.lab](https://max.does.systems/en/work/max-system/)

09 · Patterns

## Components aren't enough; the Dark Factory needs patterns

The Dark Factory implements tickets with agents on its own. For it to use UnityUI correctly, components and tokens are not enough. It needs the patterns above them: interaction patterns, flow patterns and everything that defines how building blocks become flows.

Dark Factory with UnityUI

**01**Export timesheets as CSV · created with the PM ticket skill

1. ZVS-1482
   Export timesheets as CSV
   darkfactory · on

2. Pipeline

3. Quality gate · P0–P3
   - UnityUI components
   - Tokens
   - Grid
   - Accessibility

4. Code
   Pull request
   Export timesheets as CSV
   Checks passed
   consistent only with patterns

My part

The gate checks building blocks. Whether a flow stays consistent across screens is decided by the patterns that come in as material. Engineering owns the pipeline.

- UnityUI components and tokens · from the package

- UnityUI pattern library · interaction and flow patterns, being expanded

- Design refinement skill · extended for the Dark Factory

Level 5 of 5 · agents implement tickets on their own · In use since August 2026

Risk

No patterns, no consistency

Without the patterns, the Dark Factory takes whatever it needs at the moment and builds on its own hallucination. Every quality gate can still check that components, tokens and grid are right. Consistency does not come from that.

So I formed a small initiative group to grow the UnityUI pattern library: the designer from the innovation hub, my frontend lead and me. As of my latest information, the designers build one or two patterns a week.

From pattern to release · every week

1. Build patterns
   The designers build one or two patterns a week

2. Guide and take over
   The frontend lead guides them and takes them over into code

3. Check and release together
   At the end we check together, then the pattern goes into a release

What the library already set

1. 01
   Three cards
   A component and a pattern at once. Every ERP page sits on a fixed background card that stays put while scrolling. Lists, fields and tables live in content cards, for example in the employee, customer and item records; where no header with editing is needed, plain building blocks are enough. The three cards set the alignment of every page, also hold the human-in-the-loop steps and combine flexibly.

2. 02
   Modal size by process
   A small modal for flows such as items, absences and time tracking, a large one for complex ones such as wage types, condition tables and comparison employees.

3. 03
   List instead of table
   On small screens a list pattern replaces the table, the same on web, Android and iOS; the sort order decides what the supporting line shows.

From the zvoove Design System Figma library, as of September 2026.

### What a pattern pins down

A pattern doesn’t just describe how something looks, but when it applies and what is ruled out. A designer reads it in the docs; a Dark Factory agent reads the same parts and rules as a file. An example, rebuilt with synthetic data: plan before action, the pattern behind zAIn’s approvals.

Pattern: plan before action · Example · rebuilt

Sample

1. Add Tom Becker’s missing hours for week 44 and let the client know.A

2. Add missing hours · Approval required
   1. **Open the week 44 timesheet**Tom Becker · Warehouse North assignment
   2. **Enter 38.5 hours · writes**from time tracking
   3. **Notify the client · sends**Email to the contact person
   Then I’ll run all three steps in this order.
   Runs after approval · Decline · Approve

1. Action title · Says in a few words what will happen

2. Steps · Every step on its own; anything that writes or sends is marked

3. Lock · Nothing happens until someone decides

4. Decision · Reject and approve equally easy to reach; approve is primary

Rules

- Do:Reading needs no plan: the answer comes straight away.

- Do:Sensitive values get their own consent, not the approval of the whole plan.

- Do:After approval, the same card shows what is done.

- Don’t:A blanket approval that hides individual steps.

- Don’t:An approval for something that has already happened.

**How an agent reads it`patterns/plan-before-action.md`**

`--- pattern: plan-before-action applies-to: any agent action that writes data or sends something not-for: read-only questions: they get an answer straight away --- ## Anatomy 1. Action title [head] — Says in a few words what will happen 2. Steps [steps] — Every step on its own; anything that writes or sends is marked 3. Lock [lock] — Nothing happens until someone decides 4. Decision [acts] — Reject and approve equally easy to reach; approve is primary ## Rules - DO: Reading needs no plan: the answer comes straight away. - DO: Sensitive values get their own consent, not the approval of the whole plan. - DO: After approval, the same card shows what is done. - DON’T: A blanket approval that hides individual steps. - DON’T: An approval for something that has already happened.`

Synthetic data. The flow follows zAIn, live since August 2026.

Same question, different risks

1. 01
   Approval by risk
   Reading, drafting, writing and sensitive data each get their own rules instead of one approval for everything.

2. 02
   Consent for sensitive values
   Values stay masked until someone agrees. The log records who saw which value.

3. 03
   Handover to the assistant
   A case from the Notification Center arrives at zAIn as a prepared prompt.

The flows come from zAIn and UWX.

See also:[Dark Factory](https://max.does.systems/en/work/zvoove-skills/#factory)

Learning

Quality gates check building blocks. Consistency only comes from patterns.

10 · Outcome

## What came of it

1. Make the system readable
   Guidelines, skills and rules for Figma Make, Claude, Cursor and other tools
   Prototypes made of real UnityUI components

2. Ship the package
   The frontend lead’s release pipeline, internally and publicly on npm
   UnityUI where things get built

3. One source
   One file, producing 63 component skills and one shared rules file
   Stop maintaining rules per tool

4. Check instead of hope
   QA skill with ten phases built from real production bugs
   Catch errors in AI code

5. Available to everyone
   Skills for quality gates, QA and the system in the zvoove skills library; Claude Design as everyone’s tool, autumn 2026
   Everyone can prototype

6. Patterns for the Dark Factory · open
   Expansion of the UnityUI pattern library started
   Consistency when agents implement on their own

7. Measurability · open
   not measured
   Measure the effect

11 · Looking back

## What I learned and would do differently today

### Caveats

UnityUI existed before me: I evolved the Figma library and made the system AI-ready with the frontend lead; the VP of Engineering and the VP of Product chose Claude Design as everyone’s tool. How much time the route from prototype to product saves is not measured; what is documented are the skills, review phases and pipeline. As of September 2026.

### Learnings

1. Start early, on your own initiative
   We tried things out, tested them and brought the tools into the team long before anyone asked us to. Pragmatism drove us: everyone should be able to prototype, so the product organisation and the whole company could work faster and more simply.

2. No decision without the groundwork
   Because the system was already described for machines, we could make it available to everyone, bring the skills for quality gates, QA and the system into the zvoove skills library, and finally integrate it into Claude Design.

3. Try it first, then hand it over
   I proved the route into the Figma package myself and then handed it over. That saves debates about feasibility.

4. Rules from real bugs
   The best rules in the QA skill didn't come from a workshop but from crashes in production.

### What I would do differently today

1. Measure from day one
   We always wanted to measure. But as an initiative on top of daily business, we lacked the time to build it in or think it through; everything ran ad hoc in our initiative hours. Today I would plan the measurement from the first prototype on.

2. Plan the sync with Figma earlier
   Code Connect and the Figma agent came late. Syncing in both directions stayed manual until the end. I would plan for it from the start.

> We wanted everyone to be able to prototype easily, so we could work faster, simpler and better as an organisation.
> 
> Maximilian Dahl

fin (for now)

**Case notes · How to read this case.**

Team effort · UnityUI existed before me. The frontend lead and I built the AI-ready chain together; he implemented the release pipeline after I had tried out the route.

Presentation · The live pieces are my own explainers with made-up examples, no zvoove code.

Rights · zvoove and UnityUI are trademarks of the zvoove Group. This shows my work there; it is not official zvoove communication.

Last updated · As of September 2026; the decision for Claude Design as of my latest information
