It is tempting to treat a second coding agent as a second pair of hands and simply hand it another ticket. On a shared codebase that assumption falls over quickly, and not for the reason we expected.
The expected failure and the actual one
We expected the agents to step on each other's code directly — two changes touching the same file, a messy merge. That happened occasionally and was easy to resolve. The bigger problem was slower and less visible: both agents made small, individually reasonable refactors to shared utility code, and by the time either change reached review, the other's assumptions about that utility no longer held.
What we changed
- Ticket scoping got stricter — each ticket now explicitly lists which shared files it may and may not touch, enforced the same way we enforce it for human engineers, which turned out to be the actual fix, not an AI-specific one.
- Shorter-lived branches — parallel work merges within a day where possible, rather than accumulating for a week, so the shared-file conflicts surface while they are still cheap to resolve.
- One agent, one reviewer, always — we stopped letting agent output from two parallel tasks land in the same review batch, because a reviewer context-switching between two unrelated diffs missed more than one reviewing one diff at a time.
The genuine speed gain
Independent, well-scoped tickets — a new endpoint here, an unrelated UI component there — did parallelise well, and that is most of what a small team's backlog actually looks like day to day. The failure mode was specific to shared infrastructure code, not general.
Parallelism does not remove coordination cost. It just moves it from "who writes this" to "whose assumptions about this shared file are current".
What we still do sequentially on purpose
Anything touching the data layer, the authentication path, or a shared type definition goes through one agent or one engineer at a time, with the change merged and settled before the next one starts. The cost of serialising that narrow slice of work is small compared to the cost of untangling two overlapping refactors.
Where this leaves us
Two agents on a codebase is not fundamentally different from two engineers on a codebase — the same discipline about scope and shared files applies, and teams that already had that discipline adapted with less friction than teams that did not.