The Death of Fixed Software

A few weeks ago I published a thesis on the eight world changes that would take us from "agents that write code fast" to "agents that deliver enterprise-grade software." The response told me something interesting: most people agreed on the what — that software delivery was about to be radically compressed — but almost everyone assumed the output would look the same. Faster HubSpot. Cheaper Salesforce. Your own Notion, but generated.

I think that's wrong. And I think the mistake matters.

The eight steps I described are real. They're happening. But they describe a transition — not a destination. The destination isn't "the same software, built faster." The destination is a fundamentally different relationship between humans and software. One where the interface itself is alive.

I'm calling it Agentic Adaptive Interfaces. And I think it makes most of what we call "SaaS" obsolete within 18 months — not because the services disappear, but because the surfaces do.

The hidden assumption in all software

Every piece of software you use today was built on the same bet: that someone, somewhere, could predict what you'd need — and freeze that prediction into a fixed interface.

Think about what that actually means. A product team spent months researching, designing, debating, and shipping a set of screens, flows, buttons, and menus. They made thousands of decisions about what to show you, what to hide, what order things should appear in, what words to use, what the defaults should be. They shipped it. And then they spent the next five years slowly iterating on those frozen decisions, A/B testing button colors, arguing about whether the sidebar should collapse, shipping features 90% of users will never touch because 10% demanded them.

The entire SaaS industry is built on this loop: predict → freeze → iterate → pray. And the best companies in the world are merely better at predicting. They're not solving the fundamental problem. They're optimizing around it.

The fundamental problem is this: no fixed interface can serve every user, every context, every moment. It's not a design failure. It's a category error. We've been building static maps for a dynamic territory.

What changes when generation is instant

Here's the shift that makes everything else possible: UI generation is crossing the speed threshold.

Not "fast enough to build an app overnight." Fast enough to build an interface while you're looking at it. Fast enough that the gap between "what do you need?" and "here it is" drops below the threshold of human patience — below a second in many cases, below five seconds for complex layouts.

This isn't hypothetical. I've been building this. The system I use — UIClaw, running on top of OpenClaw — can take a natural language description of what you want to see and render a full, interactive, styled interface in real time. Not a wireframe. Not a mockup. A working UI with live data, actions that do things, and a design language that's consistent and polished.

And here's what I didn't expect: once you have that, you stop thinking about software the same way. You stop asking "which app does this?" and start asking "show me what I need right now."

Agentic Adaptive Interfaces

Let me be precise about what I mean, because the term could easily collapse into vague futurism.

An Agentic Adaptive Interface is a software surface that:

Is generated on demand — not retrieved from a fixed codebase, but composed in the moment based on what the user needs, what data is available, and what actions are possible.
Adapts continuously — the interface isn't static after generation. It reshapes itself as the conversation evolves, as new data arrives, as the user's intent becomes clearer. A dashboard that was showing revenue can become a drill-down into churn the moment you ask "why is Q2 down?"
Connects to anything — the agent behind the interface doesn't just render UI. It reaches into databases, APIs, services, and tools to populate that UI with real data and wire up real actions. If the data source doesn't exist yet, it can build one.
Learns and remembers — interfaces that were useful get saved, indexed, and offered again. Over time, the system builds a registry of patterns that work for you — not a generic component library, but a personal catalog of interfaces shaped by your actual usage.
Has no fixed footprint — there's no "app" to install, no version to upgrade, no settings page to configure. The interface is ephemeral by default and persistent by choice. You keep what works. Everything else dissolves.

This isn't a new kind of app. It's the end of apps as a fixed category.

Why SaaS can't adapt

The SaaS model has a structural problem that no amount of AI features can fix: the interface is the product.

When Salesforce adds an AI copilot, it's adding intelligence inside a fixed interface. The CRM still has the same screens, the same navigation, the same object model, the same 47-tab settings page. The AI can help you use the frozen interface faster. It can't change the interface to fit you.

This is why every SaaS product eventually feels the same: bloated. Not because the teams are incompetent, but because they're serving millions of users through a single frozen surface. Every feature request from every customer gets bolted onto the same chassis. The settings page grows. The navigation deepens. The onboarding gets longer. The product becomes a Swiss Army knife — technically capable of everything, practically optimized for nothing.

Agentic Adaptive Interfaces break this trap because there's nothing to bolt onto. Every interaction starts fresh — or starts from a saved pattern that already works for you. There's no global feature backlog because there's no global interface. Your surface is yours.

The interface registry: where ephemeral meets persistent

One of the most interesting design problems in this space is the tension between generation and memory.

If every interface is generated from scratch, you lose continuity. You loved that dashboard layout from last Tuesday — but it's gone. If every interface is saved and reused, you lose adaptability. You're back to frozen software, just with extra steps.

The answer is a registry: a searchable, growing catalog of interfaces you've generated and found useful. Each entry captures the spec (the structural definition), a visual snapshot, metadata about what it does and when it was used, and the context it was built for. When you need something, the system checks the registry first: "I've built something like this before — want to start from here?" You can use it as-is, modify it, or generate something new.

