One sentence, zero examples, and the work came back done.
In October 2025, I started using Claude. I gave it a single instruction, and for the first time a tool performed the activity on my behalf. I had not attached a template. I had not included an example of what the output should look like. One instruction aimed at a task with a single clear definition of done. The work came back complete.
That was zero-shot prompting. I did not have a name for it. One instruction. Zero examples. Full outcome. I was behind the wheel, the task was unambiguous, and the model had enough implicit context to fill the gaps. I did not need to show it what good looked like. This time.
That zero-shot win is the exception, not the default.
"Three or four keywords, a question mark, enter." That was also zero-shot. That was February 2024, the first time I opened ChatGPT, and the answer came back fluent, generic, and useless. Same shot count. Different instruction quality. Same label, opposite result.
The model was not being lazy in either case. In February 2024, the instruction had no definition of done, no preferred output shape, and nothing to pull the answer toward my use case. The model averaged across everything it had seen for similar prompts and returned the midpoint. That is why zero-shot so often produces something generic. The model is not withholding a better answer. It has not been shown what one looks like for this specific task.
That gap is what shot count addresses.
Briefing a new colleague tells you exactly which shot to reach for.
Picture briefing a new hire. Zero-shot: "Write the summary." The colleague has no example of what a summary means in your context. They guess the length, the format, the tone, and produce something competent and generic. One-shot: "Here is a summary we produced last quarter. Write the next one in the same shape." One demonstration anchors the expected format. Few-shot: "Here are three examples, a complex case, a simple one, and a borderline one. Match your summary to the complexity of the current task." Now the colleague understands range and edge-case handling, not just format.
This is what examples do in a prompt. They do not tell the model what to think. They show it what the answer looks like. That is a different lever from the Role/Objective/Background/Data context-enrichment approach I covered in a prior post. The two levers are additive, not synonymous.
Research confirms that showing the model one worked example rewires the answer.
Brown et al.'s 2020 paper on GPT-3 named the gap directly:
Recent work has demonstrated substantial gains on many NLP tasks and benchmarks by pre-training on a large corpus of text followed by fine-tuning on a specific task. While typically task-agnostic in architecture, this method still requires task-specific fine-tuning datasets of thousands or tens of thousands of examples. By contrast, humans can generally perform a new language task from only a few examples or from simple instructions - something which current NLP systems still largely struggle to do.
The academic name for what practitioners call few-shot prompting is in-context learning. Dong et al.'s survey on in-context learning defines the paradigm:
In-context learning is a paradigm that allows language models to learn tasks given only a few examples in the form of demonstration.
No retraining. No fine-tuning. The model reads the examples and adjusts inside the same conversation window.
Anthropic's prompting documentation makes the practitioner case plainly:
Examples are one of the most reliable ways to steer Claude's output format, tone, and structure. A few well-crafted examples (known as few-shot or multishot prompting) improve accuracy and consistency.
Zero-shot is not limited to simple tasks. Kojima et al.'s 2022 paper showed that a large model can reason through multi-step problems without any demonstrations:
Pretrained large language models (LLMs) are widely used in many sub-fields of natural language processing (NLP) and generally known as excellent few-shot learners with task-specific exemplars. Notably, chain of thought (CoT) prompting, a recent technique for eliciting complex multi-step reasoning through step-by-step answer examples, achieved the state-of-the-art performances in arithmetics and symbolic reasoning, difficult system-2 tasks that do not follow the standard scaling laws for LLMs. While these successes are often attributed to LLMs' ability for few-shot learning, we show that LLMs are decent zero-shot reasoners by simply adding "Let's think step by step" before each answer.
Shot count and reasoning depth are two separate dials. See the chain-of-thought post published this week for the full mechanism.
Adding examples costs time you may not have, and that objection is fair.
Every few-shot example you write is prompt real estate and thinking time. When to use zero-shot versus few-shot prompting is a genuine question, not a rhetorical one. If you are asking a factual question, generating a quick summary, or working in a context where output format does not matter, adding three worked examples before your ask is overhead with no return. Zero-shot is the right default when the task has a single acceptable answer, when the model already has enough context from the conversation so far, and when the format is irrelevant to the outcome.
The objection falls short only on format-sensitive tasks. When you need a specific output structure, a particular tone register, or consistent handling of edge cases, the model without examples is not guessing. It is averaging. It produces the midpoint of every similar output it has produced for comparable prompts. A three-sentence example is not a long prompt. The overhead of few-shot is real and proportionate to task complexity. Treating it as universally expensive is the mistake.
The August 2024 structured prompt was a single-shot move I did not have a name for yet.
In August 2024, I was working at a pharma IT company on a requirements document for a new clinical data review feature. I had a 40-minute interview transcript from the head of clinical operations. The first prompt was "Summarise this transcript." The model returned something fluent and useless. The second prompt supplied a role, background, and this instruction: "Pull out the three things she clearly wants, the two things she said no to, and the one thing she contradicted herself about." Same transcript, same model. The second answer told me which paragraph I needed to rewrite before showing the document to anyone.
What I want to name here is the output template hidden inside the second prompt. "Three things... two things... one thing." That structure was a single-shot demonstration of what the answer should look like, embedded in the phrasing of the question. I showed the model the shape of the answer before it produced it. The context enrichment made the instruction accurate. The embedded output template made the answer usable. Those are not the same move, and conflating them is how people keep writing better prompts without knowing which part produced the improvement.
The examples you include teach the model the wrong lesson as easily as the right one.
The failure mode in few-shot prompting is not using too many examples. It is using poorly chosen ones. If your three examples are inconsistent in structure, the model has no stable shape to match. If all three are drawn from easy cases when the actual task is complex, the model produces something calibrated to easy, not complex. It averages across what you gave it, treating examples in prompts as ground truth, not as a range of suggestions.
A second failure mode: examples that accidentally encode a bias you did not intend. If all three examples are formal in register when you need an informal answer for this task, you will get formal output. The model reads examples the way a new hire reads a brief, completely, and without your unspoken caveats. Read your examples before you send them. Because that brief is what you are handing the model.
The shot count is a dial, not a switch. Turn it up when you need the model to see what good looks like.
Before you send the next prompt, ask one question: has this model seen what a good answer looks like for this specific task? If yes, zero-shot is fine. If the format matters, the tone is non-obvious, or edge cases need handling, add an example or two. Zero-shot is not lazy. It is correct for clear tasks. Few-shot is not thorough. It is correct for format-sensitive ones. How many examples to include in an AI prompt is a prompt engineering decision, and the dial for it was always there.
