How I run a team of AI developers with XP discipline
The guiding principle
Autonomous execution, not autonomous approval.
Agents plan, implement, test and integrate. Humans decide what ships.
Where it came from
Five stages since early 2025
01
A board the agents walked
Jira, aider and n8n. Agents moved tickets; I reviewed markdown plans, not running code.
02
Real work, on my machine
Three to five agents on a real codebase, verified end to end against the whole system locally.
03
Agents check their work
My own agents; one in the browser, validating against the running application.
04
Parallel and test-first
Agents in separate browser tabs, each on its own branch, building full-stack apps.
05
The fleet
The same process on separate compute instances, on a laptop or in the cloud, each with a complete environment.
Constant at every stage: human direction → agent execution → human review → merge.
Who does what
A human owns it; agents execute
Role
Responsibility
Me, the engineering owner
Own the outcome, set priorities and architecture, approve releases
Terminal agent
Shape requirements and design; choose developers or a manager
Manager (optional)
Plan, delegate, launch and monitor developers, summarize
Development agent
Implement in a complete environment, validate, hand off a PR
Integrator
Test multiple PRs together across changes or repositories
Human team
Normal peer review and merge
When something fails, the manager reports it and waits for my direction.
Test-first, in a complete running system
Passing tests is not the definition of done
Red first
Tests before code
Agents write tests for the intended behavior. A RED check confirms they fail before implementation begins.
Run it
Exercise the change
The agent starts the application, uses the affected feature, inspects failures and confirms it works end to end.
Stay fresh
Disposable environments
Code refreshes and rebuilds before work starts. A freshness check blocks work on a stale checkout.
The infrastructure is replaceable: laptops, VMs, containers or cloud. What matters is a runnable, testable system.
Rotating between initiatives
The limit is my attention, not agent capacity
1–3
initiatives at a time, while staying closely connected
“What are we working on? What’s next?”
How I reconnect each morning. Tickets, PRs and persisted state let the agent restore context.
Attention scales with uncertainty: routine work gets a check-in; hard work gets one-on-one pairing, sometimes for a whole day.
Tested handoffs
A PR is evidence to check, not a claim to trust
Every PR records
Self-review and corrections
What was tested in the running system
Results and implementation notes
Ticket updates and saved state
PR bundles, for multi-PR work
Pin each PR’s exact revision
Apply them together in one environment
Rebuild and run the integrated system
Run integration and health checks
Reject incomplete combinations
A body of work isn’t ready for team review just because every agent reports its own task is done.
One hard sprint
Writing code was no longer the bottleneck
~20
PRs still waiting for review at the end of one two-week sprint
If PRs wait anyway, put more into each one.
AI-assisted review points out where to focus
I review every PR myself
Each PR shows full-system end-to-end evidence
Agent-guided review for the team, who still read the changes
What review is for
“Working with an AI agent is like working with an extremely talented engineer who doesn’t know the domain.”
What slips through
A business rule, an unstated expectation, a reason things are done a certain way. The code is usually good.
A recent miss
An agent added a parameter to functions that shouldn’t have it. I reviewed the shape and missed it; a teammate caught it.
What changed
Code guardrails for that case, new rules for the agents, and I now slow down and read every line.
The workflow
Eight steps from request to production
Orange outline: findings loop back here
01
Describe
From existing tickets or a design discussion.
02
Implement, test
Each instance builds, then tests end to end in its own system.
03
Report
Manager reports with PR links; failures wait for me.
04
My review
Fleet review shows where to look; I read every PR.
05 · loop
Fix, retest
Findings addressed; each PR retested end to end.
06 · loop
Test together
Multi-PR work runs as a combined bundle.
07
Team review
PR links go to the team channel. Findings return to step 5.
08
Merge, deliver
Validate in dev and QA; I approve the production gate.
What a manager update looks like
Two paragraphs, most of the method
Manager status, identifiers replaced
The dry run passed end to end, with the red check reporting 8 failed and 159 passed against build. I’m posting the results on PR #[A] and noting the branch-resume behaviour in memory. … The follow-up box for #[B] is on the right base: its work tree is cut from [commit], the PR’s head. … That run includes an on-box reproduction of the proxy error before and after the change, so I expect it to take … roughly forty minutes.
Evidence, not claims
Real red-check counts, posted on the PR.
Real-system testing
The bug is reproduced before and after the fix.
Freshness
Follow-up work starts from the exact commit.
Learning
It records what it learned for future runs.
Rotation support
It says how long the next step takes.
Retrospectives built the fleet
One recurring question
“What challenges did you run into during this build session, and what changes in the environment would make things easier for you?”
What improves
Provisioning, code refresh, build scripts, test automation, developer tools and the AGENT.md guidance agents read.
Who decides
I start the retrospective, choose the improvements and direct the work. Agents don’t govern their own environment.
XP, adapted
How XP maps onto this
Established: test-first and rotation. The rest are goals.
XP practice
How it shows up
Pair programming
AI drives; I navigate design, intent and review
Pair rotation
I switch among AI partners while each works on its own
Test-first
Tests for intended behavior first, then the running system
Small releases
Independently meaningful, verifiable slices
Continuous integration
Validated individually and as combined PR bundles
Feedback
Agents exercise changes in the running app
Collective ownership
Agents work across repos and review colleagues’ PRs
Simple design, refactoring
Grown from real needs; refactoring has to be directed
Retrospectives
Agents say what impeded them; the environment improves
Sustainable pace
Applies to the human: one to three initiatives at a time
In practice
Output is a side effect of small slices
6+
PRs per working day in a typical month, across more than a dozen repositories
Next day
Most PRs are reviewed and merged by the end of the next day
~150
Lines in the median PR over the last 60 days, tests included, across about 4 files
~$70
A month for my own fleet: inference, Claude Code and AWS, with agents on my laptop
PR volume isn’t the point. The right measure is vertical slices of value delivered; PRs are what most organizations still count. Small PRs get read; large ones tend to get rubber-stamped.
What the agents do poorly
Four weaknesses that need my attention
Stacked PRs
A merge can collapse a stack and lose the work above it. The manager now backs up first and keeps branches.
Drift
Agents drift toward what’s simplest now. One removed a Spark and Delta Lake build because Postgres handled the demo data.
Compaction
Long sessions get summarized and details vanish, even “commit and push.” I found three commits sitting unpushed.
Abstraction
Ask for ten similar things and get ten implementations. Refactoring still matters; it just has to be directed.
What went wrong: requirements, not code
Agents verify the software does what I specified. People who know the domain tell me whether it’s the right software.
When I misunderstand a requirement, the agents build the wrong thing well.
What others can adopt
Start with one agent and one working environment
01
Treat the agent as a pairing partner, and keep a human technical owner.
05
Test related changes together before merge.
02
Give it a complete, runnable system. Work test-first and exercise every change in it.
06
Keep human review, failure decisions and release approvals explicit.
03
Keep tasks small enough to validate and hand off as reviewable PRs.
07
Rotate among AI partners; recover context with terminal titles and “What’s next?”
04
Record coordination, notes and test evidence in durable work items.
08
Ask agents what slowed them down, improve the environment, repeat.
More agents don’t automatically produce better software.
Engineering discipline, working environments, feedback loops and accountable leadership are what make parallel AI execution useful.