There's a design decision that appears in almost every AI-powered product launched this year. It's not a technical decision. It has nothing to do with the model chosen or the inference infrastructure. It's an interface decision, and it's the laziest one of all: putting everything in a chat box.
You open a data analysis tool, and there's a text box saying "Ask me anything." You enter a CRM, and there's a chatbot in the corner. You try a BI platform, and onboarding asks you to "have a conversation." The logic is always the same: LLMs are trained on dialogue-format text, therefore dialogue is the natural interface for AI. The conclusion couldn't be more wrong.
Because design isn't about projecting the system's internal architecture onto the user's screen. It's about understanding what task the user has, what cognitive load they're carrying, and which interaction modality reduces the most friction. Sometimes that's a chat. Often it isn't.
- Interface modality should derive from user context and intent, not from the underlying technology.
- Chat carries the highest cognitive cost of any modality: it forces users to articulate what they want before getting a response.
- There are at least four families of user intent for which chat is an actively poor choice.
The Problem: When Architecture Dictates UX
In the 1990s, early web editors generated HTML directly from word-processor-style interfaces because developers knew HTML better than typographic design. Nobody called that good design; it was simply what could be done at the time. Decades later, the software industry is making the same conceptual mistake: letting the system's internal capabilities determine how users interact with it.
With conversational AI, something similar happened. ChatGPT normalized the free-text input paradigm, and that paradigm has been transplanted without question into products where it makes no sense. The result isn't just suboptimal design: it's active friction. You force users to remember what they can and can't ask, to formulate queries correctly, to judge whether a response is accurate or hallucinated, to iterate in natural language when what they actually need is a filter or a button.
The conversational interface is the UX equivalent of telling users: "The system is complex; figure out how to use it." That's not user-centred design — it's model-centred design.
This connects directly to something we've argued before: the mistake of designing from the tool rather than from the user's goal. AI is an extraordinary tool, but projecting it as-is onto the screen isn't design; it's abdication.
The Four Intents That Chat Handles Poorly
Not every AI interaction deserves the same interface treatment. If we apply a basic JTBD filter — what specific task is the user trying to accomplish right now? — at least four intent families emerge for which chat is a genuinely bad choice.
Exploration without a defined question
The user doesn't know exactly what they're looking for. They want to explore a space of possibilities: trends in their data, patterns across a document set, ideas for a creative brief. In these cases, chat creates a cold-start problem: if you don't know what to ask, the empty text box is intimidating and, worse, unproductive. The right modality here is a visual surface that generates entry points — automatic clustering, contextual suggestions, heat maps over the data itself. AI works underneath; what's on top is shape, not text.
High-frequency repetitive tasks
The user executes the same action dozens of times a day: classifying a support ticket, tagging a document, approving or rejecting a suggestion. If each iteration requires writing a natural language instruction, the interaction cost is absurd. The right modality is minimum-action: a button, a swipe, drag-and-drop classification, with AI working in the background to pre-fill, prioritise or surface the right item. The user confirms or corrects; they don't "converse."
Flows with mandatory sequential steps
Some processes — customer onboarding, credit applications, technical configuration — have an order that matters and non-negotiable steps. Putting these in a chat produces two pathologies: the user skips steps because the system doesn't enforce them, or the system generates ambiguous responses because the conversation can go in any direction. A wizard with embedded AI that fills fields, validates in real time and suggests values is infinitely better than a chatbot "guiding" the user through the same process.
Trust and verifiability
When the decision has real consequences — medical, legal, financial — the user needs to audit the reasoning, not just read the conclusion. A chat that responds "The recommended dose is X" builds no more trust than the same text in a PDF. An interface that shows sources, decomposes reasoning into visible steps and lets the user explore the evidence creates a qualitatively different level of trust. This is especially critical in enterprise environments where traceability is non-negotiable.
In such environments, the design challenge goes beyond modality — it's about managing ambiguity at the interface level. AI amplifies ambiguity rather than resolving it when the interface isn't designed to contain it.
Modality: The Vocabulary the Industry Is Ignoring
Talking about "AI interface" as if it were one thing is like talking about "vehicle" without distinguishing between an ambulance, a delivery truck and a trials motorbike. Modality — the form in which the system receives and returns information — is a design dimension with its own rules, trade-offs and cognitive costs.
There are at least five relevant AI interface modalities that are not chat:
- Inline suggestion: AI proposes within the existing flow without interrupting it. GitHub Copilot is the canonical example; the user accepts or ignores without leaving their context.
- Reactive surface: the system analyses current context (open document, visualised data) and offers relevant actions without explicit user request. Notion AI attempts this with mixed results.
- Review interface: AI proposes, human decides. Useful for classification, moderation, prioritisation. The user validates at speed; the system learns from validation patterns.
- Augmented dashboard: visualisations generated or enriched by AI that the user explores non-linearly. AI selects what to show; navigation is visual, not conversational.
- Silent agent: AI operates in the background, executes tasks and notifies when something requires human attention. The primary interface is a notification inbox, not a chat.
None of these modalities is universally superior to chat. But each has conditions under which it clearly wins. The industry's problem is that these conditions are rarely evaluated; chat is chosen because it's familiar, because others have it, because it can be built quickly with available SDKs.
Choosing interaction modality is a strategic product decision, not a consequence of which AI model you've licensed.
How to Choose: A Three-Question Framework
At Room 714, when we audit AI-powered products, the first conversation isn't about the model or the API — it's about the task. And to move from task to interface modality, we use three questions that are fast to apply and force the team to inhabit the perspective of real users, not the imaginary user who writes perfect prompts.
How much does the user know about what they want?
If the user knows exactly what they want — "give me the summary of the January contract" — chat works well. If they don't — "I want to understand how my sales are going" — chat is a trap. Exploration can't be articulated in natural language before the exploration has happened; it's a circular paradox that only visual interfaces resolve.
How often do they repeat this action?
An action performed once a month tolerates a conversational interface with a learning curve. An action performed fifty times a day needs to be almost subconscious. Well-applied AI here is invisible: it reduces click count, pre-fills with precision, eliminates unnecessary steps. The risk of optimising only the visible surface when the problem sits in the full flow is especially acute in these high-frequency contexts.
What happens when AI gets it wrong?
If the cost of error is low and reversible, system autonomy can be high. If the cost is high or irreversible, the interface must be designed so the human always has visible control and the final decision. This isn't just a UX problem; it's a problem of systemic trust. A system that fails silently while the user chats away is a system that will eventually destroy confidence in the entire platform.
These three questions don't exhaust the design space, but they rule out 80% of the cases where chat is chosen by default without thought. And that 80% is exactly where UX debt accumulates — debt that teams pay later in the form of abandonment, low adoption and disproportionate support load.
The Standard That's Coming
It took the market about three years to understand that a responsive website wasn't "a website that also works on mobile" but a fundamentally different design approach. We're at an analogous moment with AI interfaces. The first wave — everything in a chat — is already showing signs of fatigue. More sophisticated users are starting to complain about conversational exhaustion, the cost of articulating every query correctly, the lack of structure when structure is exactly what they need.
The products that win over the next three years won't be the ones with the most powerful model underneath. They'll be the ones that rigorously thought through which interface modality best serves each user intent — and had the discipline not to solve everything with a text box because it was the fastest thing to ship.
If your product has AI and your first decision was "let's add a chat," it's worth spending half a day revisiting that decision from a JTBD perspective. Maybe chat was the right answer. Maybe it wasn't. At Room 714, we run that audit systematically before any AI product redesign: not to tear down what's been built, but to make sure the interface works for the user, not against them.
