Case study · AI in the product lifecycle
Designing With AI, Together
As AI tools entered our product workflow, teams gained real speed generating interfaces, flows, and concepts. But in a mature, interconnected product, designing a screen is not the same as designing an experience. The risk wasn't that AI was too slow — it was that polished output was outrunning shared agreement on what we were building.
AI accelerated our output. It did not accelerate our agreement.
The diagnosis: adoption was already here — structure wasn't
Before proposing anything, I ran a survey across Product and UX to ground the conversation in evidence, not opinion. 19 respondents, March 2026.
AI changed what's cheap — not what's hard
The new economics of building quietly shifted where the bottleneck sits.
What got cheaper
- Generating mockups, UI, and layouts
- Producing code scaffolds and prototypes
- Drafting copy, specs, and variations
- Turning a rough idea into a finished-looking artifact
What didn't
- Knowing it's the right problem to solve
- Shared understanding across roles
- Requirement clarity and completeness
- Agreement on what "done" actually means
A designed artifact looks like an answer — it can quietly skip the question.
When Product hands off an AI design
A polished artifact arrives — and UX effectively starts the thinking over.
Product + AI
generates a finished-looking design
Hand-off
the design is passed to UX as the starting point
UX inherits
decisions are already baked into the artifact
UX restarts
the problem gets re-opened and re-worked
The cost
Duplicated effort
Two roles solve the same problem twice — once in AI, once for real.
Decisions locked early
Choices are committed inside the artifact before they're ever reviewed.
Hidden requirement gaps
A finished look conceals the questions that were never actually asked.
The fix: unpack the problem together, before pixels
The instinct elsewhere is to lock down a five-day design sprint. We didn't need the ceremony — we needed its operating principles, applied at intake.
Map it together
Everyone builds one shared picture of the problem before anyone proposes a solution.
Understand first
Diverge on the problem space before sketching; the solution comes second.
Decide as a group
Choices are made openly, not in silent solo handoffs downstream.
I deliberately didn't brand this as "design thinking." The practices matter more than the label — and the label tends to put people off — so I built them in foundationally instead of announcing them.
Design gets a line in the plan
When UX time isn't scoped, it doesn't vanish — it resurfaces as rushed work and rework. We scope UX as real work, discovery and iteration included, and protect it before build begins.
Design time exists whether you plan for it or not — the only question is whether it's scheduled up front, or stolen from quality and repaid as rework.
Co-ownership, no handoffs
Planning, requirements, sizing, taxonomy, personas, journeys, and prototyping became co-owned across functions. Anyone can vibe-code a quick layout; UX designs to systems, architecture, and business + user needs, with peer review built in.
An approved AI toolkit
I mapped which AI tools were sanctioned at each stage of the lifecycle and which weren't — giving the team a clear, safe standard instead of 4.6 tools each and a stack of personal subscriptions.
What changes
Making it stick: enablement, not announcement
A process only works if the team can actually run it. So I built the scaffolding to make it routine.
AI strategy & onboarding
Built the AI strategy for the design team and onboarded every designer to the sanctioned tools.
A review process for AI work
When product partners arrive with AI-generated solutions, the artifact gets interrogated — not just inherited.
A code-based idea library
A shared library of design ideas and experiments the team contributes to — built in real code, organized by business line and user journey.
Quarterly tool workshops
Recurring tool-practice sessions so the standard keeps evolving as the tools do.
├─ marketplace/
│ ├─ search-relevance/ prototype.tsx
│ └─ condition-report/ prototype.tsx
├─ seller/ send-to-auction/
├─ buyer/ saved-searches/
└─ operations/ inspection-flow/
My job as a manager isn't to hand the team a process — it's to build a space where they can keep learning as the technology keeps moving. AI didn't change that. It raised the stakes.
How I lead
This initiative is one expression of how I manage. I currently lead a team of six designers and have managed designers for ten years, six of them at ACV.
I build for growth.
My top priority is a space where designers learn and grow as the technology keeps changing. I support each designer's goals through annual goal plans and quarterly evaluations, tracking where each person wants to go next — senior, lead, or principal.
I co-created our evaluation framework.
I built role documentation that lets us evaluate the team against the standards used across the industry, then customized it to our team and our culture.
I work backwards from solutions.
When a stakeholder, executive, or product partner arrives with a solution, I unpack the underlying problem, surface hidden opportunities, present on them, and facilitate the collaboration that turns a proposed answer into the right one. I do the same with my team.
I still build.
Alongside managing, I contribute as an individual — partnering with and conducting UX research, and creating long-range company visions that let us plan years ahead. Some of these I shaped over six years here; we're only now starting to build toward them.
In short
- Diagnosed AI adoption with a 19-person survey — finding widespread use, requirements as the core friction, and significant tool sprawl.
- Reframed the problem: AI accelerated output, not agreement.
- Identified the failure mode: AI-generated designs handed off as finished answers, forcing rework downstream.
- Rebuilt the process: a shared unpack step at intake, UX scoped as real work, co-ownership across functions, and a sanctioned AI toolkit by lifecycle stage.
- Made it durable: team onboarding, a product-AI review process, a code-based idea library, and quarterly workshops.