The work has shifted.
Same fundamentals — discover, design, build, ship, measure. What changed is what sits beside me at every phase. The agent does the typing; I do the deciding. The shift isn't toward "AI tools" — it's toward building the agents themselves, and each one I ship makes the next one faster.
Three rules underneath all of it:
AI as accelerator, not author
The agent does the typing. I do the deciding. Judgment, taste, and accountability stay with the designer.
Real data over guessed data
Agents read shipped components, real research, real outcomes — never make-believe. The design system is the contract.
Always shipping, never spectating
Live prototypes, real users, measurable outcomes. The post-launch loop is where the next iteration starts.
Agents around every phase. Conversations stay human.
Most of the product lifecycle now runs through automation grounded in real project data — not AI making things up. The one part that doesn't compress is the conversation itself: sitting with a user, asking the right follow-up, hearing what they don't say. Everything around it compounds.
The conversation stays human. Everything around it — automated.
Past studies systemized into a queryable insight repository. Live sessions auto-transcribed and summarized. Insights clustered, scored, and routed into Asana as tagged roadmap items, sized against intent. From there the same loop keeps going: wireframes generated from the synthesis, clickable prototypes coded for the next round of testing, and Figma components plus a living design system auto-generated so stakeholders can comment, mark up, and collaborate where they already work. One tool — research to design to dev. The agent doesn't sit in the conversation, though — that part is still a person in the room.
Built end-to-end inside the AWS UX Research App — research → roadmap → wireframes → prototypes → Figma. Currently in flight.
From spec to ship to evidence — one continuous loop
-
Spec → wireframes → clickable prototype. Insights turn into a
spec (
requirements.md→design.md→tasks.md), wireframes generate on the real design system, and a clickable prototype is in front of users on day one. I review for taste and intent — drift caught at the spec layer, not in production. - Pair-coded into production. From there I pair with coding agents (Kiro, Cline, Q Developer) to take the same prototype the rest of the way. Engineers pick up working code, not screenshots — no translation step, nothing lost.
- Launched staged and instrumented. Success metrics defined pre-launch, telemetry in place, a Day-30 review on the calendar. The agent watches dashboards, surfaces drift, and routes evidence into the next sprint.
The loop doesn't reset — it picks up where the last round left off. Conversations stay human; everything around them compounds.
Design
// spec → wireframes → clickable prototype
Ship
// pair-coded with Kiro · Cline · Q Developer
Learn
// launched, instrumented, evidence in
Months. Weeks. Hours.
The compression isn't linear — it's compounding, because every agent makes the next agent faster.
What the agent doesn't do.
- Decide what to build. The bet is mine to make.
- Decide which user matters. The conversations are still face-to-face.
- Decide what good looks like. Quality is non-negotiable; speed is what the agents earn.
- Earn the trust of the team. The agent doesn't carry the relationship.
- Own the outcome. If it ships and doesn't move the number, that's on me.
The current toolkit.
The tools change every two years; the principles don't. Underneath every project: a spec layer, a design system, an audit loop, and a human in the chair.
Agents // reasoning + generation
Orchestration // spec-driven build
Craft // design + prototype
Loop // research + ship
One closing rule.
Process isn't a script — it's a posture. Same insistence on craft. Much more leverage. The lifecycle that used to live across a team now lives in one practice, multiplied by the agents alongside me.
Want to see the loop applied? The selected work →