Beyond Chat: Designing AI Interfaces That Actually Work

The Problem with Chat

Ethan Mollick’s recent piece Claude Dispatch and the Power of Interfaces (March 31, 2026) makes a compelling case that AI’s biggest bottleneck isn’t capability — it’s the interface. He cites research showing that financial professionals using a chatbot for complex valuation tasks experienced significant cognitive overload: walls of text, sprawling discussions, and an AI that mirrored back whatever disorganized structure the user provided. The productivity gains from AI were partially offset by the mental tax of navigating the chatbot itself. Less experienced workers — the ones who stood to benefit most — were hit hardest.

Mollick identifies three emerging interface paradigms: specialized tools built for specific professions (like Claude Code for developers), personal agents that work on your actual files through familiar channels (like Claude Cowork with Dispatch), and interfaces-on-demand where the AI generates the right UI for the moment. His core observation is that much of what people experience as “AI disappointment” is actually interface disappointment. We built one of the most powerful technologies in recent history and made people access it through a chat window.

This has broad implications for anyone designing AI-powered products. If chat is the obstacle, what replaces it?

A Deeper Principle

Before exploring specific patterns, it’s worth stating the principle that connects them all: the best AI interfaces are defined by their output shape, not their input method.

Chat fails because the output is unbounded prose. The AI produces five paragraphs that contain the answer somewhere, then offers three new directions the user didn’t ask about. The user’s brain has to do the work of parsing, prioritizing, and structuring — which is exactly the work they were hoping the AI would handle.

Every effective alternative constrains the output into something the human brain can process quickly: a table, a diff, a ranked list, a filled template, an annotated document, a dashboard. When we design AI features, the first question shouldn’t be “how does the user talk to the AI?” It should be “what does the user need to see to make their decision, and what’s the minimum interaction to get there?”

That answer is the interface — and it’s almost never a chat window.

Five Emerging Interface Patterns

We’ve identified five patterns for AI interfaces that move beyond chat. Each reduces cognitive load in a different way, and most real-world applications will combine several of them.

1. AI-Augmented Workflows

The AI lives inside an existing process. The user never “talks to AI” — intelligence shows up as enhancements embedded in something they’re already doing. Think autocomplete in a code editor, or smart suggestions surfacing in a spreadsheet. The interface is the workflow itself.

The design principle: don’t create a new destination for AI. Inject intelligence into the surfaces people already use. The user shouldn’t have to context-switch to get the benefit.

Example: A financial analyst opens a portfolio company’s data and the system has already flagged anomalies, identified stale figures, and surfaced comparable transactions — no prompt required.

2. Structured Input → Rich Output

Instead of “ask me anything,” provide a purpose-built input surface. A well-designed form with five fields can capture more useful intent than twenty turns of chat. The key insight is that constraining the input isn’t limiting — it’s clarifying. It forces the system to understand the task precisely and produce output shaped to the task.

The design principle: replace open-ended prompts with scoped, task-specific inputs. Let the user express intent through selections, uploads, and parameters rather than natural language.

Example: For contract analysis, the user drops a document, selects an extraction template, and receives structured output with confidence scores and flagged ambiguities — no natural language prompting required.

3. Canvas / Workspace

The AI manipulates objects, not text. Instead of describing what you want in a conversation, you work with visual artifacts — data models, layouts, scenarios — and the AI operates on those objects alongside you. The interaction is spatial and visual.

The design principle: give the user and the AI a shared workspace of manipulable objects. Let the conversation happen through direct interaction with those objects rather than through language.

Example: An investment portfolio workspace where the AI clusters holdings by risk profile along axes the user defines. The user drags, reweights, and explores scenarios visually. The AI recalculates and suggests alternatives in real time.

4. Agent with Structured Reporting

The AI acts autonomously, but its output isn’t a chat message — it’s a structured deliverable. A morning briefing, an updated presentation, a reconciliation report. The agent runs, does the work, and presents results in a predefined format that the human reviews.

The design principle: separate the doing from the reviewing. The AI acts first; the human verifies after. The critical design choice is that the output has a defined shape — the human reviews a document or dashboard, never a chat transcript.

Example: An autonomous agent runs overnight, pulling the latest market data, updating analytical models, and producing a structured memo. The analyst’s morning starts with a completed draft to review, not a blank prompt to fill.

5. Decision Interfaces

The AI doesn’t give you an answer — it gives you a curated set of options with tradeoffs. This respects the human’s role as decision-maker. Instead of prose recommendations, the user sees ranked alternatives with the specific dimensions that differentiate them.

