# Your Team's Agents Are All Shipping to the Same Code at Once

Patrick Debois, Tessl | AI Engineer | 22:50

Source: https://www.youtube.com/watch?v=fTUinMqA1XQ
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/your-teams-agents-are-all-shipping-to-the-same-code-at-once
Published: 2026-11-10
Tags: agents, coding-agents, harness-engineering, software-factories, workflows

## TL;DR
- Multiple coding agents create merge conflicts, slower CI, repeated rebases, and changes that can conflict in intent even when the code merges cleanly.
- Agents need shared planning, ticket claiming, work isolation, smarter merge trains, and checks that compare the intent of concurrent changes.
- People need one shared board, decision logs, risk-based review, and a factory team that maintains agent context, skills, connections, and monitoring.

## Summary
Patrick Debois describes what changes when a software team runs many coding agents against the same codebase. Pull requests can increase dramatically, while merges trigger more rebases, repeated tests, slower CI, and higher costs. Code can also merge successfully while the combined changes violate the intended behavior. He proposes concurrent delivery, with agents dividing work more carefully, claiming tickets, announcing files they will change, and using isolated environments with their own API versions, database snapshots, and test data. Merge systems can check compatible changes speculatively and agents can reason about functions and intent. On the human side, one shared board lets engineers and other teams refine tickets with agents. Decisions should be recorded in a shared log, and review should depend on production risk. Debois also describes a factory team that maintains the coding agents, skills, context, and surrounding infrastructure.

## Key ideas
### More agents turn ordinary delivery into a concurrency problem
[00:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=0s)
Debois begins with the familiar build, test, merge, and release pipeline, then contrasts it with teams running several coding agents. As more agents work at once, pull requests increase, merges conflict, and agents can undo one another's changes. Every merge may force other pull requests to rebase and rerun tests, which makes CI slower and more costly. The queue also contains agent incidents and maintenance work for improving skills and loops. He calls the needed change "concurrent delivery": designing the codebase and pipeline for people and agents to work together routinely.

### Planning must split work before agents start coding
[03:36](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=216s)
Agents should not simply run in parallel on whatever work is available. Debois suggests dividing work by areas such as authentication and payments, then going down to files, functions, or smaller parts of a file. He says an AST graph can help identify pieces that are safe to separate. During planning, an agent claims a ticket and announces the files and changes it expects to make. Other agents can then avoid overlapping work. Work trees provide one form of isolation, while broader isolation can include a separate machine, API version, database snapshot, test data, and mocked external systems.

### Collisions need waiting, retrying, or a changed plan
[06:00](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=360s)
When agents collide, they can wait for one another, retry after the first change finishes, or renegotiate the plan so each agent takes a different part. Debois extends this beyond line-based Git merges. Agents could merge at the function level, repair a merge themselves, and adapt when they see another agent's likely upcoming change. He presents this as a move from serial changes toward systems that anticipate concurrent work rather than treating every collision as an exception.

### A clean merge can still combine incompatible intentions
[07:23](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=443s)
Debois gives an invoice example in which one change converts totals into dollar cents while another changes reporting behavior. Both pull requests can merge and pass their tests, yet the resulting report may express the wrong currency intent. The conflict is between the purposes of the changes, not between overlapping code lines. Agents could inspect whether the intentions remain consistent across several merges, then warn people or alter a pull request. Speculative merge trains could also test compatible pull requests in pairs and let independent changes proceed without waiting for every other change.

### A shared board brings agents and non-engineers into the same flow
[09:31](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=571s)
The human side of a multiplayer factory uses one task board where people can see incoming changes and work in progress. An agent can join a team conversation, collect input from several people, and refine the ticket while asking questions about tests, requirements, and expected behavior. Debois says sales, marketing, and support can use this flow to experiment or start a feature without waiting weeks for an engineer to pick up a ticket. Because the work uses the same pipeline, knowledge, skills, and loops as engineering, the result can fit the engineering process.

### People should intervene through context-rich decisions
[12:10](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=730s)
When an agent gets stuck, Debois describes a pattern from Helix ML that opens a coding IDE with the agent's exact context and files. A person can make decisions and run experiments, then hand the work back to the agent. Agents can also present a small set of choices instead of asking open-ended questions every time. Each human decision should go into a shared decision log, where people and agents can find who made it, when it happened, and how it shaped later work.

### Review should match the risk of the change
[15:25](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=925s)
Debois argues that review cannot optimize only for fewer failures or fewer pull request reviews. Agents can provide adversarial review and evidence such as screen-flow captures, videos, and test proof. The amount of human review should depend on the possible production impact. Documentation may need little review, while authentication changes need more. Some changes can use gradual release and output checks. Teams also need cheap recovery through fast restore or rollback plans, because architecture affects how much risk a factory can accept.

### A factory team will maintain the agent system itself
[19:12](https://www.youtube.com/watch?v=fTUinMqA1XQ&t=1152s)
As code production increases, marketing, support, and other groups need changes translated into language they can understand. Debois calls communication and radiating change an important part of the factory. Automation should handle routine work while routing exceptions to people with enough context to decide. He expects a factory team similar to a platform team, responsible for coding agents, shared skills, context, connections, monitoring, and the factory's own maintenance. Personal agents may eventually work inside the board and make decisions for their users.

## Notable quotes
- "These conflicts are real when you turn on a multiplayer factory." (02:29)
- "This is thinking in concurrency instead of being kind of serial in the changes." (07:00)
- "Every decision that people make actually goes onto a ledger." (14:39)
- "Automate what you can, but make sure you are able to route to a human to make the right decision with all that infrastructure." (19:12)

## Tools & references mentioned
- Tessl
- Helix ML
- AST graph
- Git
- concurrent.cd

## Who should watch
- Your team is running several coding agents against one main branch and is seeing more pull requests, rebases, CI delays, or merge conflicts.
- You are designing an internal coding-agent platform and need patterns for work isolation, ticket claiming, shared decisions, and risk-based review.
- People outside engineering are starting features with agents, and you need a shared workflow that keeps those changes aligned with engineering practices.

## Editor's note

From the pack [Software factories](https://aietalks.com/packs/software-factories):

Horthy's factory lost track of what its own code meant. Snyder needs real production cases, and Klaassen improves his process by studying what each run got wrong. Kitaru records those runs so a team can replay selected cases after changing a model, tool or workflow and check the new behavior before the factory sends it back into production.

Written by the AIE Talks editors (the Kitaru team), not by the speaker.

## Related talks

- [CI/CD Is Dead, Agents Need Continuous Compute and Computers](https://aietalks.com/talks/ci-cd-is-dead-agents-need-continuous-compute-and-computers) (Hugo Santos, Namespace & Madison Faulkner, NEA, 18:37)
- [Agents, codebases, and teams](https://aietalks.com/talks/agents-codebases-and-teams) (Aditya Khandelwal, Amazon AGI Lab, 16:57)
- [Collaborative AI Engineering: One Dev, Two Dozen Agents, Zero Alignment](https://aietalks.com/talks/collaborative-ai-engineering-one-dev-two-dozen-agents-zero-alignment) (Maggie Appleton, GitHub, 17:43)
- [Making Codebases Agent Ready](https://aietalks.com/talks/making-codebases-agent-ready) (Eno Reyes, Factory, 15:33)
- [Containing Agent Chaos](https://aietalks.com/talks/containing-agent-chaos) (Solomon Hykes, Dagger, 23:48)
