Identifying Bottlenecks in the Software Delivery Value Stream Beyond Code Review
This article challenges the common perception that AI shifts the bottleneck from coding to code review, arguing that the true constraints often lie further downstream in the software delivery value stream, specifically in deployment batching and release processes. It highlights how focusing on improving code review throughput without addressing these deeper bottlenecks can exacerbate problems by increasing the accumulation of changes awaiting deployment. The piece encourages identifying and optimizing the real constraint to improve overall value delivery and reduce risk.
Read original on The New StackThe article critiques the prevalent notion that AI's acceleration of coding has merely moved the bottleneck in software delivery from coding to code review. Instead, it asserts that neither coding nor code review typically represents the true bottleneck in the continuous delivery pipeline. This often-overlooked issue stems from an industry-wide "visibility gap" where teams are accustomed to batching changes, making this practice seem normal rather than a problem.
The Hidden Bottleneck: Deployment Batching
The core argument rests on the observation that most teams accumulate multiple changes after code review but before deployment and user enablement. This indicates that the bottleneck is not the speed of code production or review, but rather the subsequent stages such as manual verification, cumbersome change approval, or inefficient release processes. A simple test is proposed: for any given application, count the number of changes that have passed code review but are not yet deployed and enabled for users. If this number is greater than one, the bottleneck lies downstream.
Identifying the True Constraint
Many organizations mistakenly invest in speeding up upstream processes (like coding with AI or accelerating code reviews) without realizing they are merely shifting pressure to an already constrained downstream system. The key is to identify where changes accumulate *after* code review and before they reach production. This often points to problems with deployment pipelines, testing automation, or release coordination.
Impact of AI on the Value Stream
While AI significantly boosts coding speed and the number of merged pull requests, it also increases review times and pull request sizes. However, simply approving changes faster is ineffective if they then sit in a queue awaiting deployment. This means the pressure from accelerated coding is transferred to the real bottleneck, exacerbating the problem of accumulating undeployed changes. This accumulation increases risk and delays value delivery.
- Increased batch sizes: AI's ability to generate more code faster leads to larger batches of changes awaiting deployment.
- Transferred pressure: Improving code review speed without addressing deployment bottlenecks only moves changes to the next constrained stage faster.
- Hidden queues: Downstream queues (post-code review, pre-deployment) are often invisible due to their perceived normalcy, unlike visible code review queues.
To truly benefit from AI investments and improve software delivery, organizations must identify and address the actual constraint in their value stream. This typically involves optimizing deployment pipelines, increasing automation in testing and release, and reducing the need for manual batching. Ignoring this fundamental problem can lead to failed AI initiatives and persistent delivery inefficiencies.