Chat Interfaces Are Not Enough

The Thesis

Chat is a default, not a deliberate design choice. Most AI-powered products would be meaningfully better if they dropped the chat box entirely and built something that actually fits how their users work.

This is not an argument against conversational AI. It’s an argument against the lazy pattern of wrapping a model in a text input and calling it a product. Those are different things, and conflating them is costing your users time, eroding retention, and leaving real capability on the table.

How Chat Became the Default

In November 2022, OpenAI shipped ChatGPT with a chat interface. It was the fastest consumer product to 100 million users in history. Every product team on Earth spent the next six months asking the same question: “How do we add this to our product?”

The answer they gave themselves, almost universally, was: “Add a chat box.”

This made sense as a fast response to a platform shift. The problem is that it hardened into a template. Three years later, “add AI to the product” still defaults to “add a sidebar chat.” Not because anyone thought carefully about whether chat is the right interaction model for their use case. Because ChatGPT used chat, so chat is what AI looks like.

That’s not product design. That’s cargo culting.

OpenAI itself chose chat because it maps naturally to their actual use case: a general-purpose assistant with no defined task, no structured output, and no existing UI to integrate with. Chat is the right interface when you don’t know what the user is going to ask. Most products are not in that situation.

Where Chat Actually Works

Let’s be precise. Chat is a good interface in a narrow set of conditions:

Open-ended exploration. When users genuinely don’t know what they need, or when the problem space is too broad to predict in advance, free-form input is appropriate. Research tools, general assistants, and exploratory analysis fall here. Perplexity is a good example — but notice that even Perplexity layers structured outputs, source cards, and related questions on top of chat. The text input is a starting point, not the whole product.

Complex, multi-turn reasoning tasks. When a task requires going back and forth, clarifying requirements, iterating on output — chat captures that naturally. Writing assistance for long-form content, code debugging with multiple iterations, or anything where context accumulates over a session is a reasonable fit.

Low-frequency, high-stakes queries. If users come to your product occasionally with genuinely diverse needs, chat buys you coverage. You can’t build a dedicated UI for every edge case.

Notice the pattern: chat works when the task is genuinely unconstrained and conversational. Most products have structured, repeatable, high-frequency tasks. Those are not what chat is designed for.

Where Chat Is the Wrong Interface

This is the larger category, and it’s where most products are making the mistake.

Task completion flows. If your AI feature helps users complete a defined task — filling out a form, generating a report, creating a first draft of something with known inputs — chat is friction. The user doesn’t want to describe the task in natural language. They want to click through a flow and have AI do the hard part invisibly. Every extra round-trip in a chat interface is a failure of design.

Structured workflows. Linear doesn’t let you chat with your backlog. It uses AI to auto-triage issues, suggest assignees, and surface priorities inline — directly in the list view, in context, without mode switching. That’s the right call. Forcing users to context-switch into a chat sidebar to ask “what should I work on next?” adds friction to a question that should have an ambient answer.

Ambient AI. The best AI features in a product are ones you barely notice. Autocomplete in Gmail. Spell-check that just works. Code suggestions in Copilot appearing inline as you type. These are not chat. They’re AI embedded in the task at hand, triggered by what you’re already doing, returning output in the place you’re already looking. Chat requires attention; ambient AI earns attention by being useful where you already are.

Co-pilots for expert workflows. Cursor is the clearest example of getting this right. The chat panel exists, but it’s not the primary interface. The primary interface is the diff view. You describe what you want, the agent makes changes, and you see the result as a code diff you can accept or reject. The interaction is fundamentally about reviewing proposed changes to artifacts — not about having a conversation. A chat box would be the wrong frame for what Cursor actually does.

The Cost of Chat

The chat paradigm has real costs that are easy to underestimate.

Cognitive load. Writing a natural language prompt is harder than clicking a button or filling a structured form. Every time a user has to translate what they want into a paragraph, you’re adding a tax. For expert users with repetitive workflows, that tax compounds quickly and drives churn.

