An operating model for AI-assisted engineering

The Agent Drives,
I Navigate

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

RoleResponsibility
Me, the engineering ownerOwn the outcome, set priorities and architecture, approve releases
Terminal agentShape requirements and design; choose developers or a manager
Manager (optional)Plan, delegate, launch and monitor developers, summarize
Development agentImplement in a complete environment, validate, hand off a PR
IntegratorTest multiple PRs together across changes or repositories
Human teamNormal 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

  1. Pin each PR’s exact revision
  2. Apply them together in one environment
  3. Rebuild and run the integrated system
  4. Run integration and health checks
  5. 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.

  1. AI-assisted review points out where to focus
  2. I review every PR myself
  3. Each PR shows full-system end-to-end evidence
  4. 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 practiceHow it shows up
Pair programmingAI drives; I navigate design, intent and review
Pair rotationI switch among AI partners while each works on its own
Test-firstTests for intended behavior first, then the running system
Small releasesIndependently meaningful, verifiable slices
Continuous integrationValidated individually and as combined PR bundles
FeedbackAgents exercise changes in the running app
Collective ownershipAgents work across repos and review colleagues’ PRs
Simple design, refactoringGrown from real needs; refactoring has to be directed
RetrospectivesAgents say what impeded them; the environment improves
Sustainable paceApplies 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.

The agent drives. I navigate.

© 2026 Joseph Cava. Licensed under CC BY 4.0.

Speaker notes
Article