What is AI UI?
AI UI is the practice of designing software where the interface is generated around a user's intent instead of pre-built around a screen. For decades, software met users where they were — switches became commands, commands became buttons, buttons became touch gestures. Every shift closed the gap between human and machine. AI is the first era where that flips. Language sits upstream. The interface gets generated downstream.
In practice, this looks like:
- An agent reading your data, role, and history and surfacing a dashboard tailored to you
- A prompt that returns a functional UI, not a wall of markdown
- An API call from an agent that replaces an entire human session
This is bigger than "adding AI." It's a rethink of what the product surface even is.
AI UI vs. AI chatbot UI
Chatbot UI is text in, text out. It's a conversation layer pasted on top of whatever your app already does. AI UI is structural — your product itself becomes something an agent can read, reason about, and render through.
AI UI vs. generative UI
Generative UI is the rendering layer — components composed on the fly. AI interface design is the whole stack: the APIs, the design system, the trust signals, and generated components as an output of all of it.
AI UI vs. agentic UX
Agentic UX is the slice of AI UI focused on what the agent needs: clean contracts, deterministic responses, structured data. Human-facing AI UI is the other half — oversight, explainability, trust. A full design for AI agents accounts for both.
Why chat is a compromise
Think about Google Flights. You open it, and you see a full month of prices on a calendar. You spot the cheap Tuesday, notice the expensive Fridays, weigh the trade-offs, and decide.
The chat version of Google Flights would say: "The cheapest date is October 14th for $280." That's a fact. A calendar is a picture. A picture gives you context and lets you make your own call. A fact just gives you a fact.
When teams swap a dashboard for a chat bar, they quietly trade visual density, comparison, and glanceability for the illusion of being modern. That's a patch, not a strategy.
The two failed patterns
Working with SaaS teams, I see two versions of "adding AI" that don't work.
One: bolting a chatbot onto an existing product. The workflows haven't changed. The information architecture hasn't changed. The chatbot is a fancier nav menu sitting on top of the same old structure.
Two: ripping out the dashboard and replacing it entirely with a chat. Bolder, but it swaps a powerful interface for a less powerful one. You lose the thing that made the interface useful in the first place.
Both start from the same flawed assumption: that the current product is the right foundation and AI is a feature you layer on top. It isn't.
What's actually changing
Three bigger shifts are already underway, and they reframe the whole conversation.
- Interfaces are shrinking. Before Amazon, you'd browse Nike, Adidas, a specialty running site, a Reddit thread — ten websites for one pair of shoes. Amazon collapsed that into one. Agents are about to collapse that one into zero.
- Agents are now your users. APIs already account for over 70% of web traffic, and AI tools are projected to drive 30%+ of API growth this year. Your product is no longer only serving humans.
- Your foundation becomes the ceiling. If AI generates the UI, your design system is the quality floor of everything it outputs. A weak token set or broken component library gets amplified at scale.
The four stages of AI UI
There's a progression happening, and most products are stuck at stage one. Mapping where yours sits is the first useful step.
Stage 1: Text
Plain text responses. Markdown. Walls of words. Most "AI features" shipped in the last eighteen months live here. A user asks, the model types back.
Where it fails: no structure, no glanceability. You can't scan it. You can't act on it quickly. It feels like AI, but it doesn't feel like a product.
Stage 2: Inline generative UI
Still a chat, but the response contains real components — forms, charts, tables, cards — rendered from structured model output. When I ask Claude for a recipe now, it often builds a small UI around the answer instead of dumping markdown. Every query renders something different. No two users see the same thing.
Where it's useful: you stop reading, start doing. One prompt, one working UI block.
Stage 3: Chat as a builder
The agent stops returning ephemeral components and starts writing persistent views. Instead of disappearing when the conversation closes, the interface saves back into the product. A report. A dashboard. A workflow template.
Where it changes things: chat becomes a creation surface for the product itself. The conversation is temporary. The output lives forever.
Stage 4: The interface composes itself
This is basically the opposite of stage one. You don't type anything. The agent already has your role, your data, your history — it assembles the product around you before you ask. You show up, and it's already working.
Chat still exists. You barely need it. And the product finally fits the mental model Don Norman called human-centered — it fits you, not the other way around.
How to retool your product for agents
You don't rebuild everything at once. But you do need to stop investing in the wrong layer.
At TDP, we work with funded SaaS teams to prototype what their product looks like once they take this shift seriously. We design with code, which means every idea ships as a working artifact a team can pressure-test. Here's the order that actually works.
1. Treat your API as the real product surface
Agents don't click buttons. They call APIs. If your endpoints are messy, partially documented, or missing actions that exist in your UI, an agent can't use your product — and a user with an agent will silently pick someone else's.
Ask yourself: if a developer had to rebuild your entire app using only your public API, could they? If the answer is no, agents will hit the same wall your third-party integrators do.
2. Harden your design system before you ship AI features
When AI generates your UI, the design system becomes the ceiling. Tokens, components, and patterns stop being nice-to-have hygiene and become the foundation every generated screen inherits from. A weak system produces weak AI UI at scale, fast.
If you're still shipping one-off components and Figma files that drift from the code, fix that before anything else. Every AI-generated interface you ship after that point will only be as good as what it's composing from.
3. Design for two users at once
You now have two customers inside your product: the human and their agent. The human needs oversight, explainability, and trust signals — was this reversible, who approved it, what changed. The agent needs clean contracts, deterministic responses, structured data.
Map both journeys. They're different products sharing the same foundation.
4. Pick one stage and ship it well
Don't leap from stage one to stage four. Find one workflow where an agent could compose a genuinely useful artifact — a tailored report, a setup wizard, a recommendation view — and build that one well. Learn from it. Move to the next.
5. Invest in taste, not velocity
The only thing that matters when AI can build anything is knowing what to build. That's judgment. That's taste. That's understanding the user deeply enough to design the right system around them.
Most teams have spent years getting better at building. Almost nobody has spent that time getting better at knowing what to build. The gap between those two skills is about to be the only gap that matters.
What survives when interfaces disappear
The common reaction when people hear "you won't need interfaces" is that design is dead. It's the opposite. When AI can build any screen and ship any flow, the only thing left that matters is knowing what to build.
That's the point Don Norman made in The Design of Everyday Things — design isn't buttons and dropdowns. It's every door handle, every light switch, everything you know how to push or pull without thinking. That intuition, knowing how to make something feel obvious, is what's left when AI handles the building. And it's going to matter more, not less.
A few resources we point teams to when they're working through this:
- The Design of Everyday Things by Don Norman — still the clearest articulation of what "designed for humans" actually means
- Apple Human Interface Guidelines — useful baseline for what a mature design system carries
- Anthropic's docs on tool use and structured output — for teams prototyping agent-ready APIs
Marc Andreessen made the point I keep coming back to. Not long ago, 99% of humanity was behind a plow. The world spent generations asking what people would do when farming disappeared. The answer was everything worth doing now. The keyboard is the next plow. What remains is the quality of what you want.
Work with us
If you're a founder or head of product looking at your SaaS and wondering how to navigate this shift, let's connect. We'd love to help you think it through.
