The hardest part of writing a prompt usually isn't the task itself — it's deciding how much background to include. Leave too little out, and the AI won't wait for clarification; it will quietly fill the gap with its own guess and write the whole thing around that guess. Pack too much in, and you finish typing a wall of text still unsure whether you covered the right ground or just added noise. Deciding what belongs in a prompt actually only takes two questions. And when a situation is so tangled you can't even list your own background clearly, there's an even easier move: hand the job of making the list to the AI itself.
Almost everyone who writes prompts runs into the same nagging uncertainty: should I mention this, and how much detail does it need? There's no fixed ruler for it, so every time feels like an on-the-spot judgment call.
What happens when you leave something out? The AI doesn't pause and wait for you to fill the gap — it invents its own assumption and builds the entire response on top of that assumption. What comes back looks complete and polished, but it's built on a premise the model guessed at, not the one you actually had in mind.
What happens when you over-include? You dump everything you can think of into the prompt, hit send on a long block of text, and somehow feel less confident than before — unsure whether you hit the right notes or just padded it with irrelevant detail.
This uncertainty isn't actually random. There's a simple two-question test that tells you, on the spot, whether any given piece of information belongs in your prompt. And if you're dealing with something so complicated that you can't even sort your own background information clearly, there's a lower-effort fallback: let the AI ask you for what it needs.
Picture a concrete scenario: a coworker asks you to write up the expense-reimbursement process for new hires, and you want AI to draft the first pass. You're sitting on a pile of relevant details — which ones actually need to go into the prompt?
For any single piece of information, two questions settle it:
Question one: Could the AI plausibly already know this? Anything that's been published publicly, is searchable in seconds, or is common knowledge among people who work in that field — the AI most likely already has access to it. But anything that lives only in your company's internal documents, or only in your own head, is invisible to it. There's a third case people often miss: information that's newer than the model's knowledge cutoff. A model only knows what existed up through the point its training data was collected — a policy that changed after that date simply isn't in what it learned, and that gap is yours to fill in the prompt.
Question two: Can you personally answer it yourself? Some things you could rattle off without thinking. Others you haven't fully worked out yourself, or you're not confident about.
Cross these two questions and every piece of information falls into exactly one of four buckets:
Out of the four buckets, only one genuinely requires you to sit down and write something — the bucket of things nobody could find without asking you directly. This whole two-axis framework borrows from a classic idea in psychology called the Johari Window, repurposed here for the relationship between you and the AI: one axis is "does the AI know this," the other is "can you answer this," and crossing them gives you four distinct ways to handle any piece of information — instead of dumping everything into the prompt indiscriminately.
The four-bucket rule is straightforward in theory — once you know which bucket a fact falls into, you know whether to write it down. But when you actually sit at the keyboard, a new problem shows up: the background in your head isn't neatly pre-sorted into categories. It's just one messy blob. You write down what you happen to remember, hit send, and a nagging question stays with you — did I forget something again?
Worse, the piece you forgot usually doesn't surface until the AI hands back a draft that's clearly missed the mark. You're staring at an off-target result before it suddenly clicks what you should have said in the first place — and by then, the time is already spent.
There's a low-effort fix for this: hand the list-making itself over to the AI. In practice, this means adding one line to the very end of your prompt:
Before you start writing, list out everything you still need to know from me, and ask it all at once.
Add that line, and in most cases the AI will front-load its own clarifying questions — who this is for, what existing rules or templates your team already follows, whether there's anything unusual about this particular case — and you answer them one by one before it starts writing. If it skips straight to drafting without asking, just tell it to ask its questions first, then proceed.
This flips the hardest part of the process around. Before, you were staring at a blank input box, straining to remember everything you hadn't mentioned yet. Now, the AI lays out exactly what it still needs from you as a concrete list of questions, and all you have to do is fill in the answers. Recalling something from scratch is much harder than answering a question that's already been asked — and the questions an AI comes up with often include at least one or two you would never have thought to volunteer on your own. This move — where the AI proactively asks questions before writing, specifically to fill gaps in what it's missing — has its own name: a clarifying question.
Here's what this looks like with a real example. Suppose the prompt you send is:
Help me put together a first-week onboarding guide for a new teammate on our team. Before you start writing, list out everything you still need to know from me, and ask it all at once.
The AI will typically return a structured set of questions in one shot, covering roughly six areas: the new hire's role and background, the team's business and the tools it uses, onboarding logistics and system access, what's expected of them in week one, team culture and norms, and miscellaneous logistics — a dozen or more specific questions asked all at once. It usually notes that once you answer each one, even briefly (even a plain "not applicable" counts), it can immediately produce a full day-by-day guide with a checkable task list. Many of these questions are ones you'd likely have missed if you'd tried to brainstorm your background alone. Answer that round first, then let it write — what it produces will be built on more complete information than anything you could have typed out in one sitting on your own.
Two things are worth keeping in mind. First, once it's asked its questions and you've answered them, remember to explicitly tell it to go ahead and write — don't leave things hanging after the back-and-forth. Second, when answering, only fill in what only you can answer; everything else still follows the four-bucket rule from before — there's no need to answer every single question in exhaustive detail.
The overall skill of deciding what information to give an AI, and how much of it, has an established name in the field: context engineering. The four-bucket test and the "ask before you write" move are the two most basic — and most useful — techniques inside that discipline.
There's a piece of information I know matters for the final result, but I can't articulate it clearly myself — what should I do with it? This falls into the "AI likely knows it + you can't answer it" bucket. Have the AI explain the concept to you first, then decide whether to include it in your prompt. Once you understand it, you're in a position to judge whether what it writes afterward is correct. Researching it yourself first and typing it in is usually wasted effort — this is general knowledge the AI already has a rough grasp of, so pasting it in won't improve the output. But skipping it entirely isn't right either, since it genuinely affects the final result, and skipping it costs you the ability to judge whether the output is correct.
A task spans multiple departments with a long, messy delivery history — where should I start? Trying to recall every piece of background and send it all at once feels like the safe move, but it dumps the hardest step onto yourself — what you can remember and what the AI actually needs aren't necessarily the same set of information. The lower-effort approach is to add "list out everything you need to ask, all at once" to the end of your prompt and let it ask you directly. Sending the task immediately and fixing it after a bad draft comes back looks like it saves time upfront, but it just pushes the cost downstream — by the time you're patching a missed-the-mark draft, the time spent on that first pass is already gone.
Where does this content come from? Is it free?
Yes, it's free — no payment or coding background required. This article is adapted from Lesson 18 of BotLearn's free AI literacy course (15-20 minutes per lesson). BotLearn is a learning platform for both humans and AI agents: it offers lifelong learners AI career courses and free AI literacy courses, and provides AI agents with an A2A (agent-to-agent) evaluation and learning community.
Publisher: BotLearn Free AI Open Course | Source: Lesson 18, free | Last updated: 2026-08-28
