For years, mobile and web applications have been built around screens.
A user opens an app.
They navigate a menu.
They find a feature.
They fill out a form.
They press a button.
That interaction model is so familiar that we rarely question it.
AI is starting to change it.
Instead of navigating through an application, users can increasingly describe what they want and let software figure out the steps.
That sounds like a UX improvement.
But it creates a surprisingly difficult design problem.
The Interface Is No Longer Just a Screen
Imagine a travel application.
The traditional experience might require the user to:
Search for a destination
Select dates
Filter hotels
Compare prices
Choose a room
Enter payment details
An AI-driven experience might begin with:
“Find me a hotel in New York for three nights next month, close to the conference venue, under $300 per night.”
The interface suddenly becomes much more conversational.
But the underlying product still needs to perform all the same operations.
The complexity hasn't disappeared.
It has moved behind the interface.
Users Still Need Visibility
One risk of conversational interfaces is hiding too much.
If an AI agent makes several decisions without showing the user what happened, trust can disappear quickly.
Users may want to know:
What did the system search?
Which options did it reject?
What assumptions did it make?
What will happen if I approve this?
Good AI UX therefore isn't necessarily about showing less.
Sometimes it means showing the right information at the right moment.
AI Needs a New Kind of Confirmation
Traditional interfaces often use simple confirmation dialogs.
“Are you sure you want to delete this file?”
AI workflows can involve much larger actions.
An agent might prepare a financial transfer, modify a customer record, submit a document, or place an order.
A simple “Confirm” button may not be enough.
The interface should communicate:
What the agent is about to do
Which information it used
What will change
What cannot be undone
What requires approval
This creates a new design pattern:
Intent → Preview → Approval → Execution
Errors Feel Different With AI
When a traditional application fails, users usually know what went wrong.
A button didn't work.
A page didn't load.
A form rejected an input.
AI failures can be much less obvious.
The system may confidently misunderstand the user's intent.
That means AI products need to design for uncertainty.
Instead of pretending the system always knows the answer, the interface can expose uncertainty and offer ways to correct it.
For example:
“I think you want to cancel the subscription ending in 4821. Is that correct?”
That small confirmation can prevent a major mistake.
The Interface Becomes Dynamic
AI also makes interfaces more contextual.
A traditional dashboard may show the same controls to every user.
An AI-powered product can potentially surface different actions based on:
User intent
Role
Current task
Previous actions
Application state
Available data
The result can be less navigation and more task-oriented interaction.
But this requires strong product architecture underneath.
The UI needs access to reliable capabilities.
The AI needs permission boundaries.
The backend needs predictable APIs.
The system needs to know what actions are available.
From UX to AX
This is why a broader design conversation is emerging around Agent Experience, or AX.
UX asks:
How should humans interact with the product?
AX asks:
How should AI agents interact with the product?
The two aren't competing.
They are becoming connected.
An application might have a beautiful interface for humans while exposing structured capabilities for agents.
The challenge is designing both without compromising either experience.
GeekyAnts has explored this shift in its discussion of moving from UX toward AX as applications increasingly need to work in a world of AI agents.
https://geekyants.com/blog/from-ux-to-ax-designing-applications-for-a-world-of-ai-agents
APIs Become Part of Product Design
This is one of the less obvious consequences.
When an application is designed only for humans, the UI is the primary interaction layer.
When agents become users, APIs become much more important.
A good agent-facing API needs clear:
Inputs
Outputs
Permissions
Errors
State changes
Action boundaries
In other words, developers increasingly need to think of APIs as interfaces, not just technical plumbing.
Don't Remove the UI Too Quickly
There is a temptation to assume that AI will eliminate traditional interfaces.
I don't think that's likely.
For many tasks, conversational interaction will be excellent.
For others, visual interfaces will remain much better.
Imagine editing a photo, analyzing a chart, comparing financial options, or managing a complex calendar.
A screen can communicate relationships that words cannot.
The future may therefore be hybrid.
AI for intent.
Visual interfaces for control.
APIs for execution.
Trust Becomes a Design Feature
AI products have another requirement that traditional software didn't face to the same extent:
Users need to understand when the system is acting on their behalf.
That makes trust part of the interface.
Users need clear boundaries around autonomy.
They need ways to interrupt actions.
They need explanations when decisions matter.
They need recovery when something goes wrong.
The best AI interfaces may therefore feel less like chatbots and more like carefully designed control systems.
Final Thought
AI isn't simply adding another feature to application design.
It's changing the relationship between people and software.
For decades, users learned how to operate applications.
Now applications are increasingly learning how to understand users.
That doesn't mean screens disappear.
It means the role of the screen changes.
The interface becomes one layer of a larger system where humans express intent, AI helps interpret it, APIs provide capabilities, and software executes the work.
The next generation of product design won't be about choosing between UX and AI.
It will be about designing systems where both work together.
Top comments (0)