Agentic coding didn’t fail in the enterprise. It succeeded and stopped.

The 2025 debate is over. Agentic coding works. It refactors large codebases, writes the tests, runs inside CI and opens pull requests that pass human review. Sapkota et al. (2025) map the territory and place agentic coding squarely in structured, enterprise-grade automation, and the engineering teams we work with confirm it every week. Anyone still arguing that AI cannot write production code is arguing with last year.

And yet, in almost every enterprise we see, the agent stops at the same place: the pull request. Sometimes the release. Rarely earlier, never later. What it has not entered is the delivery lifecycle — requirements, design, integration, release, operations. Humans remain the critical path for exactly those steps, and the tooling that would hand them to agents barely exists. A Cisco pilot published on the LangChain blog in April 2026 draws the same line: coding agents work inside a single user-driven session, and moving software through the pipeline needs a control plane above them. In their own data, the human pull-request review became the bottleneck. We call it the lifecycle gap.

Two axes, not one ladder

Part of the confusion is that we talk about AI in development as if it were a ladder: assistant, then agent, then autonomy. It is not a ladder. There are two independent axes.

The first is autonomy of execution: from autocomplete to an agent that plans, edits, runs the tests and opens the pull request on its own. The second is formalisation of intent: from a chat prompt to a specification with an executable test contract attached.

Vibe coding sits low on both. Spec-driven development scores high on formalisation but hands the work back to a human. Most agentic coding tools sit high on autonomy and thin on specification: the agent is capable, the instruction is a paragraph.

Enterprise delivery needs to be high on both. The specification is a business task with an acceptance contract, not a prompt. Keep the 2×2 in mind — we will come back to it.

From 80 to 38: the number every CTO should know

Why does this matter beyond taxonomy? Because the benchmarks that made agentic coding’s reputation measure isolated tasks. Enterprise systems are not isolated tasks.

EvoClaw (Deng et al., March 2026) tested 12 frontier models across 4 agent frameworks in two settings: isolated tasks, and continuous evolution of the same codebase through a sequence of changes. Over 80% success on the first. At most 38% on the second. The failures were not random. The authors name the cause: long-term maintenance and error propagation — a small mistake in an early change compounding through everything built on it.

Continuous evolution is the enterprise workload by definition. A CRM, a billing platform, a claims system — none of them is built once. They are changed every week for fifteen years, under audit. The agent degrades on exactly the work the enterprise needs done.

That is why we say governance is a technical necessity, not a compliance preference. Without a structure that resets context, verifies every increment and keeps a human accountable at the transitions, the number you will experience is closer to 38 than to 80.

Development was never the bottleneck

There is a third reason the enterprise story ends at the pull request. Take any release in a large organisation and ask where the lead time went. Requirements clarification. Waiting for a dependency. Waiting for an environment. Review. Security and compliance sign-off. The release window. Operations handover.

Coding is usually the shortest station on that list, and the one that already had the most tooling. Agentic coding compressed the most-tooled station of the cycle. The rest of the lifecycle did not move.

For a CTO, a tool that makes a ten-percent station five times faster is worth having. It is not transformation.

Where this series is going

Our position, which we will argue over the next two months: agentic coding scales the developer. Enterprise delivery needs agents that scale the lifecycle — under the governance the business already owns. Code generation is solved enough. The lifecycle gap is not.

Next time: a one-page map of enterprise software delivery, and why every methodology we run assumes the executor is a human with judgement and a career.

Two questions for the comments. Where does agentic coding stop in your organisation — at the pull request, the release, or earlier? And what share of lead time in your last release was actually coding?

References (verified 14 Oct 2026; outside the word budget)

• Sapkota, R., Roumeliotis, K. I., Karkee, M. (2025). Vibe Coding vs. Agentic Coding: Fundamentals and Practical Implications of Agentic AI. arXiv:2505.19443, 26 May 2025. arxiv.org/abs/2505.19443. A review paper, not a measurement — cite it for the taxonomy and the enterprise placement of agentic coding, not for numbers.

• Kumar, R., Ramagopal, P. (2026). Agentic Engineering: How Swarms of AI Agents Are Redefining Software Engineering. LangChain blog, guest post by two Cisco engineers, 17 Apr 2026. langchain.com/blog/agentic-engineering-redefining-software-engineering. Vendor-hosted pilot write-up; attribute to the authors, not to LangChain as a company.

• Deng, G. et al. (2026). EvoClaw: Evaluating AI Agents on Continuous Software Evolution. arXiv:2603.13428, 13 Mar 2026; accepted as an ICML 2026 poster. arxiv.org/abs/2603.13428. The abstract states the figures as used: 12 frontier models, 4 agent frameworks, >80% isolated vs at most 38% continuous (best system 38.03%).