Against the Empty Prompt Box

Dashboards do not make decisions. Neither do summaries.

Both are forms of compression: they collapse messy work into a cleaner surface. A dashboard turns a business into charts; an LLM can turn a research question, product problem, or writing task into fluent text. Compression is useful. But knowledge work depends on turning information into judgment. This goes beyond finding facts, to interpreting them, testing them, and making them usable in decisions. The research is clear on this: processing information is a necessary part of creating knowledge, but only a part. When we stop there, we run into trouble.

This failure mode is easy to see inside companies. Salesforce activity, product analytics, support tickets, finance forecasts, and web traffic get piped into one executive view. In theory, everyone can now see the state of the business. In practice, a churn spike or a drop in onboarding completion still has to be interpreted. Someone has to ask whether the metric is trustworthy, connect it to customer conversations, decide which team owns the problem, try an intervention, and learn from the result. When that does not happen, the executive view becomes a well-maintained display case for information that never hardens into judgment.

The alternative is not to reject compression, but to build interfaces that keep the rest of the work in view. The useful precedent is HyperCard, Apple’s 1987 software environment built around stacks of cards. Not because we should recreate it, but because it points toward a different kind of AI interface: an environment where reading, arranging, authoring, and programming are distinct moves a person can fluidly combine.

To see why that pattern matters, start with the distinction the prompt box blurs: compression versus augmentation. Compression collapses a larger process into a smaller representation, such as a chart, a summary, a score, a dashboard, or a recommendation. That can be useful. Nobody wants to inspect every row of every spreadsheet before making a decision. But knowledge creation is full of sticky, friction-full steps that cannot simply be compressed away: tacit judgment, explicit artifact creation, recombination across sources, action, feedback, and learned practice. Augmentation is different. In Doug Engelbart’s classic formulation, augmenting human intellect meant increasing a person’s ability to understand complex situations and derive better solutions, with tools, methods, language, and training treated as one system. Augmentation preserves room for those steps. It gives people better handles on the work instead of pretending the work has disappeared.

AI accelerates compression. You can see it in the amount of AI-generated stuff that gets spun up and then immediately abandoned: summaries nobody rereads, plans nobody follows, notes nobody integrates, draft documents that briefly feel useful and then turn into clutter. This workslop looks complete enough to send but lacks the context, specificity, or judgment needed to move the task forward. A dashboard compresses a set of metrics into one surface; an LLM can compress almost any knowledge task into the same surface. Prompts implicitly combine many different moves: articulating intent, gathering materials, choosing a frame, producing new artifacts, revising prose, and sometimes writing tools. That makes AI especially powerful for combination tasks like summarizing, recontextualizing, and rewriting. It also makes the loss of process harder to see.

The cognitive problem is not that AI produces bad text. Often it produces very good text, or at least very plausible text. The problem is that looking at a fluent answer is not the same as seriously engaging with information. In a 2025 Microsoft Research study, higher confidence in generative AI was associated with less critical thinking, while higher confidence in one’s own ability to do the task was associated with more. The researchers also found that AI shifts critical thinking toward verification, integration, and task stewardship. That maps closely to the compression problem: when the system has already chosen the frame, selected the evidence, and composed the synthesis, the user’s work can shrink to acceptance, light editing, and taste. Those are real forms of judgment, but they are not the whole process. They do not force the user to notice gaps, compare alternatives, test assumptions, or build the kind of internal model that survives after the output disappears.

There’s nothing that says tools have to work like this, though.

We know how to give people productive friction, in the form of scaffolding. Scaffolding sets defaults, allows people to deepen their engagement with a system or area of knowledge at their own pace, and makes clear what kinds of tasks a person is working on at any given time.

One of the things that made HyperCard so powerful was that it scaffolded movement between modes. This maps onto Ink & Switch’s argument for malleable software: instead of treating people as passive recipients of finished applications, tools should let users gradually become editors and creators. HyperCard allowed people to explicitly work on a gradation from consumer to producer: they could read card stacks, they could author and design them, or they could script new features into the application itself. Each mode came with a different relationship to the material, and the interface made those differences visible.

People scaffold their work all the time with software. We turn to a PDF reader, a CMS, a web browser, and an IDE for different things at different times because they support different stages of knowledge creation. Reading implies one posture; drafting another; publishing another; programming yet another. The problem with a universal AI surface is that it compresses these postures into one prompt box. To do deep knowledge work with AI, we need to put the scaffolding back.

The design question, then, is not whether AI belongs in knowledge work. It is where AI belongs, and what kind of human activity its interface preserves. Returning to the HyperCard pattern, we can imagine useful AI assistance across four layers: reading, authoring, scripting, and supervision.

Reading: AI should help with triage without erasing the reader’s own reactions. A serious reading system might maintain connectors to the sources a person already trusts, suggest new sources that fit the project, and sort incoming material into explicit queues: read this in full, read these excerpts, let an agent summarize it, or skip it. It might add flexible metadata as the user’s needs change: classify sources against a constrained vocabulary, tag every mentioned company in a relevant sector, or attach relevant outside context. Most importantly, it would preserve the reader’s own notes and comments as first-class work.

Authoring: AI should act like an editorial collaborator inside the writing surface. It could pull in resources to strengthen or challenge an argument, find concrete examples for an abstract point, or surface places where the draft is leaning on an unsupported claim. It could offer feedback in the familiar language of suggestions and comments, but driven by priorities the author names: be skeptical about causal claims, flag jargon, look for missing counterexamples, tighten the structure. And when the writer is stuck, the tool could provide constrained prompts for the particular problem at hand, rather than trying to take over the whole act of writing.

Scripting: The user starts shaping the system’s behavior. That might mean editing schemas: adding a feedback type, changing the metadata fields attached to sources, or deciding what counts as an unresolved objection. It might mean defining reusable workflow recipes, like “when I save a paper, extract its claims, methods, caveats, and useful citations,” or “when I draft a post, run adversarial review, example search, and a style pass.” It might also mean creating custom views over the same underlying material: show all unresolved objections to this essay, show sources that support a claim but have not been cited, or show abandoned threads where I once had high enthusiasm.

Supervision: Delegated work has to remain intelligible and manageable. A serious system would keep agent work in a clear queue of active, pending, blocked, and completed tasks. It would prevent the workspace from filling up with stray AI-generated markdown files. And it would audit outcomes over time: which agent-generated notes were later cited, which summaries were never opened, which automations created clutter, which delegated tasks actually improved the project.

We do not know what serious, boundary-pushing knowledge work will look like in five years. That uncertainty should make us more demanding, not less. The future should not be an empty prompt box that compresses every task into the same gesture. It should be a set of systems that help people read, make, revise, automate, and supervise while preserving the work of understanding.