Could the future of software be fluid? How do we get the best of AI without losing the soul of software?
Gil Dibner

The evolution of vertical software has been defined by a single, persistent trade-off: the tension between control and convenience. We arrived here through three distinct eras, each defined by a specific innovation: the on-premise license, the SaaS subscription, and the low-code interface.

In the original era of on-premise licenses, software was a packaged product you bought and installed on your own servers. You owned the license, but you also owned the headaches—hosting, security, and maintenance. You had total control, but it was heavy, expensive, and slow to update. While customization was possible, it often meant hiring expensive consultants to write brittle code or modify the core application. This trapped companies in "upgrade hell"—unable to accept new vendor releases without breaking their own custom work.

Then came SaaS (Software as a Service). Vendors started hosting applications in the cloud. This solved the maintenance headache, but it introduced a new problem: rigidity. To make the economics work, SaaS vendors had to standardize everything. Suddenly, you stopped adapting the software to your business and started adapting your business to the software. SaaS solved the cost and complexity of running the software, but it did little to address the challenges of implementation and configuration. Customization was dead. Configuration could be complex and expensive.

More recently, the industry shifted to Low-Code/No-Code. This innovation tried to give control back to the user with visual tools. It was a step in the right direction, letting users glue things together, but it often resulted in "shadow IT"—fragile apps that lacked the deep power and security of professional engineering. Reliability and consistency were sacrificed for infinitely customizable software. At Angular, we run our entire operation on Airtable. It’s exactly what we need and is highly specialized (we improve it nearly every day), but it will never be enterprise-grade and would never fly at a large financial firm.

The "Software is Dead" Moment

Right now, the enterprise software world feels like it is on a cliff edge. We can all see the cost of generating code dropping to near zero before our eyes. The "Vibe Coding" movement is well underway, and a simple, seductive idea is gaining ground: Why buy software when you can just describe what you want to an AI and have it build an app for you on the fly? Proponents argue that "software is dead" and that the future is ephemeral—apps created for a single task and then discarded.

But for any serious enterprise application where accuracy and process matter, this "wild west" of ephemeral software has serious holes. The problem is not hallucinations or GenAI limitations. Those are getting resolved, and the architectural underpinnings that will enable robust GenAI applications are emerging rapidly.

The real structural flaws in this vision are the non-negotiable foundations of enterprise operations: security, reliability, and consistency. An enterprise operates on strict consistency of process across users and across time—something a fleeting, generated app can't guarantee. Then there are the critical layers of governance: logging, audit trails, permissions, and compliance. These aren't optional add-ons; they are the legal and operational bedrock of the company. A "vibe coded" app might solve a user's immediate problem, but it rarely accounts for the complex web of controls required to keep the enterprise safe. Finally, enterprises demand the ability to reason about their processes and impose them on their employees and partners. Traditional software and SaaS allowed the enterprise control over fallible human processes; ephemeral software surrenders that control.

A Potential Emergent Future: Fluid Software

In conversations with companies both in our portfolio and the broader market, I am beginning to sense that a new wave of software architecture is emerging. It’s a path that doesn't reject AI, but channels it. If traditional SaaS is “solid” (rigid, hard to change) and ephemeral vibe coded software is “gas” (hard to contain and always vanishing), perhaps the future needs to behave more like a liquid: infinitely and easily flexible, but fits elegantly into the shape of its environment. Let’s call this concept Fluid Software.

The first sign that Fluid Software is arriving is the growing convergence around the configuration studio. Several companies are building studio-like environments where users use textual prompts and an AI engine to configure complex software to their specific requirements. This shortens deployments and sales cycles and brings forward time-to-value dramatically. It can also reduce TCO by eliminating armies of expensive consultants. This is, perhaps, the death of forward-deployed engineers, but not the death of software.

The second sign is a small handful of companies explicitly articulating this vision: What if we allowed customers to configure the entire application within a set of clearly defined primitives and guardrails?

