You have probably lived this moment. You have been thinking about a problem for weeks. You know the constraints. You know the audience. You know exactly what a successful outcome looks like. So you open a chat window and you write a prompt that makes complete sense to you. It is direct. It is clear. You hit return.
The machine thinks for three seconds and hands you back something that is technically responsive to exactly what you typed, yet manages to completely miss the point. Generic and flat, it solves a problem you do not actually have.
What happened is Invisible Context at work. Your prompt broke because of the words you left out: the constraints and assumptions you did not explicitly name because they were so obvious to you that saying them out loud felt entirely unnecessary.
In 1990, a Stanford psychology graduate student named Elizabeth Newton ran a study that explains why this happens (I read about this in Made to Stick). She divided participants into two groups: “tappers” and “listeners.” The tappers were asked to tap out the rhythm of a well-known song, like “Happy Birthday,” on a table. The listeners had to guess the song based only on the taps.
Before the experiment, Newton asked the tappers to predict how often the listeners would guess correctly. The tappers predicted 50 percent. The actual success rate? 2.5 percent. The tappers could not understand why the listeners were failing. When a tapper taps, they hear the full orchestration of the song playing in their head. The listener just hears a series of disconnected, arrhythmic knocks on a table.
When you interact with an AI, you are always the tapper. You hear the full orchestration of your context. The machine is the listener, it just gets the taps. And because you cannot hear the silence between your own taps, your context remains invisible to you and anyone else needing to build the tools that you are developing.
Writing longer prompts will not fix this! Let me say it again, because I think our natural inclination is to simply say if I get all the context down everything will be well because we can just supply all the missing context. So, remember, writing longer prompts will not fist this. Instead, we all need to focus on learning to see our own assumptions before we type them. That is a different skill than just trying to brain dump everything in our head that is providing context. Luckily, it is also a skill that can be practiced. And this bot is one way to do that practice.
What the Machine Does With Your Gaps
When you leave gaps in a conversation with a human colleague, it usually works out fine. The philosopher Paul Grice spent his career mapping how human communication relies on cooperative inference. If you ask a colleague to “draft the quarterly update,” they do not start from zero. Instead, they know how the last update sounded. They know the current crisis facing the board. They use shared context to repair your underspecified request, filling in the blanks with institutional memory and interpersonal understanding.
A language model does no cooperative inference. As Bender, Gebru, McMillan-Major, and Mitchell laid out in their 2021 paper “On the Dangers of Stochastic Parrots,” a large language model is fundamentally an engine for next-token prediction. When you give it an underspecified request, it repairs the gaps statistically. It looks for the most probable continuation of your words across everything it has ever read, flattened into one probability distribution.
This means the machine will always fill your gaps with the statistical average of everyone’s context rather than your own. An LLM will essentially default to mean output: what most people mean when they write something that looks roughly like what you wrote. If your problem is specific, the statistical average is exactly what you do not want. In fact, in almost every case the statistical average is something you might only want as a reference but not the final product of your thinking.
The chat interface makes this worse, and the reason runs back to a promise made at the very beginning of the field. In August 1955, John McCarthy, Marvin Minsky, Nathaniel Rochester, and Claude Shannon submitted a funding request for a summer workshop at Dartmouth College. That document is where the term “Artificial Intelligence“ was coined. Four years later, in the proceedings of a symposium at Britain’s National Physical Laboratory, McCarthy spelled out what he actually had in mind. The paper was called “Programs with Common Sense,” and it described a machine he named the Advice Taker: a program that would hold everything it knew as a list of explicitly stated premises and reach conclusions by formal deduction. “A program has common sense,” McCarthy wrote, “if it automatically deduces for itself a sufficiently wide class of immediate consequences of anything it is told and what it already knows.”
Read that sentence slowly, because it describes a machine that behaves nothing like the one sitting in your browser tab. McCarthy’s system would run on stated premises. You would tell it that the board meets in March, that the operating budget is frozen until July, that the provost signs anything above fifty thousand dollars. Each of those becomes a sentence the machine holds and can show you. Ask it why it reached a conclusion and it walks you back through the chain. Now the part that matters: ask it something that depends on a premise you never gave it, and the deduction simply stops. There is nothing to reason from, so the gap announces itself.
A chatbot has no premise list. This basic set of criteria has been designed out of the requirements for the chatbots that we work with so it has nothing to stop at. When your request depends on something you never said, the model does not detect an absence. It sees a place where many continuations are plausible and picks the most common one. The failure McCarthy’s design would have made loud is the exact failure this design we work with makes silent. Fluency always finishes the job.
The net result is that because the machine talks to you like a colleague, you are unconsciously invited to treat it like a colleague. You assume it shares your context because it mimics the cadence of someone who does. It does not. The Advice Taker would have told you where its knowledge ran out. The chat window fills the gap instead, and it fills it in your own voice, which is why you almost never catch it.
What does all of this really mean? First, historically we ought to be careful about how a tight a connection we make between what was conceptually being imagined in the 1950s when much of the initial imagining about what AI might do was being dreamed up and how modern chat-interface generative AI actually behaves. There is a conceptual gap between these points in time that needs more attention than it has gotten for the general public.
Second, generic output is a specification failure rather than an AI failure. The model successfully completed the pattern you started every time. Whether you get fluid bullshit, a ‘hallucination’, or genuinely useful insights you need to edit, the model is not doing something predictable in a deterministic sense, but it is successfully completing its designed function to complete the pattern you left it. You just did not realize how much of the pattern you had left in your own head. The good news about this, though, is that a specification failure is entirely fixable, provided you catch it at the point of specification.
The Bracketing Move
Catching that specification failure requires a specific cognitive maneuver. In 1913, the philosopher Edmund Husserl published Ideas I, laying the groundwork for phenomenology. Central to his method was the concept of the epoché, or “bracketing.” Husserl argued that to understand how we actually experience the world, we first have to bracket our assumptions: we have to explicitly set aside what we think we already know about a thing in order to see the thing fresh, as it actually appears.
While this started in a phenomenology seminar, it is also a great mechanism for improving prompt hygiene. Good teachers practice a version of this every day. When you teach, you have to read your own syllabus the way a student who knows nothing about the subject would read it. You have to actively forget your own expertise. You have to bracket the curse of knowledge, like the tapper’s assumption in Newton’s case that assumes the melody is obvious, to see the steps you skipped because they felt too basic to mention.
Actors use a parallel technique. Konstantin Stanislavski taught his students the “magic if”: the practice of genuinely inhabiting a set of circumstances that are not their own. To play a role, an actor cannot just memorize lines. They must bracket their own worldview and replace it with the specific, bounded reality of the character. They have to see the world from a perspective where different things are true and different rules apply.
Call this practice The Bracketing Move. It is the discipline of looking at your own request from the perspective of an entity that possesses zero shared context, zero institutional memory, and zero implicit understanding of your goals.
Doing this manually is hard because you cannot see what you are not looking at. You need a mirror. You need a system that forces the bracketed view back onto you before you commit the prompt. The Prompt Workshop Bot serves as a gymnasium for practicing The Bracketing Move. Feel free to give it a try!
A full worked run, the setup, the complete instruction set, the architecture behind it, and four ways to hack it are below the fold for paid subscribers.
