What Is Few-Shot Prompting?

Most prompting advice tells you to describe what you want more clearly. Few-shot prompting works differently.

Few-shot prompting is the practice of embedding one or more input-output examples inside your prompt before the actual question. The model reads the pattern in your examples and applies it to the new input — no explicit instructions needed.

It is one of the highest-leverage adjustments available for format-sensitive tasks, and it requires no special tools or access.

How it works

1. Models match patterns, not rules

A [large language model](what-is-a-large-language-model.md) doesn't parse instructions the way code executes a function. It generates the most statistically likely continuation of everything inside its [context window](what-is-a-context-window.md). When you paste in examples of the output you want, you're adjusting the probability distribution of the model's next word — not writing rules. That's why one concrete example often outperforms a paragraph of precise instructions: the model matches a pattern faster than it decodes an abstraction.

2. The naming follows example count

More examples are not always better. Past five, the signal rarely improves — the model has usually extracted the pattern by the second or third example — but the cost to your context window budget grows linearly.

3. The shape of a few-shot prompt

A few-shot prompt has three parts: examples, a separator, and the actual query. The canonical structure:

Input: [example input 1]
Output: [example output 1]

Input: [example input 2]
Output: [example output 2]

Input: [your actual query]
Output:

The model reads the pairs, infers that the next Output: should follow the same pattern, and completes it. The exact label words (Input: / Output:, Q: / A:, Before: / After:) don't matter — what matters is that the pattern is consistent.

4. Why examples outperform instructions for format-sensitive tasks

Instructions are ambiguous. "Be concise" means something different to every reader. An example is unambiguous — it nails length, tone, vocabulary level, and structure in a way prose descriptions rarely do. This advantage is largest for:

• Formatting — bullet lists vs prose, headline casing, table structure
• Tone — formal vs casual, first person vs third
• Classification — label categories that are hard to define but easy to demonstrate
• Extraction — pulling the same fields from varied-format source documents

For tasks where output format is flexible, zero-shot usually suffices. For tasks where format is load-bearing, one or two examples is the efficient path.

A concrete example

You want the model to tag customer feedback with one of three labels.

Zero-shot — describe the rule:

Tag this as feature-request, bug-report, or positive-feedback: "The dark mode keeps reverting after I close the app."

Works, but the model may hedge or use inconsistent phrasing.

Few-shot — show the pattern:

Feedback: "I wish I could export to CSV."
Tag: feature-request

Feedback: "The app crashed when I pasted a long URL."
Tag: bug-report

Feedback: "The dark mode keeps reverting after I close the app."
Tag:

Result: bug-report — consistent, every time. The two examples drew the boundary between categories more precisely than a sentence of instructions could.

Why it matters

Few-shot prompting is the fastest path to consistent output across a batch of inputs. It shows up in:

• Classification at scale — labeling support tickets, notes, or research items against a fixed schema
• Format standardization — converting messy input into a clean, repeatable template
• Style matching — writing or editing content to match a specific voice or house style
• Data extraction — pulling the same fields out of varied inputs (receipts, meeting notes, contracts)

Research results back this up: across standard benchmarks, two or three well-chosen examples measurably outperform zero-shot on constrained-output tasks, and the gain often rivals switching to a larger model.

Try this

Next time the model gives you the right content in the wrong format — wrong length, wrong structure, wrong tone — don't rewrite your instructions. Paste one example of exactly the output you'd accept, then add your real query. That single change converges faster than five rounds of rephrasing.

If you store notes and research in JustJot.ai, save your best few-shot templates as reusable notes. The next time you need consistent output on that task, paste the template directly rather than rebuilding the pattern from scratch.

The operating principle: when you can't write the rule, show the case. One well-chosen example is worth more than a hundred words of explanation.