Reasoning Surface

A reasoning surface is the UI layer that broadcasts the model's internal logic as it runs. It renders plans, ranked steps, source evaluations, or structured thought summaries in streaming prose the user can actually read. Instead of dead space or a spinner the surface ships concrete signals like first I will map the current component tree then isolate unused props then propose three refactored variants. The first reasoning token lands under 800 milliseconds. Subsequent updates flow at 30 to 60 tokens per second so the user stays glued instead of checking Slack. This pattern sits at the center of the perceived speed stack. It composes with streaming text that delivers the final output, optimistic UI that commits changes early, progressive disclosure that skeletons the layout, and background agents that move heavy work to a side panel. Fifteen seconds of visible reasoning beats three seconds of black box because the user measures progress in information density not wall clock time.

What it is not is a dressed up spinner. It is not the rotating thinking text loop that every mediocre AI product shipped in 2023 and users learned to ignore by week two. It is not a raw debug dump of the model's unfiltered tokens or a modal that freezes the entire canvas while the model pontificates. Those four failing patterns hide information. A real reasoning surface distills it. It cuts repetition, translates jargon, ranks the useful bits first, and lets the user expand or collapse without losing context. It never pretends to think. It shows actual subprocesses the model ran and the conclusions it drew at each stage. Anything less is theater.

Cursor shipped the clearest concrete example in 2024 with its agent mode. A frontend engineer pastes a prompt to rebuild their authentication flow across seven files. Within 600 milliseconds a reasoning surface appears in the side panel with a numbered plan. Step one parses the existing OAuth implementation. Step two inventories every place session state is mutated. Step three cross references against the new security spec. Each bullet streams live updates. When the model discovers an undocumented edge case the surface inserts a new step four and explains why it matters. The engineer reads along, spots a missing requirement, types a correction into the chat, and watches the plan adjust in real time. By the time diffs land optimistically in the editor the human already trusts the output. The same ten minute task hidden behind a modal spinner would have driven them to coffee and back. Here the latency became pair programming.

ChatGPT's o1 rollout later that year gave every designer a second benchmark. Ask it to audit a pricing page for conversion leaks and the interface shows a thinking header that expands into full paragraphs. The model writes I am simulating three user personas then scoring each pricing tier for friction points then prioritizing fixes by expected lift. The text arrives in readable chunks. No token salad. Full sentences a human editor could have written. Product teams started copying these traces into Notion specs because they revealed exactly where the model made assumptions. Claude added project level reasoning surfaces in 2025 that list which files it pulled from a 400 page codebase before suggesting changes. Perplexity streams its research plan first with live relevance scores on each source. Linear AI surfaces dependency graphs and risk flags when breaking epics into issues. Every strong example follows the same rule. Make the wait carry information the user values more than the final answer.

Use reasoning surfaces on any task longer than ten seconds or where trust is the primary UX currency. Complex code changes that touch production. Research that pulls from multiple live sources. Strategic recommendations that affect team roadmaps. They belong in side panels or collapsible accordions so they enhance without blocking. Pair them with background agents and the user keeps shipping in the main canvas while the reasoning updates in the corner. Test the language ruthlessly. If users skip the trace every time then the surface failed its job.

Skip reasoning surfaces on trivial queries that resolve under two seconds. A one line summary or simple autocomplete needs no window into the sausage factory. Avoid them in mobile consumer apps where screen space is tight and expectations are instant. Never use one as a band aid for a lazy system prompt that produces incoherent thoughts. Fix the model upstream first. And do not expose reasoning when it risks leaking private data or violating compliance rules in regulated domains.

Reasoning surfaces turn the slowest part of AI into its most persuasive feature.