Developers are moving faster than ever with AI. That speed is now pushing hard against bottlenecks that were always sitting one layer up, in management.
The last few years of AI adoption in engineering have overwhelmingly focused on one layer: the individual developer, writing code faster with a capable assistant beside them. That focus made sense; it's the most visible, most immediately measurable place to apply the technology. It's also, increasingly, not where the actual bottleneck lives anymore.
When individual output climbs sharply, the constraints that used to be invisible, because they were never the tightest one, start to bind. Backlog triage doesn't get faster just because implementation does. PR review capacity doesn't scale automatically because there are more PRs to review. Sprint planning, dependency coordination, and prioritization were all built around a pace of work that AI-assisted developers have quietly outrun.
This shows up as a strange kind of organizational whiplash: teams that feel like they're shipping code faster than ever, while somehow not feeling like they're delivering meaningfully more value to customers. The code gets written. It sits in review. It waits for a decision about whether it's even the right thing to have built. The bottleneck didn't disappear, it just moved one layer up, from the terminal to the management process around it.
This is why the more interesting frontier for AI in engineering isn't just faster typing, it's applying the same capability to the layer that decides what gets built, triages what's worth automating, and coordinates work across a team. Scoring backlog items for risk and readiness, tracking execution across dozens of parallel efforts, surfacing what needs a human decision versus what can run on its own: these are management-layer problems, and they're just as amenable to AI as writing a function was.
Teams that only invest in the developer layer will keep hitting the same wall: a faster engine bolted to the same narrow pipe. Teams that extend automation into planning, triage, and coordination get something closer to a system-level speedup, where the whole pipeline moves faster together instead of just the part that was easiest to automate first.
The developer layer got the first wave of AI tooling because it was the most obvious place to start. The bigger unlock is what happens when that same capability reaches the layer that's been quietly limiting everything downstream of it all along.
Fleet Work Team
Writing on autonomous delivery
Parallel AI tasks look like free capacity, until you notice the real limit was never compute. It was how much a person can hold in their head at once.
Fleet Work Team
Teams have always leaked knowledge as people move on and memory fades. That used to be unavoidable. With AI systems that persist what they learn, it no longer has to be.
Fleet Work Team
AI can now own real chunks of the development process. The hard part was never the technology, it's the letting go.
Fleet Work Team