The implementation era is ending
Something genuinely strange happened to software engineering in late 2025, and I don't think we've fully reckoned with it yet.
I work as a site reliability engineer at a major healthcare system. My job is to keep platforms running, manage AWS costs across a multi-account environment, automate operational workflows, and chase down the kind of problems that never show up in marketing slides. It's deeply practical work. I spend a lot of time looking at dashboards.
For most of my career, the thing that limited my team's output was implementation throughput. How fast could humans write the code, test it, deploy it, debug it. That was the binding constraint, and most of the methodology we built (Agile sprints, DevOps pipelines, CI/CD, observability stacks) was tuned to it. The faster you could turn an idea into running production code, the faster you shipped.
That constraint isn't binding anymore. It started slipping in 2023. It broke definitively in late 2025.
In January 2026, four Anthropic engineers shipped Cowork, a general-computing agent product, with the entire codebase written by Claude Code itself in about ten days. The Stripe team migrated 10,000 lines of Scala to Java in four days using the same tool, work originally estimated at ten engineer-weeks. METR's measurements of frontier agent capability show the length of tasks AI can autonomously complete doubling every four months on the general benchmark, and every three months on the software-engineering-specific one. These aren't isolated data points. They describe a transition, and we're inside it right now.
Here's the framing I've been working on. Every era of software engineering has been defined by whichever cost was binding at the time. Waterfall was the right answer when change itself was expensive (slow compilers, physical media releases, integration testing measured in weeks). Agile was the right answer when human coordination was the expensive part (requirements drifting, customers absent, linear plans failing). DevOps was the right answer when delivery friction was the bottleneck (handoffs between Dev and Ops, manual deployments, environments diverging from production). Each methodology answered its era's binding cost. Each one is preserved, mostly, in the eras that followed.
What's happening now is that the cost of implementation, the historical bottleneck of software engineering, is collapsing along a measured exponential. The new binding constraint, the one becoming visible in every team I talk to, is verification. How do you know what an agent produced is correct? How do you orchestrate multiple agents toward an outcome that satisfies the original intent? How do you express intent precisely enough that an agent can act on it without supervision at every step?
Those are different questions than the ones Agile and DevOps were built to answer. They need a different methodology layered on top.
I spent some time over the last few weeks writing a paper that tries to make this case rigorously. It's titled Software Engineering 3.0: The Rise of Orchestrated Engineering, and it's the foundation document for everything I plan to write here. It draws on the measured trajectories of AI capability, the structural inversion of Brooks's 1986 essence/accident distinction, the limits of Agile's assumptions under AI-native conditions, and a five-year projection of when work-week and work-month autonomous task horizons become reliable. It also catalogs the failure modes (specification ambiguity, verification gaming, agent self-misreporting, the lethal trifecta, compounding error in long chains, skill atrophy, verification ceilings), because no paradigm is complete without an honest account of how it fails.
This publication is where I'll be working out the implications. Some posts will be technical: verification engineering patterns, orchestration topologies, specific failure modes I've seen in production. Some will be organizational: how engineering teams should restructure, what skills get more valuable, why Gartner predicts 40% of agentic AI projects will be canceled by the end of 2027 and what the surviving 60% look like. Some will be reflective: what's worth preserving from Agile and DevOps, what I think the field got wrong, where I'm uncertain.
The cadence will be every two weeks, with shorter posts in between when something worth saying shows up.
The thing I have that most commentators in this space don't is real ops context. A healthcare system with regulatory constraints. A team that ships production code every day. AWS bills that have to come in under budget. An honest view of what works and what doesn't when you try to apply this at scale. I'm a practitioner, not a researcher. That's the lens.
The implementation era is ending. What replaces it is being figured out right now, by real engineers in real teams. I'd like to be one of the people who helps figure it out, and I'd like to think out loud about it here.
If you read the paper and want to talk, my email is bcwilson at bcwilson dot com.
Brandon