I've always said human time is more important than machine time. If it can be automated, it should be automated.
Obviously this comes with all kinds of qualifiers, but generally, when it comes to the tasks around building, maintaining, and operating enterprise software, it's a pretty good rule of thumb.
We've long had a set of tools to do this, from shell scripts to sophisticated orchestration systems. That was traditionally programmatic machinery with clear boundaries on where it worked well: if it relied on unstructured input, you were probably going to have a bad time.
But, we now have a new component to add to our chain that can deal with this: agents. They are excellent at extracting structured output from whatever you throw at them. They can reason about how to deal with ambiguous next steps to achieve a goal. And they can call tools to verify their work.
This has created a tsunami of code. We give coding agents a natural language specification, which eventually turns into tested code. Agents scale up and get faster, and we get more code.
Traditional software development pipelines handle code as an artifact that needs to be tested, and this is a great example of established process automation. We have unit tests, integration tests, automated browser tests, etc. But we've built our pipelines around human code volumes and we're starting to see them stretch to, or even past, the limit.
Anthropic is (unsurprisingly) scaling automated code generation at a massive rate, and they're feeling it. Their recent blog post describes what it looks like when you hit a wall, even when you stretch the systems as far as you can.
Their engineers ship 8x as much code per quarter as they did from 2021-2025, and Claude writes 80% of it. Test volume went up 10x. CI jobs went up 25x in six months. And notice that the workarounds worked less: throw hardware at it, 70 days; shard, 29; daily restart, less than one day. Each fix bought less time.
Even at my small scale, I can see the elements of what they describe in my own CICD pipeline. I've started doing similar dynamic optimization to try to stretch things out and speed my builds along. Time is money, literally true when everything runs on rented compute.
But I think there is yet another place to optimize: overlap. Many of my tests are written by LLMs, and they are verbose. A lot of the work looks independent, but when you follow the logic chain you find they're examining the same underlying facet.
Some overlap is fine as a safety net, but beyond a certain level two tests that catch the same thing are just a single test that you pay for twice.
Agents like objective measures, so I use the Overlap Ratio. Count the defects caught by more than one test, divide by the total caught by all of them. Every test catching the same things is a 1. Every test catching something unique is a 0. In my own practice, anything above 0.3 means I'm probably paying for coverage I already have.
More details are in my full writeup.
This approach has allowed me to optimize my CICD suite not just by scaling and refactoring, but by having an ongoing, objective measurement that I can hand to agents to optimize. I don't need to spend my time on it, because human time is more important than machine time.