Apr 01, 2026 - 4.9245283018867925 min read

Liquid SaaS Is a Mirage. The Future Is Semantics.

In response to "What If AI Saved SaaS?"

I recently read a stimulating piece in a newsletter about the future of SaaS. The thesis: software will become "liquid"—a solid business core on top of which AI fabricates, on the fly, whatever interface each user needs. No more off-the-rack; enter scalable bespoke. It's seductive. It's also, I believe, a trap.

The real specter isn't the SaaS apocalypse. It's the privatization of chaos.

The question is everywhere: if AI can generate everything, why pay for a subscription? But the real danger lies elsewhere. If AI becomes so cheap that anyone can build their own software and keep their data at home, we don't eliminate SaaS—we replace it with an archipelago of cobbled-together solutions that pass the first test and collapse silently three weeks later.

Bugs no one sees. Edge cases no one tests. Fragile integrations no one maintains. Every company would end up running its own software without the teams to ensure its longevity. This is technical debt, except instead of being managed by a vendor, it would be scattered across every organization—invisible and cumulative.

And the promise of simplification hides its opposite. For AI to produce anything useful in a business context, you need to stack additional layers: connectors, data pipelines, security guardrails, governance, versioning. "Liquid SaaS" doesn't eliminate the plumbing. It adds more of it, while making it invisible to the user who thinks they've been set free.

The "conductor": a metaphor that backfires

The author describes the advent of AI as everyone's transition "from musician to conductor." The image is vivid. It's also misleading.

In 1983, psychologist Lisanne Bainbridge formulated what she called the "ironies of automation." Her observation, forged in nuclear power plant control rooms, hasn't aged a day: the more you automate, the harder what remains for the human becomes. You eliminate repetitive tasks and leave the operator with a concentrate of ambiguous, poorly supported, high-stakes decisions. The human isn't promoted. They inherit the leftovers—the pieces the machine couldn't absorb.

The "conductor" who pilots Claude Code to modify their own tool ends up in exactly this position: supervisor of a system whose inner workings they can't see, tasked with spotting errors the machine doesn't know how to flag.

"Workslop," or the hell of almost-good-enough

Researchers at Stanford have put a word to a phenomenon many will recognize: "workslop." It's that AI-generated deliverable that looks like finished work—clean, structured, confident—but doesn't survive serious scrutiny. The trap is precisely its appearance of quality: it doesn't signal its gaps, and it's the person receiving it who pays the cognitive price of hunting them down.

Applied to liquid SaaS, the problem is glaring. Interfaces that look like they work. Dashboards that seem accurate. Workflows that appear complete. The user, now a full-time quality controller, would need to maintain a level of vigilance that our brains aren't wired to sustain for long.

BCG documented the endpoint of this process in a March 2026 study: "AI brain fry." Employees who intensively supervise AI tools report +14% mental effort, +12% fatigue, +19% information overload, and commit 39% more serious errors. Scaled to a business application regenerated daily, the picture is dizzying.

Friction wasn't the problem. It was the guardrail.

The author celebrates the end of software "enshittification"—the piling up of useless features that pollutes the experience for 98% of users. The diagnosis is correct. But the solution contains its own irony: removing the frictions of rigid software also means removing what paced the work.

The blank page, the time spent searching, the effort of structuring—all of this functioned as a natural regulator. A Berkeley study followed two hundred employees for eight months after adopting AI tools: the volume of work didn't decrease. It swelled, across every function studied, because AI made every new task tempting to undertake.

We know Parkinson's law: work expands to fill the time available. Its AI corollary is more insidious: work expands to fill the capacity available. A SaaS where everything can be modified with a prompt doesn't emancipate the user—it pulls them into an endless spiral of micro-adjustments.

What can save us: semantics, not generation

The real opportunity is almost the opposite of the liquid SaaS thesis.

The software industry already knows the "headless" model: CRMs, CMSs, e-commerce tools that run without their own interface, exposing APIs onto which other layers plug in. Generative AI extends this logic—it places a conversational "head" on top of existing tools. It doesn't replace business software. It overlays it. And that overlay depends entirely on the foundation underneath.

But the real problem with that foundation isn't its interface. It's its lack of understanding. A CRM doesn't know what a customer is. A project management tool can't distinguish a critical dependency from a minor one. An ERP confuses a logistical delay with a strategic one.

AI should be used to give meaning to data—identify anomalies, suggest trade-offs, understand context—not to rearrange the buttons on the screen. Generating interfaces multiplies the error surface. Enriching the semantic layer reduces cognitive load instead of increasing it.

The hidden bill

One angle that the prevailing discourse sidesteps: the real cost. Integrating generative AI means additional spending on tokens, infrastructure, new hires, and integration time. It also means increased dependence on proprietary vendors whose pricing evolves at the pace of their funding rounds.

People keep repeating that "the marginal cost of code is trending toward zero." That's true for production. Not for maintenance, security, compliance, or long-term reliability. Software that's free to write but needs rebuilding every quarter costs infinitely more than a SaaS at €50 per month.

And the concrete gains? They remain to be demonstrated. The available data points in the opposite direction: more tasks, more supervision, more fatigue, with no clear net benefit.

The final irony

Bainbridge ended her 1983 paper on a formidable paradox: the most reliable automated systems—those that run the longest without a hitch—are the ones that most erode the human backup skills needed when things go wrong. The day the system fails, the operator who hasn't practiced is the least equipped to intervene.

The experience described by the author—an advanced user modifying their own tool via Claude Code—embodies this paradox. It works as long as everything is fine. The day it breaks—and it will break, because software always breaks—who will understand the system well enough to fix it?

Off-the-rack SaaS has its flaws. But AI-tailored software isn't haute couture. It's the fast fashion of software: quickly produced, quickly obsolete, and whose true cost only reveals itself after the fact.

The real question isn't technological

Ultimately, the debate over liquid SaaS misses the point. The problem organizations face isn't their software. It's the way they work.

Regenerating tools with AI is putting a technological band-aid on human dysfunctions: absurd processes, cascading approvals that add no value, meetings from which no one emerges with a decision. AI is one lever among others—and probably not the most decisive one—for improving efficiency and restoring meaning to work.

The real productivity leap won't come from a tool that regenerates its interfaces on demand. It will come from organizations that asked themselves why they do what they do, before looking for how to automate it.

SaaS doesn't need to become liquid. It needs to become intelligent. And organizations don't need better tools—they need better processes.

Sources: