How to Brief an LLM: Context Gaps and Clarifying Questions

Give it what a smart contractor would need on day one: the goal, the audience, the facts it can't know, the constraints and what done looks like. When you don't know what's missing, ask it to list its questions before it starts. Without a brief, the model doesn't wait or ask; it guesses the most typical version of your request and writes it confidently, including details you never gave it.

Key takeaways:

• It has none of your context. No memory of past chats unless your app sends it, no access to your files unless you paste or connect them, and a training cutoff.

• It's trained to answer, not to ask. Unless you invite questions, it fills gaps with plausible inventions.

• Its abilities are uneven. It can do some hard things easily and fail at some easy ones. Don't infer one from the other.

• Brief like a contractor, then let it ask. The brief supplies what you know is missing; the questions find what you didn't know was missing.

No shared context. Chat APIs are stateless: each request contains the whole conversation, and the model knows only what's in it. Products with "memory" store notes and insert them into later prompts. Nothing carries over otherwise. The model's general knowledge also stops at its training cutoff.

Trained to answer. Instruction tuning and RLHF (Ouyang et al., 2022) reward responses that people rate as helpful, and a complete answer tends to rate better than a question back. So models tend to proceed with assumptions. Laban et al., LLMs Get Lost in Multi-Turn Conversation (2025), found that models given underspecified requests make assumptions early instead of asking, then struggle to recover.

A jagged frontier. Dell'Acqua et al., Navigating the Jagged Technological Frontier (Harvard Business School working paper, 2023), gave consultants at BCG tasks with and without GPT-4. On tasks inside the model's capabilities, consultants with AI did better and faster. On a task chosen to fall just outside, those with AI were less likely to get the right answer than those without it. The boundary isn't where human intuition puts it. A model can draft a legal memo and then miscount the letters in a word (why LLMs can't count letters).

Run on gpt-5-mini; results vary by model.

Write a short email to the team about the deadline change.

Subject: Update: Project Deadline Moved to Friday, May 3

Hi team,

Quick update: the project deadline has been moved to Friday, May 3 (previously Monday,
May 6). This change gives us a few extra days to finalize deliverables.

Please:
- Review your current tasks and adjust timelines as needed.
…

It invented both dates, and then contradicted itself: moving the deadline from May 6 to May 3 takes days away, it doesn't add them. Fluent, specific and wrong in ways that are easy to miss if you skim. Now invite questions first:

I need a short email to my team about a deadline change. Before you write anything, ask
me the questions whose answers would most change the email (at most four), then stop.

1. What is the new deadline (date and time) and what was the original deadline?
2. Who on the team is responsible for meeting this deadline (entire team, specific people,
   or subteams)?
3. Is the reason for the change that you want to mention (briefly) or should it be omitted?
4. Do you want to include any consequences, next steps, or requests (e.g., confirm
   receipt, update status, propose follow-up meeting)?

Those are exactly the facts it had invented. Answer them and the email writes itself.

• Write a short brief for anything that matters. Goal, audience, facts, constraints, format, and what to do if something's missing. Five lines are usually enough. The prompting 101 guide has a template.

• Invite questions when the task is underspecified. "Ask me up to three questions before you start" costs one turn and replaces guesses with facts. For automated pipelines, where no one is there to answer, tell it to mark assumptions instead: "list any assumption on a line starting ASSUMED:".

• Don't calibrate trust from one impressive answer. Strength on one task says little about the next. Check outputs by task type, especially exact facts, counting, recent events and anything specific to your organization.

Does the model remember our previous conversations?

Only if the product stores and re-sends that information. The model itself is stateless between requests. In an API integration, it knows exactly what you send in that request and nothing else.

Why doesn't the model ask clarifying questions?

Training rewards responses people rate as helpful, and a complete answer tends to rate better than a question back. Some models ask more than others, but you get the most reliable behavior by explicitly inviting questions.

What is the jagged frontier?

A term from Dell'Acqua et al. (2023) for the uneven boundary of what AI does well. Tasks of similar difficulty for humans can fall on different sides of it, so you can't tell from a task's human difficulty whether the model will succeed.

Should I treat the model like a junior employee?

Partly. Brief it like a new hire and review its work. But unlike a junior employee, it won't learn from feedback between sessions, won't say "I'm not sure" unless asked, and may be expert-level at one step and unreliable at the next.

• Write clear asks: prompting 101: clear asks, roles and constraints.

• Put standing context in the right place: system vs user prompts.

• Make the model stress-test your plan: LLM as a cognitive multiplier.

• Why its defaults are the typical answer: are LLMs stochastic parrots?

• Supply the facts it can't know: context is king: grounding.