CODE IN TOKYO

Waterfall comeback? End of agile? What "development" means in the AI era

Lately, since I started seriously embedding AI agents into my development workflow, something has been on my mind.

Could it be that the era of agile is starting to end?

Of course, this isn’t to say Scrum disappears or anything that simple.

But the “let’s just build and figure it out as we go” style of development becomes pretty dangerous in the AI era.

AI is “blazing fast” but doesn’t grasp “intent”

Agile worked between humans because humans can fill in ambiguity.

We read between the lines.

But AI doesn’t.

AI is incredibly capable, but at its core it is “a machine that produces the most plausible thing within the context it was given.”

So when the spec is ambiguous, it goes off the rails.

The worse problem is that even when it goes off the rails, what comes out still “kind of works.”

The era of mass-producing “working garbage” at high speed

In the past, even with messy design, human implementation speed was slow, so the damage was limited.

Not anymore.

Hand it to AI, and it will spin up

all in one go.

So if the design is off, the entire system gets built — fast, and in the wrong direction.

That’s what’s scary.

And AI doesn’t push back.

A junior engineer might say “wait, isn’t this design weird?”

AI just executes the spec, calmly amplifying mistakes at scale.

So is waterfall back?

Here’s the funny part — once you start saying “let’s nail down the spec first,” it suddenly looks a lot like old-school waterfall.

In fact, recent AI-driven development really does flow like this:

But there’s one decisive difference from the old waterfall.

Old specs were “dead paper”

Old spec docs started rotting the moment they were written.

PDF’d, no one reads them, no one updates them, eventually they drift from the actual implementation.

That’s why people hated them.

Today’s specs are different.

AI reads them directly.

In other words, specs are starting to become “executable data.”

For example:

Neither is just documentation.

They are constraints on AI itself.

The AI era favors “spec-driven development”

What I’m sensing lately is that AI-era development is a hybrid of two flows.

Quick terminology check.

These two are not opposing concepts.

In the AI era, they combine.

That’s the picture.

Splitting roles looks like this.

RoleWhat they do
AIImplementation, fixes, tests, generation
HumanDesign, constraints, separation of concerns, quality definition

AI is the engine.

Humans lay the rails.

Agile isn’t going away

Don’t get this wrong — agile itself isn’t disappearing.

If anything,

these mindsets matter more in the AI era.

But “vague design is fine” no longer holds.

In the past humans filled the gap through conversation. AI cannot.

So domain design, separation of concerns, naming, boundaries, constraints — the “logical skeleton” becomes critically important.

Engineering moves from “implementation” to “definition”

What rises in value going forward isn’t “speed of writing code.” It’s

that side.

Machine code → high-level languages → frameworks → cloud → AI: implementation details have always been getting abstracted.

And now, finally, “writing code itself” is starting to be abstracted.

In the end, what’s needed is “beautiful structure”

AI is fast.

But if the design is messy, it multiplies messy things at high speed.

That’s exactly why

these unglamorous principles, the ones we’ve been talking about for ages, are becoming critical again.

Principles that were originally for humans are starting to also be principles for AI.

In the end, what really counts isn’t clever prompting, it’s

“can you keep the structure clean?”

Maybe that’s the answer.