There’s a fashionable claim going around: SaaS is dead. Business applications are just CRUD databases with business logic bolted on, the argument goes, and once agents absorb the logic, the app becomes optional. The agent becomes the interface.
It’s a clean story. It’s also missing the part that actually makes software useful.
What Chat Is Bad At
Chat is genuinely good at expressing intent, asking an open question, and getting something done without knowing which menu it lives in.
It’s genuinely bad at three things:
Scanning — nobody reads a paragraph to find a number they could see in a table in half a second
Precision — dragging a slider, reordering rows, adjusting an axis. Chat can describe it. It can’t beat touching it.
Comparison — three options across three replies is worse than three options side by side
A chat-only spreadsheet isn’t more human. It’s slower, in exchange for feeling conversational.
What UI Can’t Do Any More
The opposite failure is the one most existing software still has.
Rigid navigation assumes every user wants the same path
It can’t act for you — a UI shows you where the button is. It doesn’t click it.
It can’t explain itself — when something’s confusing, the screen just sits there
This is the gap agentic onboarding closes at small scale. It’s a preview of the shift happening to software generally.
Two Products, Converging From Opposite Ends
The useful evidence isn’t theoretical. It’s what’s already happened to products built from each starting point.
Claude started as chat. It’s an AI model you talk to — about as chat-native as software gets. It still ships a full UI, and you still have to use it. Billing. Organisation settings. Who’s on the team and what they can reach.
Not because the chat isn’t good enough. Because those things are deterministic. You need to see the seat count, not be told it. You set a spend limit and watch it save.WebinarGeek started as UI. Setting up a webinar there recently, the chatbot was genuinely good — it even handed back a list of tasks to work through.
But building the reminder sequence in chat would have been miserable.
Editing a registration page, swapping a banner, moving a send time — those are edit-and-check loops. Change one thing, look at it, change it again. A UI does that in seconds. Chat turns it into a negotiation.
One product grew a UI. The other grew a chat layer. They arrived at the same shape from opposite directions.
The Real Difference Is Bounded vs Unbounded
Here’s what those two examples are really showing, and it isn’t typing versus clicking.
A user interface is a set of constraints. The constraints are the product.
When WebinarGeek puts a form in front of you — title, date, registration questions, reminder sequence, follow-up email — it isn’t just collecting data. It’s telling you what a good webinar is made of. The fields are a checklist. The order is a method. You end up running a competent webinar largely because the software made it difficult to run an incompetent one.
Nobody wrote that down as a framework. It’s dissolved into the screens.
Claude has no such shape, by design. It will help you plan a webinar, write a novel, draft a legal argument, or waste an afternoon. The range is close to infinite, and the guidance is close to zero. It has no opinion about what “done well” means in your particular domain, because it isn’t a product about your particular domain.
That’s the actual axis. Not conversational versus visual. Bounded versus unbounded.
Constraints Are a Feature
This runs against the instinct that flexibility is always better. It isn’t.
Don Norman’s central argument in The Design of Everyday Things is that good design makes the correct action obvious and the incorrect action difficult. Constraints aren’t what’s left over after the design work — they are the design work.
A second, older usability principle does even more damage to the chat-only vision: recognition over recall. An interface shows you what’s available. A chat box requires you to already know what to ask for.
Which produces the line that matters:
A UI tells you what you didn’t know you needed. Chat waits for you to ask.
You cannot request a reminder sequence you don’t know exists. You cannot ask about the mobile safe zone on a banner image if nobody ever told you banners have one. A blank text box is infinite and, for anyone who isn’t already an expert, that’s the problem rather than the pitch.
Which Is Better Depends on Who’s Using It
The honest version of this argument has a variable in it.
Experts want the canvas. They know what good looks like. Rails slow them down. For them, chat is liberating — say the thing, skip the six screens.
Everyone else needs the rails. They don’t yet know what good looks like. The interface teaches them, one required field at a time.
And here’s the part product teams forget: every user is a novice at the beginning. Expertise is the thing your product produces, not the thing it can assume.
On day one, nobody knows what your software is capable of — which is precisely when an unbounded text box is least useful and an opinionated path is worth most.
Two Layers, One Conversation
So the future isn’t replace-the-UI-with-chat. It’s a UI and a conversational layer on the same product, each doing what it’s structurally better at.
The UI layer holds the framework — structure, state, precision, the encoded opinion about what good looks like
The chat layer holds the intent — do this for me, explain what I’m looking at, what now?
The UI keeps you on a path that works. The chat gets you unstuck when the path isn’t obvious.
The Handoff Is Plumbing, Not Design
For this to work, the two layers can’t be separate products bolted together.
The chat layer needs to know what’s on screen, what the user just clicked, what state the UI is in right now. The UI needs to reflect whatever chat just did — instantly, with no refresh and no re-orienting.
That’s the difference between a chatbot parked in the corner of an app and an agent that’s actually aware of the product around it.
The Part That Doesn’t Get Easier
Here’s the catch: every agent is working from context that’s already slightly out of date.
State changes faster than context gets delivered. Context lives in more places than any one system can see. Every new tool in the stack is another source the agent doesn’t automatically have.
Better models make agents better reasoners. They don’t make them better informed.
More on that in the next post.
So No, SaaS Isn’t Dead
Back to the fashionable claim.
The reasoning goes: business applications are databases plus business logic plus a UI. Agents absorb the logic. Therefore, the UI — and the company selling it — becomes redundant.
The flaw is in the first step. The UI was never just a way to reach the database. It’s where years of accumulated judgement about what a good outcome looks like got encoded — which fields matter, in what order, what you’re not allowed to skip, what you should be looking at right now.
Strip the interface, and you don’t get the same product with a better front end. You get a very capable assistant with no opinion about your domain, waiting for someone who already knows what to ask.
The database survives. The agent arrives. But the encoded expertise has to live somewhere — and where it lives is the interface.
SaaS isn’t dying. It’s growing a second layer.
Half Chat, Half UI: FAQ
Will chat replace traditional UI? No. They do structurally different jobs. Chat handles intent and action; UI holds the framework — structure, precision, and the encoded opinion about what a good outcome looks like. The shift is toward both layers working together.
Why is a UI better for following a proven process? Because a UI is deterministic and bounded. The fields, the order and the required steps are a method the product’s makers already worked out. Chat is unbounded by design — enormous range, no built-in opinion about what “done properly” means in your domain.
Isn’t a chat-native product proof that UI is going away? The opposite, so far. Chat-native products keep adding UI for billing, settings and permissions. UI-native products keep adding chat. Both are converging on the same split from opposite ends.
Is SaaS dead now that agents can do the work? No. The claim assumes the interface was only ever a way to reach the database. In practice, it’s where domain expertise is encoded. Remove it, and you have a capable assistant with no view on what good looks like in your industry.
What should teams building software do now? Keep the framework in the UI, put intent in chat, and invest in the live connection between them — rather than treating context as something wired up once during setup.