The pair owns the change. The pod supports it.

  1. 01Agree intentProduct and the engineering pair settle the behavior
  2. 02Generate and inspectEngineers direct bounded agent work; QA challenges cases
  3. 03Transfer the practiceCoaches help a receiving pod apply the playbook
FrameworkThe sponsor protects time. People retain responsibility for decisions, quality, and release.

Take a small request: let a workspace administrator invite a colleague. An agent can produce an endpoint, a form, and tests quickly. The team still has decisions to make. Who is allowed to invite? What happens if the address already belongs to a member? Does a successful response mean the email arrived, or just that delivery was queued?

Those questions shape the implementation. They also explain why an AI-assisted team needs product, engineering, and quality working together early. Waiting until the code review to settle them makes every generated file a little more expensive to change.

Start with a pod that can make decisions

The program starts with two pilot pods. Each has two engineers, a 0.5 Product Manager allocation, a 0.5 QA Engineer allocation, and a 0.5 Program Manager allocation. A coach and sponsor support both pods. See the starting team structure.

Half-time allocations need actual calendar space and named people. Agree when product and QA can join the design discussion, who answers questions during delivery, and how to handle an unavailable reviewer. A staffing diagram cannot settle those arrangements.

  • Product Manager: decides the intended customer behavior, priorities, and acceptance boundaries.
  • Engineers: turn that intent into a specification, direct bounded agent tasks, inspect changes, and own the technical result.
  • QA Engineer: challenges assumptions, identifies failure paths, and checks whether the evidence supports acceptance.
  • Program Manager: coordinates protected time, dependencies, review sessions, and follow-through.
  • Coach and sponsor: the coach helps the team improve its practice; the sponsor protects capacity and resolves organizational blockers.

Work through one invitation together

At the deep standup, product decides that only administrators may invite people. An existing member should receive a clear response without another invitation. QA adds the awkward cases: an expired invitation, a repeated request, and an administrator trying to act in another workspace.

The engineers trace the existing authorization and email paths. They write a short specification with explicit responses and tests. An agent can then draft the bounded change, propose negative tests, or investigate a failing check. The engineers inspect the diff and run the checks; QA reviews whether those checks cover the agreed behavior.

If the generated code says “email sent” when it has only queued delivery, somebody needs to catch that distinction. Product confirms the wording, engineering corrects the response, and QA checks the failure path. The person accountable for release still makes the release decision under the team's existing safeguards.

Give engineers time to understand the result

Engineers need room to explain why a change works, including what the agent misunderstood. That takes time for specification, investigation, and review. Filling every saved coding hour with another ticket can leave the team with more output than it can confidently accept.

Look at accepted work, rework, and defects together. If generation gets faster while review queues grow, adjust the size of each change or the availability of reviewers before expanding the workload.

The next pod should be able to carry it

During Scale, the receiving pod uses the playbook on its own ticket. The original pod coaches, observes, and answers questions without taking over implementation. Every place the receiving pod gets stuck is a useful edit to the playbook.

That handoff gives the program a practical finish: another team can explain and use the approach. Read our coaching approach to see how we help your team work through reviews and decide what needs another attempt.