AI-Driven Software Delivery: Merge Efficiency and Team Dynamics
CircleCI CTO Rob Zuber analyzes how AI is widening the gap between high-performing and median software teams. Key insights include the new 'merge efficiency' metric, the shift from documentation to executable code, and the restructuring of engineering teams to reduce handoff overhead.
The Widening Gap in AI-Driven Delivery
The integration of AI into software development is not merely accelerating output; it is amplifying existing organizational strengths and weaknesses. CircleCI’s latest data reveals a stark divergence between leading and median companies. While both groups are generating more pull requests and consuming more compute resources, only high-performing organizations are translating this volume into shipped value. This disparity is best measured by a new metric: merge efficiency, defined as the number of builds on a branch required before merging to main. Leading companies maintain or improve this ratio, indicating that their AI-generated code is robust and ready for production. In contrast, median companies see a spike in failed branch builds, resulting in higher energy and token costs with negligible gains in final output.
Strategic Shifts in Engineering Practice
To close this gap, engineering leaders must rethink traditional workflows. The era of static specification documents is giving way to executable code as the primary artifact. Teams are finding that reasoning about the problem while building the solution yields faster insights than writing detailed plans that become obsolete within days. This shift requires a cultural move toward 'harness engineering,' where agents are equipped with immediate feedback loops—such as local test suites and mutation testing—to validate their own work before it reaches the CI pipeline. By shifting validation left, teams reduce the friction of merge conflicts and failed builds, ensuring that AI-generated code is production-ready upon creation.
Restructuring Teams for AI Velocity
The acceleration of development cycles has rendered traditional team structures inefficient. Handoffs between product managers, designers, and engineers, which previously accounted for a manageable percentage of project time, now represent a significant bottleneck when execution time is reduced by orders of magnitude. Organizations are consolidating roles to minimize these handoffs, empowering engineers with product thinking and enabling non-engineers to contribute code directly. This trend is evident in data showing increased GitHub IDs from non-engineering roles committing to repositories. The future team structure will likely be smaller, more autonomous, and focused on systems thinking rather than specialized silos. Leaders must assess their teams not by job title, but by the ability to navigate complex, AI-assisted environments with minimal friction.
Conclusion
Success in the AI era depends on operational hygiene. Companies that treat AI as an amplifier of broken processes will see increased waste. Those that optimize for merge efficiency, shift validation left, and restructure teams for autonomy will capture the full value of AI-driven velocity.
Key insights
-
Merge efficiency is the critical differentiator in AI adoption. High-performing teams maintain low build-to-merge ratios, while median teams experience increased failed builds due to lower confidence in AI-generated code.
Impact: Organizations can use this metric to diagnose AI integration failures and focus on improving code quality and agent steering rather than just increasing output volume.
-
Traditional specification documents are becoming obsolete in favor of executable code. Teams that build prototypes immediately to reason about the problem achieve faster discovery and adaptation than those relying on static plans.
Impact: This shift reduces time-to-market and allows for rapid pivots based on real-world system behavior, enhancing product-market fit discovery.
-
AI is enabling non-engineering roles, such as designers and product managers, to commit code directly. This increases the number of contributors per project without corresponding headcount growth, altering traditional team dynamics.
Impact: Companies can optimize headcount costs and increase cross-functional collaboration by leveraging AI to lower the barrier to code contribution for non-technical staff.
-
The cost of handoffs between roles has increased relative to execution time. As AI reduces the time to build features, the fixed cost of communication and coordination becomes a dominant bottleneck, necessitating team consolidation.
Impact: Restructuring teams to reduce handoffs can unlock significant velocity gains that are currently being lost to coordination overhead.
-
AI is transforming production debugging from a manual, pattern-matching exercise into a data-driven correlation task. This allows engineers to focus on high-level systems thinking while AI handles the analysis of massive telemetry datasets.
Impact: Improved debugging capabilities reduce mean time to resolution (MTTR) and allow smaller teams to manage more complex, distributed systems effectively.
Action items
-
Implement merge efficiency tracking in your CI/CD pipeline. Monitor the number of builds per branch before merging to main to identify teams or projects where AI-generated code is failing validation.
Impact: This metric provides a clear, data-driven indicator of AI integration health, allowing leaders to target specific areas for process improvement.
-
Shift validation left by integrating test suites and mutation testing directly into the AI agent workflow. Provide agents with immediate feedback on code quality before they submit pull requests.
Impact: Reducing failed builds at the source decreases token waste and CI resource consumption, improving overall merge efficiency and developer experience.
-
Audit your team structure for excessive handoffs. Identify roles where capabilities can be consolidated to reduce communication overhead, particularly between product, design, and engineering.
Impact: Minimizing handoffs ensures that the speed gains from AI are not negated by coordination bottlenecks, leading to faster feature delivery.
-
Train engineers on 'harness engineering' techniques. Encourage the use of goal-seeking agents and immediate feedback loops to validate code during the development process rather than after submission.
Impact: This practice increases the confidence in AI-generated code and reduces the time spent on debugging and rework, accelerating the development cycle.
-
Leverage AI for production debugging by integrating it with observability tools. Use AI to correlate telemetry data and identify root causes in complex distributed systems, freeing engineers for strategic tasks.
Impact: Enhanced debugging capabilities improve system reliability and reduce the cognitive load on engineers, allowing them to focus on high-value architectural decisions.
Quotes
“How many builds on a branch does it take before you can merge something to main?”
“The sort of median company is creating a lot more builds on a branch because their work is broken and it fails and it fails and it fails and it fails and then they finally get it merged into main”
“I find that I can open up Cloud Code or Codex or like a coding agent, which is pretty much the chat bot plus writing code better. And by the time I figured out what I want to build, I've built it.”