Context loss. Chat sessions are ephemeral unless you explicitly engineer persistence. Most chat implementations lose context between sessions, across features, and between team members. Users end up repeating themselves constantly. The conversational metaphor implies memory that most implementations don’t actually have.

Blank page problem. A chat input with a blinking cursor is maximally open-ended and minimally helpful. Users who aren’t sure how to phrase a prompt — which is most users, most of the time — get stuck. Structured UI elements (suggested prompts, affordances, menus) dramatically improve task completion rates. Chat throws those guardrails away.

Output placement. Chat responses land in the chat window. If the user needs to move that output somewhere — into a doc, into a field, into a codebase — they have to copy-paste. That’s a seam. Good product design eliminates seams. Inline AI output, diff-based review, and direct-to-field generation all cut this step out entirely.

Retention problems. A chat interface gives users no visual sense of progress or accumulated value. A canvas, a timeline, a structured output view — these create artifacts users return to. Chat creates conversation logs. Most users never re-read a conversation log. They do return to a well-organized project canvas.

Alternatives Worth Building

Here are the interaction patterns that actually work for AI features in products:

Inline suggestions. GitHub Copilot established the template: AI output appears in place, in context, as you work. You accept or reject without breaking flow. This pattern works anywhere users are producing content — writing, coding, data entry. Notion AI’s inline generation and rewriting is a good example outside of code.

Structured AI forms. Instead of asking users to describe what they want in natural language, give them a form with smart defaults and AI-populated fields. AI does the heavy lifting behind a familiar interface. This dramatically reduces prompt-engineering burden on users and produces more consistent outputs. It’s underused.

Command palettes. Raycast’s AI features and VS Code’s command palette are both examples of AI invoked through a fast, keyboard-driven interface. The user selects an intent from a structured list rather than composing a prompt. This trades flexibility for speed and predictability — often the right tradeoff.

Background agents. Not every AI task needs a synchronous interface at all. Linear’s AI triage runs in the background and surfaces results in the normal workflow. Email drafting assistants that work overnight. Agents that monitor repos and open issues. These require robust async UI patterns — progress indicators, audit logs, correction flows — but they match how AI is actually most useful: doing work without requiring the user to babysit a chat window.

Canvas interfaces. When the output is a complex artifact — a document, a design, a codebase — a canvas that shows the artifact directly is almost always better than a chat thread. The user sees what they have, not a log of how they got it. Cursor’s diff view is one version of this. Tools like v0 and Bolt are another: the generated UI renders in a panel alongside the prompt, and iteration is about the artifact, not the conversation.

The Companies Getting This Right

Cursor built an IDE where AI is deeply embedded in every operation — completion, generation, explanation, refactoring — but the primary interaction surface is the code diff, not a chat thread. The chat panel is there for complex multi-turn tasks, but it’s not the default mode of working with AI.

Notion AI understood that writers don’t want to switch contexts. AI features appear inline, triggered by a slash command or a highlight, returning output directly in the document. The document, not a chat window, is the interface.

Linear could have built an AI sidebar. Instead, it used AI to power features that live entirely within the existing product structure: issue triage, priority suggestions, auto-labeling. You don’t interact with the AI; you interact with your backlog, and the AI makes it better.

Perplexity kept the chat input but spent serious effort making the output structured — source cards, follow-up questions, structured summaries — so the result is browsable, shareable, and useful beyond the session. The chat interface is a starting point into a structured information architecture, not a terminal.

The Question to Ask

Before you build a chat interface for your AI feature, ask this: what does the user actually need to accomplish, and does a conversation help them accomplish it faster?

If the task is structured, high-frequency, or embedded in a larger workflow — the answer is almost always no. Build a form, build inline suggestions, build a background agent, build a command palette. Design for the task.

Chat is a legitimate interaction model. It’s not a universal one. The products that figure this out early will have significantly better UX, better retention, and a clearer story about what their AI actually does — compared to the ones that are still trying to explain what to type in the chat box.

Most AI products are too easy to ship and too hard to use. The chat box is a big part of why.