01Mess
Early on, demos were how Distyl got in the door. AI strategists built them on site with clients, and they came from everywhere: engineering, product, the industries they served. All smart, all different, so every demo looked like whoever built it.
A strategist who knew the front end shipped something solid, with real endpoints, in their own taste. Merge two demos and nothing matched. Hand one to another team and they started over.
I was the only designer, and I’d watched this exact mess cost other teams a year.
02Reach
The work came in like a firehose, and hiring was never going to keep pace. Design had to scale without adding headcount.
I started the granular work myself in Figma: every state, every name, every label. I expected it to take months, and you can see it take hold screen by screen.
But the front-end team was small and heads down shipping, and a Figma file nobody has time to build is just a wish. So the system had to live where the work already happened, in the code and in the AI tools everyone was already using.




03Hackathon
Summer 2025. Teams were falling for Lovable, which made demos that looked close enough. Close enough is how you get six versions of the same button.
So at Distyl’s first hackathon I pitched the opposite: one system of record. Build it once, let it cascade through everything, and prompt it like Claude Code so it pulls from the library instead of guessing. I pulled in a couple of engineers, we built it together, and we won. Not bad for a designer pitch at an engineering hackathon.
The tools weren’t there yet, though. Figma Make couldn’t hold the system, so we hard-coded a slice of it into one repo: colors, buttons, fonts. Mostly consistent, and it still wandered.
Demo to production in a straight line.
04Build
Early 2026, the tools caught up. Figma’s MCP got good, Claude Code got good, and since I’m not an engineer, I made the tools teach me what I didn’t know.
The first goal was small: get fonts, colors and buttons to match everywhere, because if those match, the screens look like one company. By February I had a package with a Figma plugin that rebuilt every token from scratch, five lint rules that made the right way the only way, and a CLAUDE.md that told the AI how the codebase actually worked.
Then I built the repo around it. Version 1.0 took two days to stand up: token architecture, component scaffolding, a docs site. After that came months of building it out, component by component, between everything else. I called it Cognition.

05Learn
I used Claude every day. Claude Code to build locally, and Claude again to get good at the parts I used to hand off: running my own repo, deploying it, changing things without breaking them. Cursor and Vercel to spin up pages, test ideas and toss the ones that didn’t work.
Figma’s MCP closed the loop. I exported components straight from Figma into code, part shadcn, part homegrown. That mix was the honest state of things. The first products ran on shadcn, then velocity won and it spun out fast, and with engineering hopping, cleanup was slow. The system had to meet the code where it was.
A few key people on the front-end team backed me the whole way. I leveled up because they made space for it.
I used to design things and hand them off. Now anything I can design, I can build.
06Receipts
An audit by hand would have meant weeks of side-by-side comparisons. I’d been reading about agent swarms, so I asked Claude Code to build one: three subagents sweeping our three repos against the system at once. Clunky to set up, perfect once it ran.
It found 344 hard-coded hex values, 2,061 raw color utilities and zero design tokens, plus six parallel theme files and a pile of competing rules files, everyone working from their own.
Then the smoke test. I built a dark mode switch and told people to flip it. Anything on the system changes cleanly, and anything that glows the wrong way is off it. Find it, fix it, flip it back.
The front-end team was all in. They just didn’t have the hours, and Cognition sat low on a long list. Now the gap had a number, and the number moved it up.

07Spread
I started sitting in on front-end meetings, then infrastructure and engineering standups. In some of those meetings I was the odd one out, so I said why: I’m here to learn how you put things together, so what I build plugs straight into it. Same pitch every time. I built a tool, it makes your job faster, what am I missing?
At first it was a zip file with Claude skills, context docs on mission and intent, and the system itself. Drop it in, prompt what you want, and you’re 80% there. Then it went where the team already worked, distributed as a skill across Claude Code, Cursor, Copilot and Windsurf, with a token guard that blocks a production deploy on a bad color.
Once teams built from the one repo in the toolkit, nearly all 2,405 violations cleared. What’s left is a handful, mostly motion and interaction states. Four releases in four months, 60+ components, and conversational UI built for how Distyl’s products actually talk.

08Unlock
The biggest unlock was a document.
Distyl ran forward-deployed engineers, and somewhere along the way I became a forward-deployed designer. Not a real title, not a real role anywhere. It was the job anyway.
Every demo and forward-deployed build started the same way: a client, a problem, someone on site. I started writing PRDs from those motions, for agents instead of people. A PRD alone tells an agent what to build, and a design system alone tells it how things look. Hand it both and it gets the whole job.
Most weeks, demos shipped the same week, often several at once. Some were rough concepts, and that was the deal. First passes landed closer to done, with less rework and a lot less of me needed at every demo.
09Proof
That summer we hired a front-end architect. His first week was the company offsite, and he walked in expecting to build the foundation himself. Instead he had a head start, and what got him most was that one designer built it.
The changelog says it plainly: system greenlit as platform infrastructure. We moved into Storybook as the source of truth, I ran audits in VS Code, and I started shipping my own pull requests.
10Philosophy
Tokens are the easy part. The harder part is how a decision earns its way into the system. I worked to three phases, honestly mostly for me. Nobody needed the philosophy; they felt the process.
Something I understand.
Sketches, concepts, early briefs. Just me, not yet in front of users.
Something we understand.
Prototypes and specs, tested with the team and a few early users.
Something they understand.
Polished, accessible, versioned, and shipped to everyone. Repeatable.
11What it changed
In October I left Distyl. The system stayed, and it ships today as Folio at the same address.
In 2023 I drew an AI teammate for a company that wanted a pair programmer. In 2026 I built one for a team that didn’t have one.
