How a feature travels from client request to production in an AI-native pod
CLIENT
│
│ "We need X"
▼
┌─────────────────────────────────────────────────────────────┐
│ DISCOVERY & SCOPING [Product Owner] │
│ Workshop recording → agent-drafted stories → PO refines │
└──────────────────────────┬──────────────────────────────────┘
│ Approved spec
▼
┌─────────────────────────────────────────────────────────────┐
│ DESIGN [Designer] │
│ Prompt → 3–5 UI variants → pick + refine → design tokens │
└──────────────────────────┬──────────────────────────────────┘
│ Figma + token handoff
▼
┌─────────────────────────────────────────────────────────────┐
│ SPEC REVIEW [Tech Lead] │
│ Architecture check · risk flagging · rules update │
└──────────────────────────┬──────────────────────────────────┘
│ Green-lit spec
▼
┌─────────────────────────────────────────────────────────────┐
│ PARALLEL AGENT EXECUTION [Engineers] │
│ │
│ Agent A Agent B Agent C │
│ API layer DB migration Tests + docs │
│ └──────────────┴────────────────┘ │
│ │ │
│ PRs opened per subtask │
└──────────────────────┬──────────────────────────────────────┘
│ PRs ready
▼
┌─────────────────────────────────────────────────────────────┐
│ CODE REVIEW [Tech Lead + Eng] │
│ Agent PR audit · architecture check · merge or revise │
└──────────────────────┬──────────────────────────────────────┘
│ Merged to staging
▼
┌─────────────────────────────────────────────────────────────┐
│ QUALITY ASSURANCE [QA] │
│ Agent test suite · exploratory testing · acceptance check │
└──────────────────────┬──────────────────────────────────────┘
│ QA sign-off
▼
┌─────────────────────────────────────────────────────────────┐
│ RELEASE [DevOps / Platform] │
│ Canary → 5% traffic · metrics watch · full rollout │
└──────────────────────┬──────────────────────────────────────┘
│
▼
PRODUCTION
│
│ Demo + sign-off
▼
CLIENT
Owner: Product Owner
Inputs: Client brief, workshop recordings, existing backlog
Outputs: Refined user stories, acceptance criteria, scope boundary
Client call / workshop
│
▼
Otter / Fireflies
(recording + transcript)
│
▼
Agent drafts stories
from transcript
│
▼
PO reviews + fixes
(2 of 8 stories need edits)
│
┌────┴────┐
│ │
In scope Out of scope
(backlog) (logged as future / change order)
What agents do: Transcribe, structure raw notes into stories, score priority, flag ambiguity.
What only humans do: Read client mood, make scope trade-off calls, protect margin.
Definition of done: Every story has a title, user value statement, acceptance criteria, and a clear "not in scope" boundary. Coding agents can act on it without asking follow-up questions.
Owner: Designer
Inputs: Approved stories, design system tokens, brand guidelines
Outputs: Refined Figma screens, updated design tokens, prototype if needed
Story + brand context
│
▼
Prompt to Claude Design / v0
│
▼
3–5 UI variants generated
│
▼
Designer picks + refines
│
┌────┴──────────────┐
│ │
Figma handoff Token update
(screens) (colors, type,
spacing in code)
Checkpoint: Tech Lead reviews for implementability before engineering starts. Catches layout patterns that would be expensive to build before a line of code is written.
Owner: Tech Lead
Inputs: Refined stories, design handoff
Outputs: Go/no-go on spec, architecture notes, updated CLAUDE.md
Story + Figma
│
▼
Tech Lead reads spec
│
┌───┴───────────────┐
│ │
Good to go Needs work
│ │
▼ ▼
Update Bounce back
CLAUDE.md to PO or Designer
with any with specific gaps
new rules
This is where quality is won or lost. A vague spec produces vague agent output. The Tech Lead's job here is to make the spec unambiguous before any code runs.
Owner: Engineer(s)
Inputs: Green-lit spec, CLAUDE.md, design tokens
Outputs: Feature branches, opened PRs per subtask
Engineer reads spec
│
▼
Splits into independent subtasks
│
┌────┼────┐
│ │ │
▼ ▼ ▼
Agent Agent Agent
A B C
│ │ │
▼ ▼ ▼
API DB + Tests
layer migration + docs
│ │ │
└────┬─┘ │
│ │
▼ ▼
PR A+B PR C
Engineer's role: Write the specs, spawn the agents, monitor for drift, step in early when an agent goes off course, review every PR as if a junior wrote it.
Cost gate: Engineer checks token burn after the first agent cycle. A runaway loop can cost $400+ before anyone notices.
Owner: Tech Lead (final gate) + Engineer (peer)
Inputs: Agent-generated PRs
Outputs: Merged code, updated rules for repeat mistakes
Agent PR opened
│
▼
Automated checks
(lint, types, tests)
│
┌───┴────────┐
│ │
Passes Fails
│ │
▼ ▼
Engineer Agent or
peer review engineer
fixes
│
▼
Tech Lead review
(architecture, security,
subtle logic)
│
┌───┴────────┐
│ │
Approved Changes
│ requested
▼
Merge
│
▼
Update CLAUDE.md
if a new rule would
prevent this class
of mistake
What to watch for in agent PRs: Plausible-looking but subtly wrong logic, slow or unsafe queries, missing auth checks, over-engineered solutions.
Owner: QA
Inputs: Feature on staging, acceptance criteria from Stage 1
Outputs: QA sign-off or bug report
Feature on staging
│
┌────┴─────────────────┐
│ │
Agent test suite Exploratory
(Playwright, 140+ testing by human
tests overnight) (edge cases, UX
│ feel, business
┌────┴────┐ logic sense)
│ │ │
Auto-fix Escalate │
(healer to QA ┌──────┘
agent) or eng │
Acceptance criteria
check against spec
│
┌────┴────┐
│ │
Pass Fail
│ │
Sign-off Bug report
→ back to
Stage 4
For AI-powered features: QA also runs LLM-as-judge evaluation — Braintrust or LangSmith scoring agent output against rubrics, not just checking UI clicks.
Owner: DevOps / Platform
Inputs: QA sign-off, merged code on main
Outputs: Feature live in production
Merge to main
│
▼
CI/CD pipeline
(build, scan, smoke test)
│
▼
Canary deploy
(5% of traffic)
│
┌───┴───────────────┐
│ │
Metrics OK Anomaly
(latency, detected
error rate, │
cost) Auto-rollback
│ + alert
▼
Full rollout
(100% traffic)
│
▼
Observability live
(LangSmith traces,
Helicone cost,
Grafana metrics)
Non-deterministic release strategy: Feature flags let DevOps roll out AI-powered features to a slice of users first, measure quality, and expand — or kill — without a full redeploy.
Owner: Product Owner
Inputs: Feature live in production
Outputs: Client approval, invoice milestone hit, or change order
Feature live
│
▼
PO prepares demo
(agent drafts talking points,
PO edits for client tone)
│
▼
Demo call
│
┌──┴──────────┐
│ │
Approved Feedback
│ │
▼ Triage:
Invoice │
milestone ┌──┴──────────┐
hit │ │
In scope Change order
(bug fix) (new scope,
new SOW)
Day 1 ████ Discovery & Scoping (PO + agents + client)
Day 2 ██ Design (Designer + AI tools)
Day 2 █ Spec Review (Tech Lead)
Day 3–4 ████ Parallel Agent Execution (Engineers + agents)
Day 4–5 ██ Code Review (Tech Lead + Engineers)
Day 5 ██ QA (automated overnight + human exploratory)
Day 6 █ Release (canary → full rollout)
Day 6 █ Demo + sign-off (PO + client)
A feature that took 3–4 weeks in the old model ships in 5–6 days. The constraint is no longer writing code — it is judgment: the PO reading the client, the Tech Lead spotting the subtle bug, the QA engineer finding the edge case no agent imagined.
| Stage | Human owner | Agent contribution | Human judgment required |
|---|---|---|---|
| Discovery & Scoping | Product Owner | Draft stories from transcripts | Scope calls, client trust, margin |
| Design | Designer | Generate UI variants | Brand, accessibility, consent UX |
| Spec Review | Tech Lead | — | Architecture, risk, ambiguity |
| Development | Engineer | Write code, tests, docs | Spec quality, drift detection |
| Code Review | Tech Lead + Eng | Automated checks | Subtle logic, security |
| QA | QA | Test generation, auto-healing | Exploratory, business sense |
| Release | DevOps | Anomaly detection, rollback | Risk tolerance, canary thresholds |
| Sign-off | Product Owner | Demo notes | Client relationship, scope judgment |
Repeat agent mistake
│
▼
New rule in CLAUDE.md
│
▼
All future agent runs
read the updated rule
│
▼
Whole class of bug
prevented, not just
one instance fixed
This is the compounding advantage of the agentic model: every caught mistake that becomes a rule makes every future feature better. The CLAUDE.md file is the pod's institutional memory.
The workflow is not waterfall — stages overlap, agents run in parallel, and fast features can skip from spec to staging in a single day. The diagram shows the logical sequence, not a rigid calendar.