Few-Shot Examples the Right Way

Few-shot prompting is a simple way to cut mistakes by showing the model two or three mini examples before asking it to work. It’s like giving a quick demo before handing someone the task. In this guide, you’ll learn what “zero-shot” and “few-shot” mean, why a handful of examples help, and how to format them so the model copies the pattern reliably.

Zero-shot means you ask the model to do a task with instructions only and no examples. Few-shot means you add a few short input→output examples (called exemplars) above your real inputs. A label task is any job where each input maps to one choice from a fixed set of labels (e.g., Bug, Billing, Feature).

Our promise: you’ll add 2–3 examples to a tiny labeler and see fewer errors, especially on edge cases.

Models learn your pattern from the prompt you provide. Instructions tell the rules. Examples demonstrate the rules with concrete cases. Together, they anchor the model’s output format and reduce ambiguity.

Compact example

Task: classify short support messages as one of {Bug, Billing, Feature, Other}.

• Zero-shot ask (instructions only): “Classify each message into one of: Bug, Billing, Feature, Other. Return JSON lines with fields text and label.”

• Few-shot ask (instructions + 3 examples): Same instructions, but include three clearly formatted examples first. The model now imitates the format, the label set, and the level of brevity.

💡 Insight: The model copies the shape and vocabulary it sees. If your examples are clean and consistent, your outputs will be too.

Here’s a simple flow you can reuse for almost any label task.

1. Define the contract. Name the labels and the output schema (keys, casing, one object per line).

2. Pick 2–3 exemplars. Choose diverse, unambiguous cases that cover common paths and one mild edge case.

3. Format consistently. Keep the same keys, label spelling, and punctuation across all examples.

4. Place examples before the real inputs. Then say “Now classify:” and list the new items.

We’ll keep both instructions and examples short. Short, crisp examples reduce token bloat and drift. Always use the exact label strings you want back.

A reusable system prompt (your “policy”)

Use this once and keep it stable across runs.

SYSTEM PROMPT — “Promptise Assistant (Beginner Labeler)”
You are a careful labeler. Follow the label set exactly. Output JSON Lines (one object per line).
Never invent new labels. Never add commentary. If uncertain, choose the closest label.

Vague vs. precise (what not to do vs. what to do)

Vague user prompt

Can you sort these messages?

Precise user prompt

Zero-shot prompt (baseline)

Few-shot prompt (2–3 exemplars + new inputs)

⚠️ Pitfall: Don’t put labels in lowercase in examples and Title Case in instructions. The model will mix them. Match spelling everywhere.

• Too many examples? More isn’t always better. Past 3–5, gains taper and tokens increase. Start with 2–3.

• Ambiguous labels? Your definitions may be fuzzy. Add one-line label descriptions and one clarifying exemplar.

• Format drift? If outputs start to include explanations, tighten the system prompt: “Never add commentary.”

• Edge cases mis-labeled? Add one targeted exemplar showing the correct handling of that edge.

• Order effects? Rarely, swapping example order changes outcomes. Place the most representative example first.

💡 Insight: Each exemplar teaches multiple things at once: label meanings, tone, and output shape. Keep them minimal but informative.

You’ll compare accuracy on sentiment labels {Positive, Negative, Neutral} for eight short reviews.

Dataset (8 items):

1. “Loved the speed—finished my work in minutes.”

2. “Support ignored me for a week.”

3. “It’s fine. Does what it says.”

4. “The new update is fantastic!”

5. “Crashes every other day.”

6. “Price is okay for what you get.”

7. “Phenomenal team. They fixed my issue fast.”

8. “Not terrible, but I’m disappointed.”

Step A — Zero-shot run (baseline) Use this as your user message (with the system prompt above):

Step B — Few-shot run (add 3 exemplars)

Expected output shape (snippet, not the only correct labels):

{"text":"Loved the speed—finished my work in minutes.","label":"Positive"}
{"text":"Support ignored me for a week.","label":"Negative"}
{"text":"It’s fine. Does what it says.","label":"Neutral"}
...

Now tally how many feel right to you. Few-shot should reduce boundary mistakes (e.g., “Not terrible, but I’m disappointed.” skewing Negative vs Neutral) and formatting errors.

Few-shot prompting improves reliability by showing the model your intended pattern before it acts. With two or three clean examples and a stable system prompt, you anchor labels, tone, and output format. The result is fewer ambiguous choices and fewer formatting surprises.

The trade-off is tokens and curation time. Too many examples add cost without much benefit, and sloppy exemplars teach the wrong habits. Keep the contract clear, pick diverse samples, and enforce exact label strings to avoid drift.

As you practice, notice how a single targeted exemplar can fix a recurring error. That’s the fastest way to “teach” the model without changing anything else.

Next steps

• Swap in your own domain labels (e.g., P1/P2/P3, Spam/NotSpam) and repeat the lab.

• Add one tricky edge exemplar and observe whether that specific error disappears.

• Wrap this into a template you can reuse across tasks, keeping the system prompt stable and only changing examples.