Design lead who ships. I build the system, the team, and the thing itself.

Fourteen years across design systems, delivery and strategy, from startups to the Fortune 500. I build the thing, and I build the team that builds the thing — lately with AI doing real work in the loop. Right now that's Scout, a tool that turns raw input into structured data.

Selected work

A lean design system that product teams chose to adopt

Design lead along with two engineers

Product teams were building on Swift, React Native and web with no shared contract. Every design decision got remade per platform, and drifted.

What I did

Treated the system as an operating model, not a library: semver releases, same-day Figma-to-JSON contributions, an explicit platform handoff. Adoption became a decision, not drift.
Shipped the token layer and the first forty components myself — DTCG tokens through Style Dictionary, into Swift, React Native and CSS, light and dark built in from day one.
Said no in writing: a public changelog, and a "what not to generate" list. One release alone cut 233 speculative tokens down to about 60 — a pattern had to earn its place by its second use.

What changed

Design-to-build rework down about 40%. Components reference semantic tokens only, so a rebrand touches one file, not forty.
The fourth product shipped its UI in six weeks against a sixteen-week baseline — one tagged release, pinned across all three platforms.
A year later, adoption was still above 90%. Teams chose to keep using it, and a CLAUDE.md contract kept AI-generated code compliant without anyone reviewing it line by line.

Research findings that carry their own evidence

Designed and built it myself, with AI as the material

Discovery deliverables were slideware. Stakeholders couldn't tell a grounded claim from a confident one, so the loudest claim won.

What I did

Built VERA, an agent that drafts discovery deliverables with the evidence attached to every claim, and Stacks, the tool for assembling them.
Prototyped in code from day one — the prototype became the product.
Made unsupported claims visibly different instead of quietly deleted, so the gap itself became information.

What changed

Deliverable assembly went from days to hours on three engagements.
Every shipped claim traces to an interview, a metric, or gets flagged — zero silent assertions.

Sizing engagements by model instead of guess

Led the capability model; built the sizing logic

Teams were staffed from headcount intuition, then corrected mid-engagement — the most expensive possible time to learn the answer.

What I did

Mapped delivery into 26 capabilities, each with execution levels and a capacity model, separate from job titles.
Built sizing logic that turns an engagement intake into a staffing range, with a stated reason behind every line: scope, stakes, timing, effort.
Tested the model against three past engagements, and set up a pilot on live proposals next to the current method before asking anyone to switch.

What changed

Fewer mid-engagement corrections — the model catches under-scoped work and missing roles at proposal time, before they're expensive. Target: half, against a baseline from past engagements.
Faster proposals, because the model does the arithmetic and people review the reasons. The target is two days, down from a week.
Sales and delivery argue about reasons, not numbers: each disputed seat points to a stated reason that can be changed.

Proof

Case studies are testimony — you have to take my word for it. This is evidence instead: the actual calls I made, the actual repo, and how I think in writing.

A DECISION LOG

Price capabilities at a level, not titles.
Why
Titles hide the work. On an enterprise client engagement, an AI & ML title built systems and UI, and a Product Strategy title ran delivery. Pricing by title would have staffed the wrong people.
What it cost
Harder to sell than a title-first estimate, because clients think in roles. It also needs self-assessments that don't exist yet.
Agents never get a seat, and their savings stay unproven.
Why
Counting agent help without the review it creates understaffs exactly the engagements that lean on agents hardest.
What it cost
The model reads high against what agentic teams deliver. Sales will want the savings in the price; it waits for timesheets.
Ship the iPad app gated, not blocked.
Why
A designer can explore design and AR on day one. Pricing features stay inactive until an admin saves one category, item and variant, so onboarding friction drops to near zero.
What it cost
It's a two-state product, and nobody has defined what "inactive" looks like on the iPad: greyed, hidden or placeholder numbers. That gap lands on the designer mid-session.
AI proposes, the rules engine disposes.
Why
AI emits only schema-validated proposals and never touches geometry or pricing. That guarantees buildability and makes every interaction auditable.
What it cost
No generative range at all. Schema failures reject silently, so a brittle schema becomes dead air the rep can't diagnose in the field.
Dropped sequential staging for parallel definition.
Why
Meetings kept getting cancelled or cut short and async homework sat for weeks. Waiting on one validated layer before the next would have stalled the project.
What it cost
No built-in safety of validating one layer before opening the next. Several foundational decisions stayed provisional at once.
Built the Hub instead of documenting it.
Why
A coded prototype on the client's own stack showed how each role really uses it, and surfaced gaps and gray-area ownership earlier than documents would have.
What it cost
We built ahead of settled structure. The retro named too little scaffolding upfront and limited early buy-in on technical constraints.
Let AI hold the relationships between unsettled layers.
Why
AI in Miro linked roles, tasks, intent clusters and navigation, so the team could work downstream while foundations were still being validated.
What it cost
It failed where decisions were ambiguous and reinterpreted instead of extending. The fix: lock decisions once made, and let AI extend, not reinterpret.

This site, built in the open

No case study for this one — just the repo. Every prototype, every rewrite, every rejected direction is a real commit, with an AI co-author in the log. Read the history instead of my summary of it.

View the commits ↗

From the notes

AI, context, and the shifting meaning of intent

In a human-built prototype, every element carries intent: we can point to a margin, a color, a label, and say “that's there because…” With AI-generated prototypes, that chain breaks — the artifacts look intentional, but aren't necessarily meaningful. The job shifts from owning every pixel to interpreting what AI makes, and turning the noise into direction.

Read the full article on LinkedIn ↗

Notes on building

The opinions behind the work. Open one to see where it comes from.

How I lead

Through the work. I grew a design practice from four to nine, promoted two designers to senior, and never stopped shipping myself — tokens, prototypes, the occasional pull request. The team's output is the portfolio; mine is making that output better and faster than it would be without me.