I made design AI-native. Then I did the same for the whole company.
- Role
- Director, Software Product Design. Inherited a one-person department with no process. Now developing 2 leads toward leadership.
- Problem
- A 30-year-old codebase, ~1,000 screens to redesign, and a CEO who wanted AI strategy yesterday.
- What I built
- A five-phase design pipeline where every artifact traces back to the brief that spawned it, plus the measurement system that proves what it saved.
- Result
- 476 designed states and 59 logged decisions in four months, with 2 designers doing the work of 4–5.
I built the measuring part before I had anything worth measuring, which felt like a wasted month at the time. It's the reason I can show you these numbers instead of describing them.
Who did what: the system is mine. I architected it, built it, and I still run it. The design output is shared with one other designer. The counts come straight out of the vault. The ratios are modeled against a traditional baseline, and I used the low end of my own range.
One designer, no process, and a CEO who wanted AI yesterday
I joined a 30-year-old retail tech company to reshape its design department. What I inherited was a single designer, a 30-year-old codebase, and a process that consisted of an accessibility partner and the early bones of a component library. The CEO wanted AI strategy yesterday.
A Figma file per feature, one designer per screen, hand off, repeat was never going to cover a thousand screens. And bolting AI onto a broken pipeline only produces broken output faster. So I stopped trying to make designers work faster and rebuilt the process around one idea: provenance. Every screen we ship knows exactly where it came from.
Every screen we ship knows exactly where it came from.
I put the whole process on rails
The pipeline runs five phases, from "we have a problem" to "we shipped, and here's what users did with it." Each phase produces an artifact and every artifact carries a breadcrumb back to the problem brief. Any teammate can open any spec line in our repo and walk it back to the user research, the design decision, the dev review, and the analytics. Nothing gets orphaned.
AI does the work it's actually good at: generating interactive HTML prototypes with their edge cases, piping to Figma via MCP, turning dev and PM feedback into structured notes. People do the work we're good at: judgment, edge-case storytelling, the conversations that never fit in a Jira ticket. Accessibility is checked in-line, on semantic HTML, before screens lock. What users do after launch comes back in and teaches the next design.
A UI modernization that used to take three weeks now ships in an afternoon, because the next designer doesn't have to re-derive decisions the system already remembers. The team runs it without me. That mattered more to me than the speed did.
The real test: ~1,000 screens on a locked deadline
A storefront redesign scoped at roughly 1,000 screens: 440 primary layouts plus about 560 edge-case states, because retailers customize everything. Two designers produced the handoff on a locked eight-sprint deadline, for a build team ten timezones away.
The lever wasn't working faster. It was the handoff format. An interactive document puts every edge case next to the screen it belongs to, instead of a Figma file where edge cases sit scattered or missing entirely. That took out three costs that used to land on developers: lookups, clarification round-trips, and rework caught late. It gave back close to a full sprint out of the eight, which was the whole margin between hitting the date and slipping it.
Then I measured it
Most teams can't tie AI work to an outcome, and it's usually because nobody set up the counting before the work started. Since every artifact in the pipeline carries its provenance, the system can count what it produced and model what the old process would have cost. That's where the numbers at the top of this page come from. It also means I can hand you the assumptions instead of asking you to trust the total.
An AI program nobody can audit tends not to survive its first budget review.
What was hard
Three things bit us, and each one shaped how I run the pipeline now.
- Pixel-perfect parity with an existing component library is brutal. Importing a mature library into Claude Code and getting prototypes to honor every token, spacing rule, and state variant, without the model quietly inventing a button, took far more guardrails than I expected. We fixed it by tightening the prompt contract and treating the library as a constrained vocabulary rather than a suggestion.
- Routing transcription into the right node of the knowledge graph is slow, deliberate work. Dev and PM feedback only stays useful if it lands on the spec line it actually addresses. That meant building the graph one stable connection at a time. Moving fast here corrupts every decision downstream.
- Edge cases have to be documented before an agent can find them. About 560 of the storefront's states are edges. The agent could only generate useful variants once those edges (empty states, error paths, partial data, permissions branches) were written down somewhere it could retrieve. Documentation stopped being a deliverable and became infrastructure.
What I'd bring to your team
None of this was specific to retail, or to design. It's three moves in a particular order, and I've now run it twice.
Make the knowledge retrievable
Research, decisions, transcripts, and the component library become a structured layer an agent can actually query. Until this exists, AI output is confident guessing.
Put the process on rails
Phases with named artifacts, citations back to the brief, and human checkpoints where judgment beats generation. The speed comes from not re-deriving decisions, not from cutting corners.
Instrument it on day one
Provenance makes the output countable, which makes the program auditable, which is what turns an AI experiment into a funded line item. It's the boring move, and it pays off late, so it's usually the one that gets dropped.
See how the screen builder actually runs
Eight folders, six phases, the feedback loop, and a worked example with a decision-log excerpt, mocked into a neutral domain for confidentiality.
What it unlocked
Proving AI inside design earned the mandate to redesign how the company's knowledge workers use AI more broadly. That work became a 9-layer connected intelligence architecture, green-lit by the CEO and IT for company-wide scale. That's Case 01.