Waterfall Per Increment: How Agentic Coding Changes Everything

Why your AI investment isn’t paying off — and what to restructure now

Andrej Karpathy — ex-Tesla AI Director, OpenAI founding member, the guy who coined “vibe coding” — now says he’s never felt more behind as a programmer.¹

“Clearly some powerful alien tool was handed around except it comes with no manual and everyone has to figure out how to hold it and operate it, while the resulting magnitude 9 earthquake is rocking the profession.”
— Andrej Karpathy, December 2025

Theo Brown — ex-Twitch engineer, YC founder — generates 11,900 lines of production code without opening an IDE.² Neither of them looks at code anymore. This isn’t laziness — it’s the future arriving. And it’s arriving faster than anyone expected.

But here’s what most engineering leaders miss: these elite practitioners aren’t just coding faster. They’ve restructured how they work entirely. And that restructuring is why their investment pays off while yours doesn’t.

That statistic should stop you cold. The majority of developers using AI tools are going backwards. Not because AI is bad at coding — it’s remarkably good. But because organizations are optimizing the wrong constraint.

The Constraint Shifted. Your SDLC Didn’t.

For forty years, the bottleneck in software development was implementation. Typing code. Debugging code. Refactoring code. Every process improvement — from Waterfall to Agile — was designed to manage the expensive, error-prone reality of humans translating ideas into working software.

Agile won because it acknowledged that requirements discovery is iterative. Users don’t know what they want until they see it. So we ship small increments, gather feedback, and iterate. The code is the artifact we manage, version, review, and cherish.

Then agentic coding arrived, and implementation became cheap.

“GPT-3.5 alone achieves 48% accuracy on coding benchmarks. Wrapped in an agentic workflow, the same model reaches 95%. The improvement from GPT-3.5 to GPT-4 is dwarfed by incorporating iterative agent workflows.”
— Andrew Ng, on agentic workflow research⁴

Read that again. A weaker model with good architecture doubles the performance of a stronger model used naively. Architecture beats capability. Process beats power.

This is the insight most engineering leaders miss. They buy better AI tools. They give everyone Cursor or Copilot subscriptions. They measure “lines of code generated” and feel good about adoption metrics. Meanwhile, their teams are 19% slower than before.⁵

The Surgery Problem

Here’s where Karpathy’s behavior becomes instructive. When building Nanochat — an 8,000-line production system — he hand-wrote most of it. His explanation:

“It’s basically entirely hand-written (with tab autocomplete). I tried to use claude/codex agents a few times but they just didn’t work well enough at all and net unhelpful.”
— Andrej Karpathy, on Nanochat development⁶

The inventor of “vibe coding” hand-writes production code. Why?

Because AI excels at greenfield generation but struggles with surgery on existing code. When you ask AI to modify existing systems — integrate with complex codebases, refactor without breaking interfaces, add features to established architectures — it “misses bits” and “tacks on little pieces” without redesigning the whole.

This is why 65% of developers report that AI “misses relevant context during critical tasks like refactoring, writing tests, or reviewing code.”⁷ The AI is brilliant at first drafts. It’s mediocre at editing.

Waterfall Per Increment: The New Model

This brings us to the restructuring that actually works.

Agile’s core insight — that requirements emerge through iteration — remains true. Users still don’t know what they want until they see it. You still need feedback loops. You still ship increments.

But inside each increment, the economics have inverted. When code generation is cheap and code surgery is expensive, you want:

• Detailed specifications upfront — because AI’s first-pass quality depends entirely on spec clarity
• Ruthless evaluation harnesses — because you verify behavior, not lines of code
• Regeneration over patching — because fresh generation beats accumulated patches

This looks like waterfall inside each slice: detailed design, then generation, then verification. But it remains agile across slices: iterate on requirements, learn from users, adjust direction.

The Evidence Is In Your Own Data

If you’ve adopted AI coding tools, you already have the evidence. Look at these patterns:

Pattern 1: Time-to-first-working-version decreased. Time-to-production increased.

AI generates prototypes fast. But integrating those prototypes into existing systems, making them production-ready, and debugging the “almost right” outputs takes longer than before. This is the surgery problem at scale.

