# Your Team's Agents Are All Shipping to the Same Code at Once - Patrick Debois, Tessl

## Executive summary

The talk outlines the shift from serial Continuous Delivery (CD) to Concurrent Delivery (CD) in modern software factories, driven by the use of multiple human developers and AI coding agents. The core challenge is managing high concurrency—where many agents simultaneously merge to the `main` branch—which traditionally slows down CI/CD pipelines due to conflicts and required rebasing. Solutions involve advanced planning techniques, such as splitting work using AST graphs, implementing dedicated work trees, and utilizing speculative merge trains to maintain flow and reduce human review bottlenecks.

## Key takeaways

- The Shift to Concurrent Delivery: As factories become 'multiplayer' (multiple agents/people collaborating), the system must transition from a serial flow to a concurrent one. This requires designing for both people and agents to work together on the same codebase.
- Managing Merge Conflicts and PR Volume: Multiplayer factories lead to a factor of 10 increase in Pull Requests (PRs) and merges, increasing the risk of conflicts and slowing down CI/CD because all PRs must rebase and rerun tests.
- Advanced Concurrency Strategies: To mitigate conflicts, strategies include: 1) Splitting work granularly (e.g., using AST graphs to define tasks); 2) Using dedicated 'work trees' for context isolation; 3) Implementing 'speculative merge trains' to pre-check compatibility of multiple PRs.
- Improving Human-Agent Collaboration: Agents are evolving beyond simple coding to participate in planning and review. Features like agents joining chats and maintaining a shared 'decision log' allow non-engineering roles (e.g., marketing, support) to contribute and track requirements, reducing reliance on manual intervention.

## Technical details

- Concurrent Delivery vs. Continuous Delivery: Concurrent Delivery is the necessary evolution of CD to handle multiple, simultaneous contributors (human and agent) working on the same codebase.
- Work Isolation and Planning: To manage concurrency, agents can be given isolated environments (work trees) and context (API snapshots, database snapshots) to prevent external world impact during development. Work can be planned using techniques like the AST graph to determine optimal work splits.
- Conflict Resolution and Merging: Advanced systems aim for 'smarter' merging that goes beyond line-by-line code comparison. They can merge by function and even predict incoming changes, allowing the system to adapt code proactively (thinking in concurrency instead of serially).
- Risk-Based Review and Testing: Review processes are shifting from solely focusing on code quality to assessing risk. Teams can categorize changes by impact (e.g., documentation vs. authentication) to determine the appropriate level of human review, potentially using gradual releases or automated checks.

## Practical implications

- Architectural teams must plan for concurrent development from the outset, moving beyond simple linear CI/CD pipelines.
- Implement tooling that supports work isolation (e.g., dedicated work trees) to allow agents to work without impacting the main branch.
- Adopt speculative merge trains to proactively test the compatibility of multiple PRs before they hit the main branch.
- Design the factory to capture and utilize a shared 'decision log' to track context and decisions made by both humans and agents.

## Topics

Concurrent Delivery, Software Factory, AI Agents, CI/CD Pipelines, Codebase Management, Software Architecture, Patrick Debois, Tessl, Concurrent CD Research

Source: https://www.youtube.com/watch?v=fTUinMqA1XQ
