The Zero-Shot article covered relying purely on instructions, with no examples. This article covers what happens when you add a handful of them directly into the prompt: few-shot prompting.
The simple definition
Few-shot means including a small number of worked examples — typically somewhere between two and a few dozen — directly in the prompt, showing the model exactly what a correct input-output pair looks like before asking it to handle a new case. Rather than only describing the task in words, as zero-shot does, few-shot demonstrates it concretely, letting the model infer the pattern directly from the examples themselves.
Why showing beats telling, in this specific way
Recall from the Zero-Shot article’s real limitation: purely instructional prompts can leave real ambiguity about exact format, tone, or edge cases.
Few-shot solves this by letting examples do work that instructions alone often can’t — a specific input-output pair shows, concretely and unambiguously, exactly what “correct” looks like, including subtle formatting or stylistic details that would be tedious or difficult to fully specify in words.
This connects directly to the pattern-recognition idea from the Pattern article, back in the Foundations phase — a model given a few clear examples can often infer the underlying pattern connecting them, the same core capability that makes learning from data work throughout this entire glossary, just applied here at the level of a single prompt rather than a full training run.
flowchart LR
A["Example 1: 'happy' -> positive"] --> D[Model infers the pattern]
B["Example 2: 'terrible' -> negative"] --> D
C["Example 3: 'okay' -> neutral"] --> D
D --> E["New input: 'amazing' -> ?"]
E --> F["Model predicts: positive"]ANALOGY vs. TECHNICAL REALITY
Analogy: Think of training a new employee to sort incoming customer emails by urgency.
You could describe the rules in words — “urgent means angry customers or system outages” — or you could show them three or four real, labeled example emails: this one is urgent, this one is routine, this one is low-priority, and why.
The examples often communicate the actual judgment call far more precisely and quickly than an abstract description could.
Where this breaks down: A new employee genuinely learns and internalizes a rule from a few examples, applying real judgment to new, different cases going forward, in future days and weeks.
A model’s few-shot “learning” is not learning in the training sense at all — recall from the Weights article that nothing about the model’s actual parameters changes from a few-shot prompt; the examples exist only within that one prompt’s context window, as covered in the Context Window article, influencing that single response through the same attention mechanism covered in the Attention article, and vanishing entirely once the conversation ends.
The historically important name behind this technique
This deserves to be stated directly, since it’s the origin of one of the most cited titles in recent AI research.
OpenAI’s landmark 2020 GPT-3 paper is literally titled “Language Models are Few-Shot Learners” — the paper’s central finding was that GPT-3 could be shown just a handful of examples directly in a prompt and perform a new task at a level competitive with, or sometimes better than, models that had been specifically fine-tuned on thousands of labeled examples, as covered throughout the Data Handling phase.
This was a genuinely significant result: it demonstrated that a sufficiently large pretrained model could adapt to new tasks through prompting alone, without the expensive labeling and fine-tuning process that had previously been standard practice.
What “in-context learning” actually refers to
It’s worth naming a closely related term you’ll encounter constantly alongside few-shot prompting. In-context learning describes exactly the phenomenon few-shot prompting exploits — a model appearing to “learn” a new task purely from examples given within its current context window, with no actual weight updates involved at all.
This is precisely why the quotation marks around “learning” matter here: it’s a genuinely different mechanism from the gradient-based training covered throughout the Training Mechanics phase, even though the practical effect — better performance on a new task — can look superficially similar.
A concrete example, layered
For a simple beginner example: a few-shot prompt for extracting names from text might read “Extract the person’s name. Input: ‘John went to the store.’ Output: John. Input: ‘Maria called her sister.’ Output: Maria.
Input: ‘The dog ran fast.’ Output:” — the model, having seen the pattern twice, correctly infers that this last input contains no person’s name and responds accordingly, without ever having received an explicit instruction describing that edge case.
For a production example: companies building specialized classification or extraction features often use few-shot prompts with 3–10 carefully chosen examples as a fast, cheap first approach — testing whether a general-purpose model like GPT-4 or Claude can hit acceptable accuracy this way before ever investing in the far more expensive labeled-dataset and fine-tuning process covered in the Data Handling and Algorithm articles.
Why more examples isn’t automatically better
It’s worth being honest about a real, practical trade-off here. Every example included in a few-shot prompt consumes tokens, directly increasing the cost and latency of each request, exactly as covered in the Token and Context Length articles.
And research has found that simply adding more examples doesn’t reliably keep improving performance past a certain point — a handful of well-chosen, genuinely representative examples, including at least one or two edge cases, often outperforms a much longer list of repetitive or poorly chosen ones.
Design examples that actually teach the boundary
Imagine a review classifier where MIXED is easily confused with NEGATIVE:
“Beautiful screen, but the battery lasts only two hours.” → MIXED
“Everything works, although delivery was late.” → MIXED
“The battery failed after one day.” → NEGATIVE
“Fast, bright, and comfortable to use.” → POSITIVEGood examples show hard boundaries, use the exact desired output format, and cover realistic variation. Four nearly identical easy examples consume context without teaching much.
Few-shot prompting changes the current context, not the model’s stored weights. Remove the examples and their immediate influence disappears. This is why few-shot learning is fast and reversible, but also why it consumes input tokens on repeated requests unless an application caches or otherwise reuses the prefix.
Real-world example: teaching a company’s special labels
A delivery company uses internal labels that the model has never seen:
“Driver is nearby and moving.” → ACTIVE_ROUTE
“Parcel is waiting at the city depot.” → HUB_HOLD
“Address cannot be found.” → ADDRESS_BLOCK
Now label: “The package is still at the warehouse.”The examples teach both the label names and the desired answer format inside the prompt. The model may answer HUB_HOLD without any weight update. Teams commonly use this for classification, extraction, style imitation, and demonstrating tool-call formats. They must avoid including private customer information in examples and should choose examples representing real edge cases.
Common misconception
A frequent beginner assumption: that few-shot prompting is a form of real training or fine-tuning, since the model appears to genuinely improve at the task afterward.
As the in-context learning discussion above explained, this isn’t accurate — nothing about the model’s weights changes; the examples only ever influence that single response, within that single conversation’s context window, and the model returns to its unmodified, pretrained state the instant a new, separate conversation begins.
Where this fits in what comes next
You now understand both baseline prompting approaches — zero-shot (instructions alone) and few-shot (instructions plus concrete examples). The next article, Chain-of-Thought, covers a related but distinct technique — not showing examples of the final answer, but showing (or eliciting) the reasoning steps that lead there.
In one sentence
Few-shot prompting shows a model a handful of concrete input-output examples directly in the prompt, letting it infer a task’s pattern the way it inferred patterns during training — a genuinely powerful, historically significant technique, and one whose in-context “learning” vanishes entirely once the conversation ends, since it never touches the model’s actual weights.
Related Terms
- Author
- TechByteByByte Editorial Team
- Reviewed by
- TechByteByByte Admin
- Published
- Last reviewed