UI is Dead, Long Live the UI
TL;DR: AI agents are killing UI as a control mechanism while making UI more important as an understanding mechanism… with exceptions.
For decades, we designed software around one pretty safe assumption:
the human is the operator.
We click buttons, fill forms, drag things around, navigate menus, change settings. The software shows us what is happening and then gives us controls to make something else happen.
AI agents are starting to break that assumption.
If an agent can update a customer record, create a ticket, reschedule a meeting, modify a CAD model, deploy an application, or reconcile a spreadsheet directly through a programmatic interface, why should it click through the same UI I do?
Well… It probably shouldn’t.
And this has led to a very tempting conclusion:
UI is dying. APIs are the future.
However, I think that’s only half right. While agents may remove much of the need for humans to operate software, humans still desperately need to understand what’s going on.
And text alone is surprisingly bad at that.
So yes, UI is dying.
But also:
long live the UI.
Agents can operate systems better than we can
Consider something painfully ordinary: a TODO application.
Today, I open the app, click New Task, enter a title, choose a date, maybe select a project, assign someone, and hit Save.
An agent doesn’t need any of this. Give it something closer to:
create_task()
assign_task()
change_deadline()
close_task()
… and we’re done.
No dropdowns, no date picker, no lovingly animated button changing from blue to slightly darker blue when you hover over it.
The agent doesn’t care.
The same applies almost everywhere. Why should an AI navigate six Salesforce screens to update a customer? Why should it open Jira, search for a ticket, click Edit, change three fields, and submit a form? Why should it pretend to be a human using software when the underlying operation can be exposed directly?
For agents, the programmatic interface is the natural interface. Something structured, deterministic, and easy to manipulate. That might be an API, an MCP server, a command-line interface, functions, events, whatever comes next. The implementation isn’t really the interesting part.
The important shift is that software increasingly needs to be machine-operable.
Humans still need to understand what’s going on
Now, let’s flip the direction. Imagine asking your agent:
What’s going on with my project?
It could answer:
You currently have 17 open tasks. Three are overdue, five are blocked, four are waiting for review, and…
Which is technically correct. Also not how I want to understand a project.
Give me a board. Show me the blocked tasks. Put the overdue ones where I’ll immediately see them. Show me dependencies. Let me see that one entire branch of the project is stuck behind a single decision.
I can understand that in a few seconds.
This distinction becomes ridiculous when you move beyond TODO lists. Imagine a CAD application. The agent could tell me:
The support bracket is 72 millimeters wide, with a 14-millimeter circular opening positioned 18 millimeters from…
No… just show me the damn bracket 😅
Language is fantastic for explanation but it isn’t always fantastic for perception. A lot of times I don’t want something explained. I want to see it.
And then UI suddenly becomes more important than ever
Forget about clicks or how visible a button is. That’ll hardly be relevant for many applications (though certainly not all).
Because agents are now performing hundreds of actions on our behalf, the important human questions become:
- What is happening?
- What needs my attention?
At that point, UI is less about how to make things easy to operate and more about how to make things understandable.
Traps ahead…
Every rule has exceptions, and this is no exception (okay, I’m not proud of that one — soooorry 🤦). Sometimes I absolutely want direct manipulation.
Imagine an AI designing something in CAD.
It generates the model. I inspect it. Then I notice one detail. I don’t want to spend thirty seconds describing geometric coordinates like I’m negotiating with a very smart alien.
I want to grab the hole and move it.
This one. Here.
That’s the thing with UI too. It lets humans express things that are difficult to verbalize.
So perhaps the future relationship looks like this:
Agents operate.
Give them programmatic interfaces.
Humans understand.
Give us visual interfaces.
Humans intervene.
Give us controls exactly where judgment matters.
Temporary interfaces? Sure!
There’s another possibility that I find even more interesting. Maybe applications don’t need one permanent UI at all. If the underlying system exposes structured state, an AI could generate the interface that makes sense for what I’m trying to understand right now.
I ask:
Create an interactive page showing me everything blocking the September launch.
The system generates a dependency graph.
Later:
Compare what we planned with what actually happened.
Now I get a timeline.
Then:
Forget the details. What are the three things I should worry about?
We’ve seen that already. Agent-generated throwaway interfaces are nothing new, but how can we make agents build good ones? Will teaching agents to build good interfaces become part of the UI discipline?
Conclusion
I don’t think I’m describing anything new or far in the future here. From my personal experience and what I’ve been seen others doing, this is more likely “in six months” than “in six years”.
Of course, AI adoption is not uniform. Internal systems in companies that are heavy users of AI are probably spearheading that, while established software for end-users that already needed training for operating the it are likely to move more slowly.
But, eventually… eventually that’ll be the norm.