The quiet death of the prompt: how interfaces eat the model.
For two years, the prompt box was the only UI we had. As capabilities grew and latencies shrank, it stopped being the right metaphor.
The prompt box has had a remarkable run. In late 2022 it arrived as a near-religious artifact — a humble <textarea> that doubled as the entire affordance for the most general piece of software anyone had ever shipped. By mid-2024 it was the default UI of a generation of products. By 2026, it has started to feel old.
Not bad. Not broken. Just old in the specific way that command lines feel old when you've used a good GUI: still respected, still preferred by some, still the right answer for narrow tasks — but no longer where the action is.
This essay is about what comes next, and why the question is mostly architectural rather than visual.
The prompt was always a constraint, not a feature
Look at any 2023 chat product and you'll find an onSubmit handler that turns a string into an HTTP call and then renders a stream of tokens back into a div. The interface is a thin layer wrapped around a single generative endpoint. Every “feature” — citations, tools, search, image upload — is bolted on as either a system prompt suffix or a JSON schema response.
This was a forced move. When models were slow, expensive, and unreliable, the simplest possible UI was also the safest. A prompt box let users self-route through their own intent. The product didn't have to know what the user wanted; the user just typed it.
A prompt box is a confession that the product team can't decide what the model is for.— vercilo, essay №34
That confession was honest in 2023, and increasingly less honest now. We know what the model is for. We're using these things every day. The prompt box is a hangover from a moment when we genuinely didn't.
Three things that broke the metaphor
I'd argue three quiet shifts have pushed us past peak prompt:
- Latency collapsed. When a request takes 80ms instead of 8 seconds, you stop wanting to compose it. You want to try things.
- Tools became the API surface. The interesting capabilities of a 2026 model are composed capabilities — search, code, search-then-code, etc. Each of those wants its own affordance.
- Long-running work became normal. Agents that take 90 seconds to think need a UI that respects that. A “send” button does not.
None of these are visual problems. They're shape-of-the-system problems. The prompt box is what you build when your system is shaped like one big request and one big response.
What replaces it
I think there are three families of post-prompt interface, and they're each a few years away from production-grade. Briefly:
1. Direct manipulation, restored.
The first family looks a lot like the GUIs of the late 1990s. You see your data, you click on parts of it, and the model is invoked through verbs attached to those parts. Spreadsheets are the obvious early form. The interesting products are not chat windows with tools — they're tools with chat windows tucked inside them.
2. Inline, ambient assistance.
The second family is the one most people see daily without naming it: the squiggle under your sentence, the autocompleted commit message, the “explain” that appears when you select something. There's no prompt because you didn't ask. The product asks on your behalf.
3. The agent as a coworker, not a chatbot.
The third — still the rarest — is the long-running, surface-less agent that you assign work to and check on later. The interface is closer to a project tracker than a chat. You don't prompt it; you brief it. The reply is a set of artifacts, not a paragraph.
// A brief is a contract: scope, deliverables, exit conditions.
// The model owns the loop; the UI owns the framing.
type Brief = {
scope: string;
inputs: Resource[];
deliver: (a: Artifact) => Promise<void>;
stopWhen: (s: State) => boolean;
};
async function run(b: Brief) {
let s = init(b);
while (!b.stopWhen(s)) {
s = await step(s); // 1 turn of work
if (s.artifact) await b.deliver(s.artifact);
}
return s.summary;
}The contract above is more or less the smallest agent UI I can imagine that's actually useful. Note what it does not have: a prompt, a chat history, a model name, a parameter slider. Those things are implementation details of step(), not user-facing concerns.
Why this is hard, mostly
If the only thing standing between us and the post-prompt era was a few good Figma files, we'd have shipped it by now. The reason we haven't is that all three replacement families demand the model be embedded in a system whose shape is not request/response. Agents need durable state. Inline assistance needs typed selections. Direct manipulation needs the model to know what it's looking at.
None of those are model problems. They're systems problems wearing model-problem hats — and the teams that figure them out first will set the visual vocabulary of the next decade.
A short list of things to try
- Stop calling your text input a prompt. Call it what it is — a query, a brief, a comment, a search.
- Treat your tools as first-class. If a verb deserves its own button, give it one.
- Expose state. The user should be able to see what the model can see, and edit it.
- Make latency a design surface. Sub-100ms calls should feel different from 5-second ones.
- Think in artifacts, not threads. Threads are conversational; artifacts are owned.
None of this is a prediction that chat interfaces die. They won't. They're a wonderful general-purpose pencil and they'll keep being a wonderful general-purpose pencil. But the next interesting AI products will not be chat-shaped, and the teams still investing their entire product surface in a textarea are going to wake up in 2027 wondering where the rest of the category went.
Let me know what you build.