Skip to content
CV
WorkDesign System UnityUI · AI-ready15 min read01 · Overview

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.

Read the caseRJump to results
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
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

    63component skills from one filePlus one shared rules file
  • 10

    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
  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 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
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 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.
Written from the roles' requirements, as of my last information.
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.

05 · Tool path

Every tool exposed a gap, until a decision was made

The path through the toolsautumn 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.

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 toolLive on this site

max.does.systemsUnityUILiveexplainerexplainerRuns on the real system of this site: the same tokens, components and rules.UnityUI on npm
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.

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 skillLive on this site

max.does.systemsUnityUILiveexplainerexplainerRuns 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 · Accessibility9 checks

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.

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.

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

01Export timesheets as CSVcreated with the PM ticket skill

  1. ZVS-1482

    Export timesheets as CSV

    darkfactoryon

  2. Pipeline

  3. Quality gateP0–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 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 ownIn use since August 2026

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 releaseevery 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 actionExample · rebuilt

Sample

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

    1. Open the week 44 timesheetTom Becker · Warehouse North assignment
    2. Enter 38.5 hourswritesfrom time tracking
    3. Notify the clientsendsEmail to the contact person

    Then I’ll run all three steps in this order.

    Runs after approvalDeclineApprove
  1. Action titleSays in a few words what will happen
  2. StepsEvery step on its own; anything that writes or sends is marked
  3. LockNothing happens until someone decides
  4. 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.

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

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 Factoryopen

    Expansion of the UnityUI pattern library started

    Consistency when agents implement on their own

  7. Measurabilityopen

    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)

CV · Maximilian Dahl
In plain words

What do you actually do, Max?

My parents and family have nothing to do with tech or my profession. They told me they did not understand my website. This is for them. And for anyone who would like an explanation without the jargon.

I make software easier to work with.

When someone spends ages searching for a button or has to enter the same information three times, I want to know why. I watch how people work, talk to them and design a better way through the task. Then we try it together.

My title is Principal Designer. That means I also make decisions about how whole products fit together and help the team build on them. I still design and write code myself.

Here is a simple example.

At zvoove, I designed an assistant called zAIn. This simplified example shows the idea:

  1. Someone asks

    “How much holiday do I have left?”

  2. The assistant looks it up

    It finds the information and explains the answer.

  3. The person decides

    If they want to book time off, they review the details before anything is sent.

My job is to work out what people need to see, how the answer should be explained and when the program needs their approval.

A design system is a bit like LEGO.

Imagine every team inventing its own bricks. Nothing fits. With a shared kit, the pieces connect, even when people build different things.

Shared pieces. Different things you can build.
Book time offReview an invoice

In software, those pieces are things like buttons, input fields and messages, plus rules for how they work together. I built this kind of kit at Container xChange. It is called Compass.

What has come out of my work?

One starting point
At zvoove, I designed the shared starting point for several programs and tried it out in code. It became Launchpad, which has been live since August 2026.
Built, too
I built the visible part of the notification centre myself. A backend engineer built the part behind it, and we shipped it together.
A team that can build on the work
At Container xChange, I grew the design team from 4 to 14 together with Niclas. Compass gave designers and developers a shared kit to work with.

What am I particularly good at?

I look beyond the screen in front of me. When several teams run into the same problem, I look for a solution they can share. That is how Compass came about.

And I like making an idea tangible early. I can build a working version myself, put it in front of someone and find out where it falls short. I would rather learn that from using it than from a long discussion about a picture.

What would I like to do next?

I want to help decide what a product should become, support a team and keep building myself. I am looking for a role as a Principal Designer, Team Lead or AI Product Builder, in a team that builds with artificial intelligence.

In plain words: I want to take responsibility for the whole thing, without giving up the part I enjoy most — trying things out and making them work.