# Rebuilding CI for AI-Scale Commit Volume — Gautam Korlam, SonarSource

## Executive summary

The rapid increase in code generation from AI agents is overwhelming traditional Continuous Integration (CI) and review processes, which were designed for human commit rates. The talk outlines a necessary shift in engineering systems, advocating for changes that move beyond simple compilation checks. Solutions include implementing advanced CI techniques like incremental builds, caching, and sharding; automating reviews with AI first passes; and establishing robust governance policies to ensure auditability and compliance across the entire change path, from proposal to acceptance.

## Key takeaways

- The Bottleneck Shift: Traditional merge queues (like Uber's SubmitQueue) were designed for human arrival rates. When AI agents generate multiple PRs rapidly, the CI and review queues become centralized bottlenecks, slowing down the entire Software Development Life Cycle (SDLC).
- Systemic CI Improvements: To handle high volume, CI must be optimized using techniques like incremental builds, caching, sharding, and parallelization. For instance, caching outputs using a build system like Rust can reduce CI time from minutes to under a minute for incremental steps.
- Governance and Auditability: For regulated industries, compliance requires recording the entire change lineage, not just a passing CI status. This includes tracking who wrote the code, who approved it, the source of the change (e.g., automated workflow vs. human prompt), and providing explicit reasons for any overrides or skipped checks.
- Review and Approval Automation: The review process is often the biggest bottleneck. Teams should leverage AI for initial code review passes and implement policies (e.g., auto-approving low-risk dependency bumps) to prevent human reviewers from becoming the limiting factor.

## Technical details

- SubmitQueue Architecture: Uber developed SubmitQueue to test combinations of incoming commits in parallel, predicting potential conflicts and keeping the main branch healthy, a system that remains relevant today.
- CI Optimization Techniques: To reduce feedback cost, implement incremental builds, caching, sharding, and parallelization. The goal is to make the CI step itself extremely fast so that repair loops are efficient.
- Compliance and Policies: Policies must enforce rules beyond simple compilation (e.g., HIPAA, GDPR). The system must record the context of the change to ensure that the code is compliant, even if the CI passes.
- Agent Context and Repair Loops: Agents require durable context from logs and failures to prevent repeated attempts to solve the same problem, making the repair loop more efficient.

## Practical implications

- Measure the entire path from proposed change to accepted change, including recovery and accountability, rather than just focusing on code generation volume.
- Automate the approval process for low-risk changes (e.g., dependency bumps) to remove human bottlenecks.
- Shift expensive checks 'to the left' in the development cycle to catch failures when they are cheapest to fix.
- Implement mandatory record-keeping for all compliance decisions, ensuring that the 'source of truth' is preserved even as CI data expires.

## Topics

Build Engineering, Continuous Integration (CI), AI Development, Software Governance, DevOps, Compliance, SonarSource, SubmitQueue, Rust, GitHub

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