Fluid Software is not here yet, but the pieces appear to be gradually falling into place. It represents a potential hybrid architecture—one that keeps the magic of Generative AI but anchors it with the structural integrity of traditional SaaS. For Fluid Software to work, it must strictly decouple well-defined primitives from the generative configuration. Imagine an architecture split into two distinct layers:

• The Immutable Primitive Layer (The "Hard Core"): This layer consists of compiled, vendor-controlled logic blocks—think of them as the "physics" of your industry that shouldn't change. This includes the math behind a double-entry ledger, the strict rules of HIPAA storage, or cryptographic signatures. This code is written by human engineers, rigorously tested, and locked down. The AI can't touch it, and neither can the user. It just works.

• The Declarative Configuration Layer (The "Fluid Shell"): This is where the user plays. Instead of writing code, the user—or an AI agent—creates a configuration that tells the primitives what to do. When a user says, "I need a workflow for approving high-risk vendors," the system doesn't write new Python code. Instead, it creates a recipe. It strings together the pre-existing verification, credit check, and approval blocks in a specific order.

This raises a critical question: who owns the code? In one version of this future, the codebase is multi-tenant, owned by the vendor and rented SaaS-style. Only the configuration has been radically re-imagined. In a second, more extreme version, each customer’s unique configuration is a single-tenant codebase that can be exported. Allowing customers to walk away with their own single-tenant version of their Fluid Software would be the most radical expression of this vision—and the most forward-looking embrace of the idea that the cost (and therefore value) of code is zero. The value shifts to the workflows around configuration and the guardrails that ensure the software is reliably compliant with enterprise goals. As with open source today, the point of single-tenant fluid software would not be that enterprises prefer to run their own stack, but that their ability to walk away with their implementation would be a comforting guarantee against vendor lock-in.

If this model emerges, it could finally solve the paradox of enterprise software in the AI era: governance versus flexibility.

You get governance because the code executing the logic is always the vendor's immutable primitives. The system stays audit-proof and secure. There's no risk of an AI hallucinating a security flaw because the AI isn't writing the dangerous code—it's just arranging the safe blocks. Simultaneously, you get flexibility because the configuration is fluid. The user feels no friction and can reshape how the app looks and flows instantly using natural language, without waiting months for a vendor to release a new feature.

In this vision, software engineering doesn't disappear; it just changes roles. Engineers at software vendors build the guardrails, and customers—aided by AI—configure their own path.

I'm far from convinced this is the right vision for the future, and there are obvious structural risks. Can we actually define "atomic primitives" for complex business logic without creating a distributed monolith? How do we prevent the configuration layer from becoming just another form of unmanageable code (the "YAML engineering" trap)? And if every customer configuration is unique, does the burden of QA shift unfairly back to the customer? There may not be great answers to these questions yet, but they might be easier for fluid software to address than for ephemeral software.

I’m curious where you see the opportunity to build in this way, or if you believe these structural challenges are insurmountable.

And most importantly - if you are building something that might fit into this Fluid Software model - I’d love to hear from you.

The AI-Native Enterprise Playbook
Ten real-time observations on a rapidly evolving playing field

No More Painting by Numbers
It’s the end of the “SaaS playbook.

The Age of Artisanal Software May Finally be Over
Every wave of technological innovation has been catalyzed by the cost of something expensive trending to zero. Now that’s happening to software.

Founders as Experiment Designers
David on why founders should run everything as an experiment.

ENTERPRISE/TECH NEWS

Ads are coming! OpenAI says it will start testing clearly labeled, bottom-of-response ads in ChatGPT for logged-in U.S. adults on the free tier and the new $8/month “Go” plan, while keeping higher paid tiers ad-free (and excluding sensitive topics and under-18 users). Fidji Simo frames this as “mission-aligned” monetization with strict guardrails: ads won’t influence answers, chats won’t be shared with advertisers, and users can control personalization. The strategic subtext: if OpenAI’s costs scale with compute, ads may be the only way to expand both reach and ARPU fast enough to sustain R&D. But it’s entering a knife fight with Google/Meta, and eventually needs Meta-like personalized conversion ads, not just contextual placements. 