The design principle: narrow the decision space without making the decision. Present options, highlight tradeoffs, and let the human choose with full visibility into what drives each option.

Example: In data reconciliation, instead of “I think these records match,” the system presents three candidate matches ranked by confidence, with the specific fields that differ highlighted. The analyst clicks to confirm or override.

Applied Example: AI-Powered M&A Due Diligence

To make this concrete, consider how these patterns combine in a single workflow — buy-side due diligence on an acquisition target. This is a domain that’s analytically complex, time-pressured, and currently painful in ways that chat doesn’t solve.

Today, a deal team doing due diligence ingests hundreds or thousands of documents from a virtual data room — financial statements, contracts, customer agreements, employment records, IP filings, litigation history, regulatory correspondence. Analysts manually read through these documents, flag risks, cross-reference findings across sources, and compile everything into a structured diligence report. The work is a brutal combination of reading comprehension at scale, pattern recognition across disparate sources, and judgment about materiality. A chatbot doesn’t fix this; asking an AI “what are the risks in this data room?” produces an answer so generic it’s useless, and asking document-by-document is just a slower version of reading them yourself.

Here’s what a non-chat interface could look like, layering the patterns above:

The AI processes the data room before the team starts reviewing (Pattern 4). When the deal team opens the diligence workspace, an agent has already ingested every document in the data room, classified them by category (financial, legal, operational, HR, IP), extracted key terms and provisions, identified potential risks, and cross-referenced findings across documents. The team’s first interaction is navigating a structured map of what the data room contains and what the AI found — not uploading files into a chat window one at a time.

The output is an interactive risk landscape, not a report (Pattern 3). A multi-panel workspace organizes findings by diligence category. One panel shows a document inventory with classification and processing status. Another presents extracted risks as a visual map — clustered by category, sized by potential materiality, colored by confidence level. A third panel shows the cross-reference graph: which findings are connected across documents (e.g., a revenue concentration flagged in the financials that also appears as a key-customer dependency in a contract). The deal team navigates a spatial landscape of risk, not a linear document.

Interaction happens through direct manipulation (Pattern 1). The analyst clicks on a flagged risk to see every source document that contributed to it, with the relevant passages highlighted in context. They can reclassify a finding by dragging it between categories, mark it as immaterial with a single click, or escalate it to a senior reviewer. When they need to ask a question that can’t be expressed through the UI — “check whether any of the customer contracts have most-favored-nation clauses that would be triggered by the acquisition” — a scoped query input appears, constrained to the data room’s contents and returning results as structured findings, not prose.

Exceptions drive attention (Pattern 5). Instead of reading every document equally, the interface surfaces a prioritized list of items requiring human judgment: provisions the AI couldn’t confidently classify, contradictions between documents (a financial projection in the management presentation that doesn’t match the audited statements), and unusual terms that fall outside normal patterns for this deal type. The deal team spends their time on the 15% of the data room that actually requires expertise, not the 85% that’s routine.

The diligence report assembles from the team’s decisions (Pattern 2 + 4). Every risk the team confirmed or dismissed, every reclassification, every escalation — all captured automatically. The AI generates a draft diligence report organized by standard workstream categories, with each finding traced back to its source documents and the team’s disposition. The lawyers and bankers review and edit a structured deliverable, not a chat log.

The result: the deal team’s job shifts from “read the data room and find the risks” to “review the risks the AI found and decide which ones matter.” The interface respects their expertise by surfacing judgment calls and materiality decisions, while eliminating the weeks of mechanical document review that chat was never going to replace.

Why This Matters Now

The gap between AI capability and AI usability is the central bottleneck in enterprise AI adoption. Most organizations are deploying AI as chatbots — adding a text box to existing products and calling it an AI feature. The research Mollick cites suggests this approach is actively counterproductive for complex knowledge work.

The organizations that move past chat-as-default and design interfaces around domain-specific workflows will see disproportionate results — not because their AI is smarter, but because their users can actually leverage what the AI is capable of. As Mollick puts it, every new interface that closes even part of the capability-accessibility gap will feel like a leap in AI capability, even when the underlying models haven’t changed.

Programming has Claude Code. Design has emerging tools like Stitch. The vast landscape of professional knowledge work — finance, legal, healthcare, engineering — is still waiting for its equivalent. The teams that build those interfaces first won’t just have better AI features. They’ll have redefined what work looks like in their domain.