Article
How Product Pod Roles Change Across Three Phases of AI Adoption
Most discussions about AI in software focus on productivity: faster coding, fewer people, more output. But the deeper change is not how fast code is written, but who is responsible for what, and what work actually matters inside a product pod. This article examines three phases of evolution and what each role actually does in each phase.
Most discussions about AI in software focus on productivity: faster coding, fewer people, more output.
That framing misses the real transformation.
The deeper change is not how fast code is written, but who is responsible for what, and what work actually matters inside a product pod.
To understand this shift, it helps to look at three phases of evolution and examine what each role actually does in each phase.
Phase 1: Before AI — Code-Centric Pods
In the pre-AI world, pods were organized around producing code.
Product Owner (PO)
The PO's primary output was documentation:
- requirements
- user stories
- acceptance criteria
- edge cases written in prose
Specifications were incomplete by nature, but humans compensated. The PO relied on engineers to interpret ambiguity during implementation.
Tech Lead (TL)
The TL translated requirements into architecture:
- designing systems
- making tradeoffs explicit
- reviewing code for correctness and style
- filling in gaps left by specs
Much of the system's real design lived in the TL's head.
Engineers
Engineers were the main producers of value:
- writing code
- interpreting specs
- resolving ambiguity
- encoding business logic directly into implementations
Their understanding of the system was embedded in the code itself.
QA
QA came late in the process:
- manually testing features
- validating that the system roughly matched the specs
- finding regressions after the fact
Tests existed, but they were rarely complete or authoritative.
In this phase, code was the primary artifact.
Phase 2: The Transitional Phase — Personal AI Assistants
This is the phase most teams are in today.
AI enters the picture, but without structural change.
Product Owner (PO)
The PO still writes specs, but notices new issues:
- AI struggles with ambiguity
- requirements are interpreted differently depending on prompts
- undocumented assumptions break quickly
Specifications become less reliable, but still dominate the process.
Tech Lead (TL)
The TL now faces new challenges:
- engineers use different AI tools
- AI-generated code varies in style and structure
- architectural consistency erodes faster than before
More time is spent reviewing and correcting AI output.
Engineers
Each engineer uses their own AI:
- different tools
- different prompts
- private context
- invisible reasoning
Productivity spikes, but predictability drops. Engineers supervise code generation rather than writing everything manually.
QA
QA feels the impact first:
- regressions appear in unexpected places
- AI breaks old behavior it doesn't "remember"
- undocumented constraints are violated
Manual testing increases, but it does not scale.
In this phase, speed increases but shared understanding declines.
Phase 3: The Future — Shared Agents and Behavior-Centric Pods
In the third phase, AI stops being a personal tool and becomes shared infrastructure.
This changes every role in the pod.
Product Owner (PO)
The PO moves away from producing large documents.
Instead, the PO focuses on:
- defining outcomes
- clarifying constraints
- specifying behavior through examples
- collaborating on acceptance tests
The PO's contribution shifts from prose to precision.
Tech Lead (TL)
The TL moves away from constant code review.
Instead, the TL becomes:
- guardian of architectural boundaries
- owner of system invariants
- curator of rules that AI agents must follow
- designer of constraints rather than implementations
Architecture becomes explicit and enforceable.
Engineers
Engineers are no longer primarily code producers.
They focus on:
- designing behavior precisely
- writing and refining tests
- orchestrating shared AI agents
- reviewing generated changes
- handling edge cases and correctness
The core skill shifts from writing code to controlling systems.
QA
QA undergoes the largest transformation.
QA becomes:
- owner of the test suite
- guardian of behavioral coverage
- author of acceptance tests
- defender of historical requirements
Manual testing fades.
Tests become the executable contract.
The Big Shift: From Producing Code to Defining Truth
Across the three phases, one change is consistent:
Pods move away from producing code and toward defining behavior.
- Code becomes cheap
- Tests become expensive
- Precision becomes the bottleneck
Documentation loses its role as a source of truth:
- it is ambiguous
- it becomes outdated
- AI cannot reliably interpret it
Tests take over because they are:
- unambiguous
- executable
- enforceable
- capable of preserving old requirements
To safely use AI, test coverage must approach 100% for behavior that matters — not as a metric, but as a necessity.
What Pods Optimize for in the AI Era
Before AI, pods optimized for:
- code throughput
- developer velocity
- implementation efficiency
After AI, pods optimize for:
- correctness
- stability
- shared understanding
- controlled change
The pod is no longer a factory for code.
It is a system for defining, validating, and evolving behavior.
Teams that understand this shift will scale AI safely. Teams that don't will move fast — and quietly break everything.
Related content
Explore the framework
This article discusses how product pod roles evolve with AI adoption. The State-Based Collaboration Framework provides a structure where behavior is explicitly defined through states, transitions, and policies — making systems more testable and maintainable as AI becomes central to development.
View the framework