Over time, this registry becomes something genuinely new: a personal component library that grows from use. Not designed by a product team guessing at your needs. Shaped by your actual work, your actual data, your actual patterns.

This is the difference between a tool that serves you and a tool that learns you.

The real disruption: databases and services on demand

Here's where it gets genuinely weird — and genuinely powerful.

Today, if you want a CRM, you need a CRM's database: contacts, deals, pipelines, activities, all with the right schema, the right relationships, the right indexes. Building the interface is one problem. Having something to put in it is another.

In the adaptive interface world, the agent doesn't just generate UI. It generates — or connects to — the entire data layer underneath. Need a view of your sales pipeline? The agent can query your existing database, or spin up a new one, or pull from three different APIs and unify the data in memory. Need to track a new kind of object that no existing tool supports? The agent creates the schema, the storage, and the interface in a single motion.

This means the boundary between "using software" and "building software" evaporates. You don't choose between Airtable and a custom database. You describe what you need, and the system figures out where the data lives — or creates a home for it. The interface and the infrastructure become a single, fluid response to intent.

"I need to track investor conversations with follow-up reminders and a pipeline view" stops being a tool-selection problem. It becomes a sentence.

What this means for the SaaS industry

I want to be clear: I'm not saying SaaS companies disappear overnight. The data they hold, the integrations they've built, the trust they've earned — those are real moats, for now.

But the surface layer — the part you interact with — becomes commoditized. If an agent can generate a better interface for your specific workflow in seconds, the value of a generic, frozen interface drops toward zero. SaaS companies become backend services: data stores, integration hubs, compliance engines. The front end becomes a conversation.

This has three major implications:

1. "Best UI" stops being a competitive advantage. When any interface can be generated on demand, the product that wins isn't the one with the prettiest design system. It's the one with the best data, the most reliable APIs, and the deepest integration fabric. The presentation layer becomes a commodity.

2. Pricing models break. SaaS charges per seat because the interface is the product. When the interface is generated dynamically and the value is in data and services, per-seat pricing makes no sense. You're not licensing a screen. You're consuming capability.

3. Vendor lock-in shifts. Today, switching CRMs is painful because the interface has trained your muscle memory. Your team "knows" Salesforce. In an adaptive world, the interface layer is portable — it's generated, not memorized. Lock-in moves to the data and integration layer, which is both more honest and more escapable.

The experience gap

There's a natural skepticism here: "Generated UI can't possibly be as good as something a skilled design team spent months on."

Today, that's true. Generated interfaces in early 2026 are functional and clean, but they don't have the craft of a hand-polished product. They're missing the micro-interactions, the careful typography hierarchies, the subtle animations that make great software feel alive.

But here's what I'd ask you to consider: how much of that craft actually matters to you in the moment of use?

When you open a dashboard to check your pipeline at 9am, do you notice the 200ms ease-in on the sidebar animation? Or do you notice that the three numbers you need are right there, exactly where you want them, with exactly the filters you care about — because the system knows your context?

The experience gap is real but shrinking. And the relevance advantage of adaptive interfaces — showing you exactly what you need, not a generic screen designed for the average of all users — more than compensates for the polish gap in most practical contexts.

The best-designed SaaS in the world still makes you click through three menus to find the thing you need. An adaptive interface puts it in front of you because it knows you.

What I'm building

This isn't just a thesis. It's a build log — an early one.

UIClaw is an experiment I've been developing to explore this space. It sits on top of OpenClaw (an AI agent orchestration platform) and turns natural language into rendered, interactive interfaces — in real time, with live data, connected to real services. It's rough. It's a starting point. It is emphatically not production software.

But that's precisely the point.

The interface registry I described? It exists — with exactly one entry in it right now. Every interface I generate gets catalogued: the spec, a screenshot, metadata about what it does, tags for searchability. When I need something similar, the system surfaces it. The bones are there. The muscle is still growing.

I'm sharing this not because UIClaw is ready, but because even in its earliest form, it has already changed how I think about software. The moment you experience an interface that was generated for you, right now, based on what you just asked for — even a rough one — you can't unsee it. You start noticing how much time you spend navigating fixed software to find the three things you actually need. You start resenting menus.

This is very early. UIClaw is an experiment, not a product. The generation quality will improve. The registry will get smarter. The data layer will get deeper. A hundred things need to be solved before this is something you'd hand to a non-technical user. But the core insight is already clear — even from this rough starting point: fixed interfaces are a local maximum. We've been optimizing the wrong thing.

The future of software isn't a better app. It's no app at all — just a surface that appears when you need it, shaped exactly for you, and dissolves when you're done.

This is Part 2 of the "Software as a Request" series. Part 1 covered the eight world changes needed for agent-built enterprise software. This piece explores what happens when that capability meets the interface layer — and why the result isn't faster SaaS, but the end of SaaS as a fixed category.

I'm Nick Halstead. I built TweetMeme (acquired by Twitter), DataSift, and InfoSum. Now I'm building AskGVT and exploring the future of AI-native software. Follow me for more at future.gvtlabs.ai.