Initiative case · Design system · AI prototypingzvoove · 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.
- Role in the project
- With the frontend leadSenior product designer (principal scope): experiments, skills, rules and prototyping setup
- Setting
- Own initiativeStarted in autumn 2025, without a brief
- Responsibility
- Skills, rules, package routeGuidelines for Figma Make, skills repository, QA skill; the frontend lead built the release pipeline
- Status
- and 2 more states
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
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
63component skills from one filePlus one shared rules file10
review phases in the QA skill
16 screens
a login flow in three layouts in one day
16 screensa login flow in three layouts in one dayBuilt in Cursor
Problem
The AI didn’t know the system
Prototypes came together in hours, but with wrong components and invented props.
Intervention
One source for every tool
One file produces skills, rules and guidelines. A QA skill checks in ten phases.
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 leadSenior product designer (principal scope): experiments, skills, rules and prototyping setup
- Setting
- Own initiativeStarted in autumn 2025, without a brief
- Responsibility
- Skills, rules, package routeGuidelines for Figma Make, skills repository, QA skill; the frontend lead built the release pipeline
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 managerJob 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.
EngineerJob 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.
DesignerJob 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 FactoryJob story
- When
- agents implement a ticket on their own,
- I want
- a harness that works,
- so
- they use UnityUI perfectly.
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.
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.
Every tool exposed a gap, until a decision was made
Autumn 2025
Figma Make
Prototypes in hours, plus the first guidelines and skills.
Gap: doesn't know the codeClaude Code
A skills repository for knowledge, QA, migration and the route from Figma to UnityUI.
Gap: terminal onlyClaude
The same skill in the app, even without a code environment.
Gap: rules maintained twiceCursor
A login flow with 16 screens in three layouts in one day.
Gap: one rules file per toolLovable
Prototypes by the innovation hub. We picked up their results, which helped make Code Connect feasible.
Gap: no bridge to FigmaFigma 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 choiceAutumn 2026 · decision
Claude Design
Result: one tool for everyoneThe 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.
Learning
Every switch of tools cost us rules. What survived every switch was the single description of the system.
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
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.
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.
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
Accessibility
The last of the ten phases checks accessibility. If it is missing, the QA skill rates it as P2.
1Perceivable4
- Images with alt textOr deliberately marked as decorative.WCAG 1.1.1A
- Headings in orderNo level skipped.WCAG 1.3.1A
- Colour never aloneA state needs more than a colour.WCAG 1.4.1A
- Text contrast at least 4.5:1From the engineers' review skill.WCAG 1.4.3AA
2Operable2
- Everything reachable by keyboardEvery interactive element, without a mouse.WCAG 2.1.1A
- Visible focusKeyboard users see where they are.WCAG 2.4.7AA
3Understandable1
- Form fields with a labelNo field with a placeholder only.WCAG 3.3.2A
4Robust2
- Icon buttons have a nameOtherwise a screen reader only reads “button”.WCAG 4.1.2A
- Dialogs with a titleSo it is clear what has opened.WCAG 4.1.2A
Checks from the QA skill and the review skill; the mapping to WCAG success criteria is mine.
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.
See also:max.system, max.zeichen and max.lab
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.
01Export timesheets as CSVcreated with the PM ticket skill02Pipelineagents implement · Engineering03Quality gate04Codefor review
ZVS-1482
Export timesheets as CSV
darkfactoryon
Pipeline
Quality gateP0–P3
- UnityUI components
- Tokens
- Grid
- Accessibility
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 tokensfrom the package
- UnityUI pattern libraryinteraction and flow patterns, being expanded
- Design refinement skillextended for the Dark Factory
Level 5 of 5agents implement tickets on their own
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.
Build patterns
The designers build one or two patterns a week
Guide and take over
The frontend lead guides them and takes them over into code
Check and release together
At the end we check together, then the pattern goes into a release
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.
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.
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.
Sample
- Add Tom Becker’s missing hours for week 44 and let the client know.A
Add missing hoursApproval required
- Open the week 44 timesheetTom Becker · Warehouse North assignment
- Enter 38.5 hourswritesfrom time tracking
- Notify the clientsendsEmail to the contact person
Then I’ll run all three steps in this order.
Runs after approvalDeclineApprove
- Action titleSays in a few words what will happen
- StepsEvery step on its own; anything that writes or sends is marked
- LockNothing happens until someone decides
- DecisionReject 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 itpatterns/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.
01
Approval by risk
Reading, drafting, writing and sensitive data each get their own rules instead of one approval for everything.
02
Consent for sensitive values
Values stay masked until someone agrees. The log records who saw which value.
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
Learning
Quality gates check building blocks. Consistency only comes from patterns.
What came of it
Make the system readable
Guidelines, skills and rules for Figma Make, Claude, Cursor and other tools
Prototypes made of real UnityUI components
Ship the package
The frontend lead’s release pipeline, internally and publicly on npm
UnityUI where things get built
One source
One file, producing 63 component skills and one shared rules file
Stop maintaining rules per tool
Check instead of hope
QA skill with ten phases built from real production bugs
Catch errors in AI code
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
Patterns for the Dark Factoryopen
Expansion of the UnityUI pattern library started
Consistency when agents implement on their own
Measurabilityopen
not measured
Measure the effect
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
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.
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.
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.
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
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.
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.
fin (for now)