A Paper Argues AI Agents Are Killing Software Engineering as We Know It

For 50 years, software engineering has rested on one assumption: a human writes code, the code runs, and the code is the product. A new paper by Zhenfeng Cao titled "The End of Software Engineering" argues that AI agents shatter that assumption entirely. The argument is not that AI writes code faster -- it is that code itself is becoming an ephemeral byproduct of a reasoning process, not the thing being built.

The Core Problem: Complexity Doesn't Scale

The paper opens with a formal argument rooted in complexity theory. In a traditional software system, every feature, every edge case, every integration point must be explicitly encoded by a human engineer. As the system grows to n components, the number of possible interaction paths between them grows as O(2^n) -- exponentially. Human cognitive capacity, meanwhile, stays flat.

This is Brooks' "essential complexity" from The Mythical Man-Month, and decades of engineering practice -- modular design, microservices, CI/CD -- have chipped away at it without ever changing the asymptotic behavior. The ceiling is always human cognition.

Agentic systems break that ceiling. Instead of a human encoding all decision logic upfront, an LLM reasons through the problem at runtime, generates code only for the specific path it needs, and discards it when done. The model's effective capacity scales with training compute, not with how much a developer can hold in their head.

From SaaS to AaaS: The Third Shift

The paper frames this as the third major paradigm shift in how software is delivered:

• Software 1.0 (Local): Code runs on-premise. The user owns the complexity of installation and maintenance.
• Software 2.0 (SaaS): Code runs in the cloud. The vendor absorbs infrastructure complexity. Revenue model: subscription.
• Software 3.0 (AaaS -- Agent-as-a-Service): An agent autonomously operates in the cloud. The agent absorbs the complexity of understanding, building, and running. Revenue model: outcome-based.

Each shift follows the same logic: whoever is best positioned to absorb complexity does so, and everyone else is freed from it. SaaS freed businesses from server rooms. AaaS, the paper argues, frees them from having to specify how a result should be produced -- they only need to specify what result they want.

The paper also identifies why the current dominant approach -- using AI to help engineers write code faster -- is structurally limited. They call this the "AI to Software to Result" pipeline, and it has three problems: the human remains the bottleneck on every design decision, the final artifact is still a traditional static codebase with the same exponential complexity, and any change still requires traversing the full requirements-design-code-test-deploy chain.