Pattern 2: Code churn doubled.

GitClear analyzed 153 million lines of code and found that code churn — lines reverted or updated within two weeks — has doubled since 2021. Code duplication increased 4x.⁸ AI is generating code that doesn’t stick.

Pattern 3: Senior developers are skeptical. Junior developers are excited.

Only 29% of developers now trust AI outputs, down from 40% one year ago.⁹ The drop in trust correlates with experience. Seniors have seen the surgery problem; juniors are still impressed by first-pass generation.

Pattern 4: Your fastest teams have better specs, not better prompts.

If you look at where AI actually accelerates delivery, you’ll find a common factor: clear specifications and executable acceptance criteria. The teams struggling have vague requirements and rely on iteration to discover what they want.

What Leaders Actually Need to Change

The restructuring isn’t complicated. It’s just different from what you’ve been doing.

1. Invest in specification quality, not prompting tricks

The bottleneck is now “knowing what to build” not “building it.” This means your highest-leverage investment is specification infrastructure: templates, examples, acceptance criteria, and the discipline to write them before generating code.

2. Build evaluation harnesses first

Before any generation happens, define how you’ll know it worked. Automated tests, synthetic user journeys, security checks, performance budgets. These aren’t nice-to-haves; they’re the steering wheel. Without them, you can’t tell good generation from bad, and you can’t regenerate with confidence.

3. Treat code as compiled output

The spec is your source code. The generated code is like a compiled binary. You don’t hand-edit binaries; you fix the source and recompile. Similarly, when requirements change or bugs emerge, your first instinct should be “improve the spec and regenerate” not “patch the generated code.”

“We’re moving from ‘code is the source of truth’ to ‘intent is the source of truth.'”
— GitHub Engineering Blog¹⁰

4. Redesign code review

Traditional code review assumes a human wrote the code and made human-shaped mistakes. AI-generated code has different failure modes: subtle incorrectness, context blindness, pattern mismatches. Review should focus on: Does this match the spec? Do the tests pass? Does the diff make sense? Not: Is this elegantly written?

5. Accept regeneration as normal

When a module needs significant changes, delete and regenerate from an updated spec. This feels wasteful to developers trained on code-as-precious-artifact. But regeneration is cheap; surgery is expensive. Model upgrades are free improvements if you regenerate; they’re migration costs if you’re nursing patched outputs.

The Transition Is Happening Now

In 2001, seventeen software leaders met in Snowbird, Utah and published the Agile Manifesto. The transition from Waterfall to Agile took over a decade. Agile usage increased 88% between 2002 and 2020.¹¹

The current transition will move faster. AI capability doubles roughly every 18 months. The gap between “AI-augmented teams using old workflows” and “AI-native teams using restructured workflows” is widening rapidly.

“Like in 2025, the skepticism from 1-2 years ago is gone and almost everyone (93%) expects big gains, yet almost no one (3%) is seeing the impact yet.”
— David Heiny, on engineering leader surveys in 2026¹²

93% expect gains. 3% are seeing them. The difference is workflow restructuring.

The engineering leaders who restructure now will build compounding advantages: specification libraries that improve with each project, evaluation harnesses that catch more issues over time, developers who become specification experts rather than code archaeologists.

The leaders who keep buying better AI tools without restructuring will keep wondering why their investment doesn’t pay off.

The Bottom Line

Your SDLC was designed for an era when code was expensive to produce. That era ended.

The new constraint is specification clarity and evaluation quality. Optimize for that, and AI becomes the 95% performer that research promised. Ignore that, and you’re in the 66% who spend more time fixing than saving.

Agile doesn’t die. It mutates. Each increment becomes a mini-waterfall: detailed spec, ruthless evaluation, regenerate rather than patch. Between increments, you iterate on requirements just like before.

This is waterfall per increment. This is how agentic coding changes everything.

The question isn’t whether to adopt AI coding tools. You already have. The question is whether you’ll restructure your workflow to match what the tools actually do well — or keep optimizing a constraint that no longer binds.