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. AI speeds up everything around it.
Every signal feeds one living evidence base: past studies, live interviews, usage telemetry, and field feedback. Sessions are auto-transcribed and summarized, insights are clustered and scored, and the strongest ones are routed into the backlog as tagged, sized roadmap items, connected through MCP to the tools the team already works in. From there the loop keeps moving: specs drafted from the evidence, working prototypes coded for the next round, and Figma plus the living design system updated so stakeholders comment and collaborate where they already are. Once it ships, live adoption and engagement data closes the loop and sets the next roadmap priority.
Built end-to-end as the AWS UX Research App — research → backlog → wireframes → prototypes → Figma — saving the team weeks of manual effort.
From spec to ship to adoption at scale — 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. - Built in working code, with the right model and tool for each job. No single vendor. Spec-driven builds run in the Kiro IDE and Claude Cowork, with Kiro Crew's multi-agent harness for agent teams that keep working on long-running tasks between sessions. Models and assistants are fit to purpose across the field — Anthropic Claude for deep reasoning and code, OpenAI's ChatGPT, Google Gemini, Meta Muse, Perplexity for research, and Amazon Nova where speed and cost at scale matter most — each matched to the job it does best. 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.
- Adopted, then scaled. Launch is the start, not the finish line. The team builds and shares with the same AI tools, onboarding is part of the product, and rollout grows org-wide with guardrails and clear direction built in — the way Autonomous Sales nearly doubled Sales Acceptance and the AI-Ready Design System spread across the org in Kiro and Amazon Quick.
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
// Kiro · Claude Cowork · multi-model, fit to purpose
Adopt
// launched to real users, the team building with it
Scale
// org-wide rollout, guardrails built in
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.
Models + assistants // right model for the job
Orchestration // spec-driven, multi-agent 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 →