The Middle Isn't Disappearing — It's Being Rebuilt

There's been a lot of debate lately about the "disappearing middle" of software work.

AI coding agents can now handle much of what used to consume engineers' time: writing boilerplate, wiring systems together, translating specs into code. For some, this feels like the erosion of the core of software engineering itself. I think that framing misses what's actually happening.

We're not eliminating the middle of software work.

We're rebuilding it — at a higher level of abstraction.

And this time, it's happening fast.

The Illusion of a Disappearing Middle

Karri Saarinen has argued that AI is collapsing the traditional, implementation-heavy middle of software development. Agents increasingly turn intent directly into working code, thinning the space between idea and execution.

Addy Osmani echoed this from another angle: the best engineers were never just coders. They were clarity merchants — people who shaped ambiguous problems into something executable.

Chiradeep Vittal extended the argument further, pointing out that AI is correcting a long-standing misallocation of talent. When implementation becomes cheap, effort shifts toward harder problems: systems, constraints, failures, and tradeoffs.

And Aaron Levie reminds us this pattern isn't new. Across history, automation collapses one layer of work — and then complexity expands elsewhere. The middle disappears only to re-emerge in a more sophisticated form.

The common conclusion from all of this is often framed as:

"The middle is gone."

But that's not quite right.

The Real Shift Is Cognitive, Not Just Technical

What's actually changing is how engineers think.

Historically, software development followed an implicit cognitive order:

First thought: Make it work.

Correctness and basic functionality dominated attention.

After thought: Make it fast, safe, and reliable.

Performance, security, compliance, and operability were handled later — in reviews, audits, incidents, and postmortems.

This wasn't ideology. It was cognitive bandwidth.

When most human effort is spent writing and debugging code, everything else becomes secondary.

AI agents fundamentally disrupt this hierarchy.

When First Thought Is Offloaded, In-Thought Emerges

As engineers offload first-thought work — the mechanical translation of intent into code — something subtle but powerful happens:

They get their attention back.

Correctness and basic implementation no longer monopolize cognitive space. Instead:

• Experienced engineers become reviewers of first thought
• They validate structure, intent alignment, and edge cases
• They surface architectural dead ends earlier

This isn't deskilling.

It's cognitive reallocation.

And here's the key shift:

What used to be after thought is pulled forward into in-thought.

Performance, security, policy, and observability stop being bolted on later. They become design-time constraints.

• Security is no longer a post-hoc audit — it's designed into execution paths
• Performance isn't tuned after deployment — it's encoded into architecture
• Observability isn't an ops concern — it's embedded into system behavior
• Policy isn't documentation — it's runtime-enforced logic

This is the strongest evidence that the middle isn't disappearing.

It's being upgraded.

The New Middle Is a Decision Layer

What we're rebuilding is not an implementation middle.

It's a decision middle.

A layer focused on:

• What must always be true (policies, invariants, guardrails)
• What must be observable when things fail
• What tradeoffs are acceptable before code is written
• What autonomous systems are allowed to do — and on whose behalf

This is why identity, authorization, policy, and observability naturally converge here.

They are no longer after-thought details. They are in-thought constructs.

In an agentic world:

• Identity defines who is acting
• Authorization defines what is allowed
• Policy defines under what conditions
• Observability defines how we know what happened

Together, they form the rebuilt middle — the layer that governs autonomous execution.

History Rhymes — Again (But Faster This Time)

This isn't the first time software has gone through this cycle.

Every major architectural shift follows the same pattern:

Execution collapses. Coordination expands.

When infrastructure moved to the cloud, engineers stopped racking servers — but a new middle emerged: IAM, policy, cost controls, infrastructure-as-code.

When monoliths broke into microservices, deployment got easier — but service discovery, observability, and API gateways became mandatory.

When CI/CD automated releases, manual deploys vanished — but pipelines, rollback strategies, feature flags, and governance layers exploded.

Each time, one middle disappeared — and a new control plane replaced it.

AI is doing the same thing. It collapses the implementation middle — and forces a new one into existence: closer to intent, risk, authority, and failure.

The difference this time is speed. What took decades in infrastructure is happening in years — maybe months — with autonomous systems.

From Builders to Governors of Systems

AI doesn't remove engineering judgment.

It forces it upstream.

The engineers who will thrive aren't those who write the most code — but those who:

• Surface constraints early
• Anticipate failure modes
• Encode intent clearly
• Turn after thought into in-thought

This is not less engineering.

It's engineering at higher leverage.

Closing

The middle of software development isn't gone.

It's being rebuilt as a control plane for autonomous systems — where intent, context, identity, authorization, policy, and observability are designed together, not patched on later.

The tools change.

The abstraction level rises.

But the craft remains. As it always has.

Curious how others are seeing this shift — especially those building or operating agentic systems today.