Agentic consultants. McKinsey CEO Bob Sternfels says the firm now “employs” ~25,000 AI agents, and that AI work (run through its QuantumBlack unit) is now a meaningful share of projects. This is either pure marketing (likely!), or a glimpse of where high-end services are heading: consultancies are treating agent labor like a new delivery layer, compressing analysis/production time and shifting economics away from billable hours toward outcome-linked, tech-enabled engagements. For founders, it’s both a distribution wedge (sell into these agent-heavy workflows) and a warning shot: your product has to win in an “agents-first” operating model, not just in a partner deck. 

Fleet of minds. Jack Clark (Anthropic co-founder) describes a new default: you “spin up” research agents before a hike (or an Uber nap), and they read thousands of papers, cross-check, and hand you polished reports. It’s not just productivity porn; he notes the psychological shift (guilt over not tasking machines) and the emerging job of “managing a fleet of minds.” (Somewhat similar to the newsletter last week!). In VC/startup terms, this is another signal that the bottleneck is moving from model capability to orchestration layers—agent management, workflow QA, and new “institutional” tooling that turns parallel AI labor into reliable outcomes.

HOW TO STARTUP

Software 3.0? Doug O’Laughlin argues “Software 2.0” (seat-based, human-driven SaaS) is headed for a structural reset as tools like Claude Code turn software into a byproduct of compute rather than the scarce asset. His key analogy is the memory hierarchy: AI agents/context windows behave like fast, non-persistent DRAM, while the enduring value shifts to “NAND” layers—APIs, state, and systems of record that agents read/write. For founders/VCs, that implies UI/workflow differentiation (and many horizontal SaaS categories) compresses, while “source of truth” + infra-native, agent-consumable products capture the durable rents. 

Founder-mode on cancer. In perhaps the best piece I’ve read in weeks, Elliot Hershberg profiles GitLab founder Sid Sijbrandij, who after an osteosarcoma relapse stepped back from CEO at the end of 2024 and treated his illness like a startup: obsessive documentation, maximal diagnostics, and a hand-picked “SWAT team” to run fast iterations. The piece zooms into how single-cell analysis suggested fibroblast markers, pushing Sid to try a FAP-targeting radioligand therapy in Germany (Lu-177) and ultimately get back to remission. For founders/VCs, it’s a vivid signal that “care orchestration + data + access” may become a new platform layer in biotech…turning patients into operators and creating room for software-native healthcare startups. 

Agent-led sales. On TBPN last week, Sonya Huang describes the evolution from sales-led growth to product-led growth to agent-led growth. We wholeheartedly agree! Read Gil’s take from a few months ago.

Cursor’s new browser. The Cursor team used GPT 5.2 in Cursor to build an entire browser in a week. And it kind of works! Impressive demo of what’s possible. 

HOW TO VENTURE

The end of open APIs. Tom Tunguz argues the era of “open APIs” is ending as incumbents harden their platforms: Salesforce throttled Slack’s API, Datadog shut off accounts of a would-be competitor, and Epic is accused of using patient records as a gatekeeping tool. With AI speeding up software shipping, big vendors can expand into adjacent products faster, so they defend the valuable data and workflow choke points they already own. For founders and seed investors, platform-leveraged SaaS looks riskier again: diligence API and data rights early, and bias toward wedges that become the system of record or can own an end-to-end stack.

Blue Energy Co-Founder & CEO Jake Jurewicz will be speaking about the Future of Energy at Davos.

Portchain Connect to be implemented by Klaipeda Container Terminal, as part of its efforts to modernise berth planning.

DualBird
DevOps Engineer (Tel Aviv, Haifa)

Reco
Senior Product Manager (Tel Aviv)

SOURCIX
Backend Engineer (Tel Aviv)