I made design AI-native. Then I did the same for the whole company.

My role

Director, Software Product Design — inherited a one-person department and no process; hired into it and now develop 2 leads toward leadership

The problem

A 30-year-old codebase, hundreds of screens, one designer, and a CEO who wanted AI strategy yesterday

What I did

Rebuilt the process around provenance — an 8-phase pipeline where every artifact traces back to the brief that spawned it

Outcome

456 UI states and 82 logged decisions, feeding a ~1,000-screen storefront redesign · ~30% dev time cut

I joined a 30-year-old retail tech company with one designer, no process beyond accessibility, and a CEO who wanted AI strategy yesterday. I was hired to reshape the department. I chose AI as the lever — first to change how my own team works, then to operationalize it for the knowledge workers across the org who actually had to use these tools to do their jobs.

Scroll within frame to see the full pipeline ↓

The whole pipeline on one page — problem framing all the way through to a post-ship learning loop. Open full diagram →

What I walked into

A 30-year-old codebase, hundreds of screens, one designer, and a department whose entire process consisted of an accessibility partner and the early bones of a component library. Meanwhile the CEO wanted AI strategy yesterday. The old way of designing — a Figma file per feature, one designer per screen, hand-off, repeat — wasn't going to scale, and bolting AI onto a broken pipeline would just produce broken output faster. So I stopped trying to make designers work faster and rebuilt the process around an idea I called provenance: every screen we shipped should know exactly where it came from.

The move

I built an 8-phase pipeline that runs 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 trail back to the problem brief that spawned it. Translation: 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 is orphaned. Nothing gets lost.

AI does the heavy lifting where it's good — generating interactive HTML prototypes with edge cases, piping to Figma via MCP, transcribing dev/PM feedback into structured notes. Humans do the heavy lifting where we're good — judgment, edge-case storytelling, the conversations that don't fit in a Jira ticket. An external accessibility partner validates before lock. Production telemetry comes back in and teaches the next design.

What changed

A UI modernization that used to take three weeks now ships in one afternoon. Not because we're cutting corners — because the next designer doesn't have to re-derive the same decisions every time. The system remembers. The team adopted it; this isn't a one-designer party trick.

The clearest test is a storefront redesign scoped at roughly 1,000 screens — about 440 primary layouts plus ~560 edge-case states, since retailers customize everything and almost every feature carries advanced settings. Two designers produced the handoff on a locked eight-sprint deadline, for a build team split across a ~10-hour timezone gap. The lever wasn't working faster. It was the handoff format: an interactive document with every edge case sitting next to the screen it belongs to, instead of a Figma handoff where edge cases sit scattered or missing. That removed three developer taxes — lookups, clarification round-trips, and rework from assumptions caught late. By my estimate it reclaimed close to a full sprint of the eight, which was the margin between hitting the date and slipping it. The same scope under the old model would have needed two more senior designers and most of a year. Neither was on offer.

Every screen we shipped should know exactly where it came from. Nothing is orphaned. Nothing gets lost.

What was hard

AI-augmented design isn't a free lunch. Three things bit us, and 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 significantly more guardrails than I expected. We solved it by tightening the prompt contract and treating the library as a constrained vocabulary, not a suggestion.
• Routing transcription into the right node of the knowledge graph requires slow, deliberate upfront work. Dev/PM feedback only stays useful if it lands on the spec line it actually addresses. That meant building the graph carefully, one stable connection at a time — moving fast here corrupts every downstream decision.
• Edge cases have to be documented before the agent can find them. Our storefront redesign is scoped at roughly 1,000 screens — about 560 of them edge-case states. The agent could only generate useful variants once those edges — empty states, error paths, partial-data scenarios, permissions branches — were written down somewhere it could retrieve. Documentation stopped being a deliverable and became infrastructure.

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.