We are about four years into the new AI era and patterns of the new normal have started to emerge.
We are seeing enormous amounts of copies of existing software. We are not really seeing software get better.
Let me start with what could have happened - and then what I actually see happening.
What Could Have Happened
The optimistic version is simple. AI removes the mechanical cost of writing code. The bottleneck shifts from "can we build this" to "what should we build." Developers with real understanding of software - its weight, its tradeoffs, its failure modes - finally have the time and energy to act on that understanding. We get leaner software. Faster software. Software that does not need four layers of abstraction to render a button.
The idealistic version goes further. The barrier drops low enough that people who understand problems deeply but could not previously build solutions can now build them. Domain knowledge finally beats framework knowledge. We get software shaped by the problem rather than by whatever the developer already knew how to use.
Both of those versions assume that the constraint was time. That given enough of it, quality would follow.
Now I don't think that assumption was ever true.
What I Actually See
Two things are happening, and they look different on the surface but come from the same place.
We are building frameworks. And we are building on frameworks.
These feel like separate conversations but they belong under the same roof, because most developers live on frameworks - they work inside them, they think in them, they reach for them automatically. Building a new framework is the most natural thing in the world to a developer who has spent years inside existing ones. It is familiar territory expressed as output.
Cloudflare built a Next.js clone. A working framework, demonstrably impressive, completely unnecessary. Next.js already exists. The world did not need a copy, nor a new framework at all - more on that lower in the article. But it made a great demo, a great blog post, a great proof of capability - and that is the reason.
This is not a Cloudflare problem. This is the pattern. AI gets aimed at things that look impressive fast, and frameworks look impressive fast because everyone already knows what they are supposed to be.
Meanwhile, the rest of us are scaffolding new projects on the same foundations as before, just faster. React on Next.js on Node on a managed platform with abstractions on top of abstractions, five levels deep. AI did not make that stack lighter. It just made it faster to assemble. The weight is still there. The failure modes are still there. You just got there quicker.
Frameworks exist to make writing lines faster and easier. If AI already does that - if that mechanical cost is largely gone - then building more frameworks is answering a question nobody is asking anymore. And building on them at speed is not progress. It is the same decisions, accelerated.
Frameworks Should Be Obsolete
If you build on a framework, three things happen:
- You finish your program faster than typing from scratch with zero abstractions already in place.
- Your code runs through another code that calls other functions that run through other classes and methods - which is, of course, visibly slow even on today's 5.5 GHz CPUs, 7000 MT/s RAM and 7500 MB/s SSDs.
- The program has just received a huge amount of attack surface for hacking - which is smarter than ever.
Point one was always the justification for accepting points two and three. Speed of development was the trade. You paid with performance and security and got back time.
AI can change that trade. If writing from scratch is no longer the slow part - if the mechanical cost of building without a framework is largely absorbed by the tool - then you are left with the costs and not much of the benefit. The slow stack. The inherited vulnerabilities. The assumptions baked in by someone else for someone else's problem.
Frameworks made sense when developer time was the constraint. It increasingly is not. Which means we should be seeing a move away from them - toward leaner, more direct software that actually uses the hardware it runs on.
We are seeing the opposite. More frameworks. Faster adoption of existing ones. New frameworks built as demos of AI capability, which will themselves become foundations that the next wave of developers builds on without questioning.
The abstraction compounds. The hardware keeps getting faster. The software somehow feels slower than ever.
Why Nothing Is Changing
I think there are two reasons software is not getting better.
- AI is not capable of leading the improvement.
- Most developers do not really understand software - they understand frameworks.
I suspect it is both, and probably more the second than the first.
I work with blank slates and AI coding regularly. No framework, direct instructions, building from actual requirements. It is less immediately capable than framework-assisted development - of course it is, there is no scaffolding to lean on. But with clear direction it produces good results. The AI does not impose a ceiling. The understanding of what you are trying to build is the ceiling.
When that understanding is shallow, AI fills the gap with whatever is familiar and well-documented. Which is frameworks. Which is copies of existing tools. Which is the path of least resistance dressed up as productivity.
The question used to be "can I build this?" or "would it be cool to try?" Now the question is "why not?" Without the constraint of difficulty forcing any real consideration of whether it should be built, or whether there is a better way to build it.
The only honest reason I can find for most of what is being produced is the trend. Build it, write the article, make the video, collect the attention - or get bought by the very company creating the hype train. The output is not the point.
What I Hope Comes After
Hype cycles end. This one will too.
What I hope comes after is a quieter period where the developers who actually understand software - who can articulate what they need, who can lead AI toward something genuinely better - start doing that without the noise.
I hope they are already doing that, quietly, taking time to build something in two years that would have taken them twenty before - just like we do.
More software from scratch. Less inherited complexity. Stacks that are the right size for the problem rather than the default size because that is what everyone uses.
Maybe, on the other side of this, a photo app on Windows that opens in under 100ms. Not because that is a hard technical problem. Because sub-hundred milliseconds should be normal and has not been, because the stack it sits on was never questioned - just inherited and added to.
That is not an AI problem to solve. It is a judgment problem. The willingness to look at something that technically works and say it is not good enough - AI does not help with that. It just removed the excuse that you did not have time.
AI can help build the right thing faster. It cannot decide what the right thing is.
The developers who already know the difference will benefit most from this era. Everyone else will produce more, faster, and none of it will be better.
50,000 Jiras. Is that exaggerated? Maybe, but not by much. Todo apps were built in numbers before - they are the default now as well.
We can now build faster than ever and it can be great stuff. Please do - and if you already are, thank you. Can't wait to see your work.
Top comments (0)