Everyone is asking some version of the same question now: if AI makes software dramatically easier to build, what happens to software businesses?
The strongest mood I’m seeing is not “SaaS is dead,” but something more unsettling: the cost of building software is falling fast, which means weak software moats are getting exposed. The moat is shifting away from raw implementation and toward distribution, trust, proprietary data, deep workflow ownership, compliance, and operational excellence.
That is the backdrop to a lot of the sharpest opinion pieces being written right now.
Table of Contents
My take
Here is the broad feeling in the software world right now: excitement on the surface, anxiety underneath.
There is genuine optimism that AI-assisted engineering (vibe coding) can make small teams absurdly productive. It is easier than ever to prototype, ship, test ideas, and build useful internal or niche software without a giant engineering org. That part is real, and a lot of writers are no longer treating it as a novelty.
But there is also a growing suspicion that the old software business playbook is weakening. If code generation becomes cheaper, faster, and more accessible, then software companies can no longer lean so heavily on “it took years to build” as their main justification for valuation, pricing, or defensibility.
So the current vibe is not quite doom, and not quite triumph. It is more like this:
That is why the conversation has become so charged. People are not really arguing about code editors. They are arguing about whether the economics of software are changing under everyone’s feet.
Articles and blogs
Good news: AI Will Eat Application Software
One of the boldest takes in the whole debate. The argument is that application software is becoming less defensible as AI lowers the cost of reproducing product functionality, and that users increasingly care more about outcomes than about seat-based tools. This is a strong inclusion if you want a fearless, investor-style view of the pressure building under traditional SaaS.
From Demos to Deals: Insights for Building in Enterprise AI
A useful piece on how AI companies may need to operate differently from classic SaaS companies. The emphasis is not just on building the product, but on how product commoditization changes go-to-market, value capture, and what an enduring moat might actually look like in AI.
The New Rhythm of the Enterprise Sale
This one is less about coding and more about business mechanics. The key idea is that AI is changing not only what companies buy, but how quickly they evaluate and replace software. That matters because shorter replacement cycles are bad news for sleepy incumbents.
Whether AI is a bubble or revolution, how does software survive?
A thoughtful middle-ground essay. The framing here is that cheap software generation does not mean all software value goes to zero; it means the economics of smaller, simpler tools are changing much faster than the economics of high-stakes systems. Good for readers who want nuance instead of chest-beating.
Why demand for code is infinite: How AI creates more developer jobs
A useful counterweight to the “software jobs are over” narrative. The argument is that lowering the cost of creating software can increase the total amount of software the world wants, which may expand demand even while changing what developers actually do.
A new worst coder has entered the chat: vibe coding without code knowledge
This captures the backlash side of the conversation. The point is not that AI-assisted engineering is fake, but that it can make it much easier to generate impressive-looking nonsense and push brittle software further than it deserves to go.
Not all AI-assisted programming is vibe coding
One of the most useful framing pieces on the whole subject. Simon Willison separates carefree, high-trust prompting from more accountable AI-assisted programming. It is a good reminder that not all AI-heavy coding practices are equally reckless.
Will the future of software development run on vibes?
A short but sharp warning. The basic message is that AI-first development is fantastic for experiments and prototypes, but dangerous when people let a “good enough” prototype slide into production without the engineering discipline that production systems require.
AI-assisted coding for teams that can't get away with vibes
This is a good bridge piece between fast AI experimentation and serious delivery. It speaks directly to teams that still need maintainability, accountability, and reliability, even while using AI heavily.
My LLM coding workflow going into 2026
A practical and disciplined view of how experienced engineers are folding AI into real work. Rather than treating AI as magic, it presents a workflow where AI speeds things up but the human still owns the outcome.
The reality of AI-Assisted software engineering productivity
A useful reality check. The argument is that AI can absolutely save time, but coding is only one part of software delivery, so the gains are often uneven. It is a good antidote to simplistic “10x developer” claims.
How to write a good spec for AI agents
This piece is really about where the world may be heading next: from prompting by instinct to building with clearer specs and more structured intent. It hints at a future where software teams become more like editors, orchestrators, and reviewers of machine-generated work.
Themes showing up across the debate
1. The moat is moving, not disappearing
The strongest recurring idea is that code itself is becoming less scarce, but software advantage is not vanishing — it is relocating. The defensibility is moving toward distribution, trust, data, integration depth, workflow ownership, and the ability to operate reliably at scale.
2. Weak SaaS looks shakier than strong SaaS
The software businesses under the most pressure seem to be the ones selling generic, shallow, seat-based tools with limited differentiation. If your product can be approximated quickly by a smart team using AI, the market is going to ask hard questions.
3. “Can build” and “can run” are diverging
This is one of the most important distinctions in the current discussion. AI makes it easier to build software. Running resilient, secure, supportable systems is still a different discipline. The gap between those two things is becoming more visible.
4. The winners may look more like operators than coders
A lot of the opinion pieces point to the same conclusion: the next winners may not be the teams writing the most code, but the teams that understand the workflow best, own the customer relationship, integrate deeply, and use AI to move faster without losing control.
Final thoughts
The overall vibe in the software world right now is restless, opportunistic, and slightly paranoid.
There is a sense that something big has already shifted, even if nobody agrees yet on where it ends. The loud optimists think AI-assisted engineering will blow up the old SaaS model and turn software into a faster, cheaper, more fluid business. The more grounded voices think that is only half true: software creation is being commoditized, but software operations, trust, and workflow ownership are becoming even more valuable.
That feels closest to reality.
So no, SaaS does not look dead soon. But it does look less comfortable. Less protected. Less able to rely on historical effort as proof of future value.
The old story was: building software is hard, so incumbents are safe.
The new story seems to be: building software is getting easier, so incumbents have to prove they deserve to survive.
And that is the mood now more than anything else.
Top comments (0)