Donovan Crewe

Why 2026 Is The Year Software Delivery Stopped Being Human-Centric

AI breaks the assumptions the SDLC was built on

By Donovan Crewe · · Software Delivery, SDLC, AI-Native Engineering, AI Agents, Engineering Leadership

The SDLC won’t survive the AI era – not because AI writes code better, but because it breaks one of the assumptions the SDLC was built upon: engineers and solution architects learn by doing the work AI is now eliminating.

Not because AI writes code better than humans, but because the entire system was designed around assumptions that are no longer true.

For decades it has been the operating system behind software delivery. Waterfall, Agile, DevOps and Platform Engineering all built upon the same fundamental idea.

Software is built by groups of people who collaborate, hand work between one another and move through a sequence of activities that ultimately deliver value.

The specifics changed over time, but the assumption remained remarkably consistent.

Humans were the participants.

Humans gathered requirements. Humans designed systems. Humans wrote code. Humans tested applications. Humans deployed software and operated platforms.

The entire system was built around optimising how humans work together.

That assumption is now changing.

Over the past few months, several events have happened that many people are treating as separate stories. SpaceX acquired Cursor. Nvidia released desktop AI supercomputers capable of running enormous models locally. Coding assistants have rapidly evolved into autonomous agents capable of executing meaningful work independently. Enterprises have simultaneously discovered that simply giving developers AI tools does not automatically produce transformational outcomes.

These are not independent events.

They’re all signals pointing towards the same destination.

Software delivery is no longer a human-only system.

I deliberately avoid saying human plus AI because I think that framing unintentionally trivialises what’s happening. It suggests AI is another tool alongside IDEs, CI/CD pipelines and source control systems.

It isn’t.

We’ve introduced an entirely new participant into software delivery.

For the first time in our industry’s history, we have a participant that can reason across architecture, implementation, testing, security, documentation and operations simultaneously. It can operate continuously, maintain enormous amounts of context and contribute at machine speed.

The significance of this cannot be overstated.

Because once you introduce a new participant into a system, the system itself has to change.

Yet many organisations are trying to force AI into delivery models that were designed long before AI existed.

That’s why there’s so much friction right now.

Most organisations expected a productivity revolution. They gave developers access to coding assistants and assumed output would multiply overnight. Instead, they discovered that faster code generation doesn’t automatically translate into faster delivery.

Developers may be moving quicker, but approvals still exist. Requirements are still ambiguous. Teams still operate in silos. Governance still happens at the end of projects. Organisational knowledge is still fragmented across systems.

The technology evolved much faster than the operating model—and faster than the talent model..

The truth is that the AI conversation has never really been about code.

Code was simply the first visible outcome.

The real transformation has always been about how work happens...and who develops the judgment to oversee that work.

When you start looking at software delivery through that lens, you begin to see why our existing models are starting to show their age.

Take the traditional SDLC as an example.

Even Agile, arguably the most successful software methodology of the last twenty years, still largely follows a sequential model. Requirements become designs. Designs become implementations. Implementations become tests. Tests become deployments.

Yes, the loops became smaller and faster, but the underlying system remained intact.

AI doesn’t naturally work that way.

The moment intent exists, AI can immediately begin contributing everywhere.

A requirement can generate architecture suggestions. Those architectures can generate implementation approaches. Those implementations can generate tests. Security concerns can be surfaced immediately. Documentation can be created in parallel. Observability strategies can be proposed before a single line of production code exists.

The lifecycle stops being sequential.

It becomes concurrent.

This is where I think the industry is still underestimating what’s happening.

Everyone is focused on replacing tasks.

The bigger story is that we’re replacing assumptions.

For decades, one of our core assumptions was that software delivery had to be broken into phases because humans naturally specialise and coordinate through stages of work.

AI changes that dynamic entirely.

This doesn’t diminish the importance of human expertise. In fact, it elevates it.

Human judgement becomes more valuable, not less.

The role of engineers becomes more important, not less.

What’s changing is where we apply our energy.

Engineers will spend less time producing code and significantly more time producing clarity.

Clarity of intent.

Clarity of architecture.

Clarity of constraints.

Clarity of governance.

Clarity of validation.

I increasingly think the engineer of the future will look more like an orchestrator than a traditional software developer.

We've become very good at describing the future engineer, but we've spent almost no time asking how we're going to produce them.

Ironically, this makes strong engineering fundamentals more important than ever before.

AI amplifies capability.

Strong engineers become dramatically more effective because they already understand systems thinking, trade-offs and architectural patterns. Weak engineering practices, however, become exponentially more dangerous because AI can scale those mistakes at machine speed. The irony is that AI is removing many of the experiences that created them.

This is why I believe organisations focused purely on AI tooling are missing the point.

We’re moving towards a world where engineering judgement itself becomes infrastructure.

For years, infrastructure meant compute, storage and networking.

Tomorrow, infrastructure will also include reasoning.

Every organisation will own some combination of models, organisational memory, agentic systems and governance mechanisms that become deeply embedded into how work happens.

In many ways, we’re rebuilding software factories.

Not the rigid factories we deliberately left behind during the Waterfall era, but a new kind of factory built around intelligent systems.

Intent enters the system.

Knowledge is retrieved.

Architectures are proposed.

Risks are surfaced.

Tests are generated.

Implementation happens.

Humans intervene where strategic judgement is required. The limiting factor won't be AI capability. It'll be the number of people capable of knowing when to intervene.

The output is no longer code.

Code is becoming abundant; judgement becomes scarce.

I think that distinction is one of the most important strategic shifts leaders need to understand.

The winners of the next decade will not be the organisations that generate software the fastest.

They will be the organisations that establish trust in machine generated software the fastest.

Because judgement that builds trust is ultimately what scales AI.

Not models.

Not tokens.

Not prompts.

Trust.

This is also why I don’t believe the future is AI-powered Agile or AI-powered Scrum. Adding agents to existing methodologies feels increasingly similar to putting a faster engine into an ageing vehicle.

The engine isn’t the problem anymore.

The vehicle is.

We need entirely new operating models that can deliberately manufacture engineering judgment.

For decades the SDLC accomplished both at the same time. AI is separating those two responsibilities.

This is where my thinking around AGE began.

The AGE lifecycle doesn’t start with phases.

It starts with a different assumption.

Software delivery is no longer a sequence of human activities. It’s a continuously evolving system of orchestration, validation and governance shared between humans and intelligent systems. It's a system for producing judgment in a world where experience is no longer accumulated naturally.

Agents execute.

Governance protects.

Engineers elevate.

The more I think about it, the more convinced I become that we’re entering a new industrial era for software engineering.

Cloud computing changed where software runs.

AI is changing how software gets built – making it vastly more abundant.

Years from now, I don’t think we’ll look back at 2026 and remember it as the year AI became good at writing code.

It will be the start of engineering judgment becoming scarce.