The Last Great Web Framework May Already Exist

I have a habit of thinking about these things but never putting pen to paper to actually share my thoughts.

This particular thought started with a fairly simple question:

If frameworks were largely built to make software development easier for humans, what happens to them when humans are no longer the ones writing most of the code?

I don’t mean tomorrow.

And I’m not suggesting developers are about to disappear.

But it feels fairly obvious that AI is going to write an increasing proportion of software over the coming years. Not just snippets or boilerplate either, but increasingly complete features, systems and eventually large parts of applications.

So where does that leave frameworks?

Frameworks are really a human solution

Think about why frameworks exist in the first place.

They give us conventions.

They reduce boilerplate.

They stop us having to reinvent things like routing, state management, authentication, rendering, database access and all the other repetitive (and let’s be honest, sometimes annoying) bits that come with building software.

They make complicated systems easier for humans to work with and reason about.

Because humans have limitations; we can only hold so much context in our heads.

We forget APIs.

We get bored writing repetitive code.

We want sensible defaults.

We want abstractions that allow us to think about the problem we’re solving without constantly thinking about everything underneath it.

A framework is, in many ways, a way of making the machine easier for the human to work with.

But AI doesn’t necessarily have this same problem.

An agent doesn’t get bored because it has to write hundreds of lines of plumbing.

It doesn’t really care whether an API is elegant.

It doesn’t complain that something requires too much configuration.

It can work across hundreds or thousands of files, trace dependencies, generate repetitive code and keep iterating until the tests pass.

Which made me wonder:

Why would humans keep creating new frameworks primarily to improve developer experience if the developer is doing less and less of the implementation?

Maybe the framework wars just stop mattering

We’ve spent years debating React vs Angular vs Vue vs Svelte, then Next.js vs Remix, and whatever framework appears next claiming to finally fix development.

But what happens when your interaction with the whole thing becomes something more like:

Build me a multi-tenant SaaS product with authentication, billing, analytics, an API and role-based access. It needs to support this level of traffic and behave like this when something fails. At that point, do I actually care whether the AI chooses Next.js?

Or React?

Or something else entirely?

Probably not, unless it’s fitting in to an existing ecosystem using a specific framework.

What I do care about is whether it works.

I care that it’s secure.

I care that it performs properly.

I care that it can be maintained if I ever needed to step in.

The framework starts becoming an implementation detail; something happening beneath the level I actually interact with.

There is an obvious argument against this

Frameworks don’t exist only because humans dislike boilerplate.

They also provide structure:

Constraints.

Predictability.

A known way of doing things.

That matters to humans, but it probably matters to AI as well.

In fact, I believe there may even be an argument that AI could benefit from frameworks even more than we do.

Tell an agent:

Build this however you want. and you’ve given it an enormous solution space.

Tell it:

Build this using a known framework, these patterns and these architectural rules. and suddenly you’ve narrowed that space dramatically. The agent has fewer architectural decisions to make, fewer assumptions to invent and, importantly, less context it needs to establish before it can actually start building.

And context isn’t free. Those tokens rack up!

Frameworks introduce established conventions.

Known failure modes.

Existing libraries.

Documentation.

Tests.

Millions of examples of things we’ve done millions of times before..

That makes generating reliable software easier.

So I don’t think AI will simply make frameworks disappear.

If anything, in the short term I feel like I could see the opposite happening.

The biggest frameworks could become even more dominant because AI already understands them so well; they’re literally trained on them.

So it really made me think that the likes of React, Next.js, Django, .NET, Spring and the rest could become incredibly difficult to displace.

Not because developers will love them forever, but because machines already have an enormous amount of knowledge about how to use them.

So maybe frameworks become boring?

And I mean that in a good way.

Perhaps we end up with a much smaller number of mature, predictable frameworks that sit quietly underneath the software AI produces.

They become infrastructure.

Nobody gets particularly excited about them anymore.

Nobody needs a new JavaScript framework every six months.

They just work.

The interesting innovation moves somewhere else.

Which brings me to something else I started thinking about.

Are agents becoming the new framework?

Not literally.

An agent is obviously not a framework in the traditional sense.

Something still has to exist underneath it.

Software eventually needs to resolve down into real things: browser APIs, JavaScript, WebAssembly, SQL, operating system calls, bytecode, machine instructions.

But look at the abstraction layers we’ve built over time.

At one point humans interacted much more directly with machines.

Then we added higher-level programming languages.

Then libraries.

Then frameworks.

Each layer allowed us to describe what we wanted at a higher level while worrying less about what was happening underneath.

AI agents potentially add another layer.

Something like:

Human intent > AI agent > framework/libraries > runtime > machine

And once you look at it that way, another question appears.

Does the agent actually need the framework forever?

Today, almost certainly.

Frameworks give agents structure and predictability.

But longer term, I’m less convinced.

A lot of the reason we avoid lower-level APIs is because working with them directly can be tedious and difficult.

When have you known AI to care about the tedious?

If an agent can reliably build directly against browser APIs, databases, cloud infrastructure and other lower-level primitives, maybe some of the abstractions we created specifically for ourselves become less useful.

Not all of them. But some.

The distinction I keep coming back to is this:

Frameworks abstract complexity for programmers.

Agents may eventually abstract programming itself.

And if that happens, frameworks move further and further away from the person actually asking for the software to be built.

Maybe the most valuable thing isn’t the code anymore

This is probably the part that interests me most.

If AI becomes very good at producing implementations, then the important artifact in software development starts shifting.

Instead of the valuable thing being a particular .tsx file, service or repository, maybe the valuable thing becomes the description of the system itself.

Its behaviour.

Its constraints.

Its rules.

For example:

Analytics must never delay the main transaction. A user from one organisation must never be able to access another organisation’s data. If the analytics system fails, the primary service should continue operating. This data should be removed after a defined period. Those are not really implementation details.

They are statements about what the system is supposed to do.

And if an AI can generate an implementation from those requirements, test it, change it and even replace the underlying technology later, then maybe the implementation becomes increasingly disposable.

The specification becomes more important.

The ability to precisely define a system becomes more important.

Knowing what should happen becomes more valuable than knowing exactly which framework method makes it happen.

So is this the end of frameworks?

Probably not, that would be too dramatic to even suggest!

Abstractions are useful regardless of whether the thing using them is human or machine.

Frameworks also encode years of knowledge about how software should behave, and I can’t see AI simply throwing all of that away.

But I do wonder whether we’re approaching the end of frameworks being culturally important to developers in the way they have been for the last couple of decades.

The next great framework might arrive next year.

There could be ten of them.

But there’s also a possibility that the last truly important ones are already here.

Not because we finally perfected development.

But because the people frameworks were originally designed to help may gradually stop being the ones writing most of the code.

And if that happens, maybe the framework wars don’t end because somebody wins.

Maybe they end because we stop caring who won.

Originally published at LinkedIn.