Technically they shouldn't differ this much. Ask a machine and it hands you a near-identical answer every time.
But systems are built by people, for brands. They carry a team's structure and history, its taste, and most of all what the brand is trying to be. That is why every one is different, and honestly why the work stays interesting. The variation isn't noise to standardise away. It's the point.
The work always had one reader: people. Lately it has a second. The agents now pulling from our tooling read a system literally, and they don't forgive one that only half exists. Same job, higher stakes: consistent and verifiable enough for the machines, human enough to still carry the brand and the people who made it.
A design system Unica can read, and so can their AI agents.
Design intent kept getting lost between Figma and production. Agents could not read the system at all.
Design Engineer: token architecture, paired components, machine-verifiable specs.
A system humans and agents can both consume, so teams ship with intent intact.
An evolving design system that teams struggled to adopt at scale.
Rethought foundation and strategy, then ran training and workshops.
An agile framework product teams could actually run with.
A new visual language to roll out across products for teachers and pupils.
Optimised tokens, components and the Figma library, aligned with dev.
A streamlined token pipeline integrated across the portfolio.
UX strategy and component architecture for Exact's product suite.
Product surfaces needed a coherent, scalable component architecture.
UX strategy and component architecture across the suite.
A clearer structural foundation for the product to build on.
A multi-brand design system three people built and ran, one codebase, live across the Nordics.
Many brands and markets, one small team without multiplying codebases.
Design Lead: token architecture, unbranded components, React pipeline.
Two brands in light and dark from one build; visual changes reached live code in hours.
I work independently, through CreateNew (the first designer-owned cooperative, which I co-founded). Recent design-system engagements include:
Building Unica's design system to be read by humans and agents alike: tokens, paired components, machine-verifiable specs.
UX strategy and component architecture for the design system at the Dutch business-software company.
Two engagements: first rethinking the system's foundation and strategy, then returning to refine it and train the product teams to run with it.
A new visual language across their products for teachers and pupils: token structure, components, and the Figma-to-code pipeline.
Design-system work for the digital products of the global chemical-distribution group.
Multi-brand design system: one React-and-tokens codebase, two brands in light and dark, live across the Nordics.
The work I make when nobody asked. Three decades in, and I still can't leave an interaction alone. How should a surface feel under a cursor? How do you build something a machine can read without draining the life out of it? I have to know, and knowing means building it. Most of it starts inside real work: something to make my own process faster, or part of a client project, a custom tool left behind as an artifact. Some is still on the bench; a few might end up as repos.
Controls that bend the light behind them, so the interface reads as a material, not a rectangle.
one feDisplacementMap fed by a blurred mask, not a filter per button
A photo rebuilt as theme-aware dots, so a bitmap can live inside an editorial layout.
Bayer 4×4 ordered dither on a canvas, recolored to the active theme
The site you are reading, used as a running notebook for interaction craft.
every effect in this list ships here first, in hand-written HTML and CSS
Generating and checking color ramps for several brands from one source of truth.
OKLCH lightness steps, validated for contrast before they ever reach a token
An OKLCH generator that guarantees readable pairs across every brand and mode.
reject a step at generation time if it fails AA, before anyone hand-checks
Packaging physics-based spring easings as tokens, so interaction survives the handoff.
store the spring as a linear() ramp, so CSS and code read the same curve
Git-style visual diffs for design tokens, so a reviewer sees a ramp shift before approving the merge.
render the before and after swatch inline, not the hex string
Flagging hardcoded values and unbound variables in Figma before a pixel reaches engineering.
walk the node tree, match every fill against the bound-variable set
Reading the codebase to show which components actually ship versus which only live in the library.
count real imports, not the component inventory
Structuring system docs so an LLM agent can consume tokens and components without guessing.
still finding the shape: what an agent needs from a spec that a human reader does not
If you've read this far,
we should talk.
A system to build, a foundation to reset, a team to get running on its own: that's the work I like best. I take it on independently through CreateNew, from the Netherlands, remotely across Europe. If that's the problem on your desk, let's have a coffee.
