You've been taught that few-shot examples make prompts better. More examples, better results. It's the first technique most people learn, and the one they reach for by default.

The research says otherwise. In 2026, for most tasks on modern instruction-tuned models, few-shot examples are actively degrading your output quality while burning tokens you don't need to spend.

The Over-Prompting Effect

Tang et al. coined the term "over-prompting" after testing across GPT-4o, DeepSeek-V3, Gemma-3, LLaMA-3.1/3.2, and Mistral. The pattern was consistent across every model: performance peaks at a small number of examples, then declines as you add more. Not plateaus. Declines.

This isn't a minor effect. On a route optimization task, Gemini 3 Flash scored 33% zero-shot. Adding four examples climbed it to 64%. At eight examples, it crashed back to 33%. The model learned and then unlearned.

Security classification hit even harder. Lin and Mohaisen (NDSS 2025) found few-shot examples destroyed vulnerability type identification accuracy. Gemma 7B dropped from 77.9% to 39.9%. LLaMA-2 70B went from 68.6% to 21.0%. The examples didn't help the model classify vulnerabilities. They confused it.

Few-Shot Isn't Learning What You Think

Here's the part that should change how you prompt. Min et al. ran an experiment where they randomly swapped the labels in few-shot examples. Positive sentiment examples got labeled negative. Correct classifications got wrong labels. Performance barely changed.

The models weren't learning input-label mappings from your examples. They were picking up format cues and token distribution patterns. The actual content of your carefully crafted examples? Mostly irrelevant.

This means few-shot "learning" is really few-shot "formatting." And if all you need is output formatting, there's a cheaper, more reliable way to get it.

Constraints Beat Examples

Structured constraints tell the model exactly what you want without the ambiguity of learning-by-example. A constraint like "respond in JSON with keys: category, confidence, reasoning, each under 50 words" is unambiguous. An example of the same output format leaves the model guessing which aspects of the example matter.

Here's what this looks like in practice.

The Few-Shot Approach (wasteful):

Classify the following support ticket. Here are examples:

Ticket: "My payment failed at checkout"
Category: billing
Priority: high
Summary: Payment processing failure during purchase

Ticket: "How do I change my password?"
Category: account
Priority: low
Summary: Password reset inquiry

Ticket: "The app crashes when I upload photos larger than 10MB"
Category: bug
Priority: medium
Summary: Application crash on large file upload

Now classify this ticket: "I was charged twice for my subscription"

The Zero-Shot With Constraints Approach (better):

Classify this support ticket.

Rules:
- Category: one of [billing, account, bug, feature-request, general]
- Priority: one of [critical, high, medium, low] based on revenue impact and user count affected
- Summary: one sentence, under 20 words, stating the core issue without editorializing

Ticket: "I was charged twice for my subscription"

Respond in exactly this format:
Category: [value]
Priority: [value]
Summary: [value]

Why This Works: The constraint version defines the output space explicitly. The model doesn't have to reverse-engineer your intentions from examples. It knows the valid categories, the priority logic, and the summary requirements. No ambiguity, no format drift, and 60% fewer tokens.

Expected Output:

Category: billing Priority: high Summary: Customer reports duplicate subscription charge requiring immediate refund investigation.

The few-shot version uses ~150 tokens on examples. The constraint version uses ~80 tokens on rules. At 1M requests per month, that difference compounds fast. Enterprise LLM API spending hit $8.4B by mid-2025, with few-shot padding flagged as a primary source of token waste.

Zero-Shot CoT Now Beats Few-Shot CoT

Chain-of-thought prompting was the one area where few-shot seemed bulletproof. Show the model examples of step-by-step reasoning, get better reasoning out. Cheng et al. put that assumption to the test across current-generation models.

For strong models like the Qwen2.5 series and comparable architectures, adding CoT exemplars didn't improve reasoning at all. The exemplars were functioning purely as output format alignment. Zero-shot CoT with a simple "think step by step" instruction matched or beat few-shot CoT.

This tracks with what practitioners are seeing. If the model already knows how to reason about your task, showing it examples of reasoning is redundant. You're paying tokens for information the model already has.

Zero-Shot CoT With Constraints:

A SaaS company has 10,000 users paying $50/month. They're considering a price
increase to $60/month but estimate 15% churn from the change. They also expect
the higher price point to reduce new signups by 10% from their current rate
of 500/month.

Calculate whether the price increase is profitable over 12 months.

Think through this step by step. Show your math at each stage. State your
assumptions explicitly. Give a final recommendation with the break-even
timeline.

Why This Works: No examples needed. The constraints ("show your math," "state assumptions," "give break-even timeline") direct the reasoning structure. The model knows how to do financial math. Your job is to tell it what outputs you need, not show it how to think.

Expected Output:

Current annual revenue: 10,000 users x $50/month x 12 = $6,000,000

Post-increase scenario: Immediate churn: 10,000 x 15% = 1,500 users lost Remaining users: 8,500 x $60/month = $510,000/month

New signup rate: 500 x 0.90 = 450/month Monthly user growth: 450 new users at $60 = $27,000 incremental/month

Break-even analysis: Month 1 revenue: 8,500 x $60 = $510,000 (vs $500,000 current = +$10,000) The price increase is immediately profitable despite 15% churn...

When Few-Shot Still Earns Its Tokens

Few-shot isn't dead everywhere. There are specific cases where examples remain the right tool.

Subjective style matching. If you need output that matches a specific voice or aesthetic and you can't fully capture it in constraints, two or three examples of the target style still work. Tone is hard to specify declaratively.

Genuinely novel output formats. If you've invented a custom format the model has never seen, one or two examples teach it faster than a paragraph of structural constraints. But if the format maps to JSON, markdown, CSV, or any common structure, constraints win.

Specialized domains without instruction tuning. Smaller or older models that haven't been tuned for your specific task still benefit from examples. The weaker the model's baseline understanding, the more examples help. But on Claude, GPT-4, Gemini Pro, or any current frontier model, instruction tuning already covers most domains.

Phishing detection. NDSS 2025 benchmarking showed few-shot with six examples reduced Grok-3-Beta false negatives from 950 to 248 on phishing URL detection. Some binary classification tasks on specific models still respond well to examples.

The pattern: if the model already knows how to do the task (and modern models know how to do most tasks), examples are overhead. If the model genuinely lacks the knowledge, examples teach it. Test both. Measure. Don't assume.

The Decision Framework

Before adding few-shot examples to any prompt, ask two questions:

Am I teaching format or knowledge? If format, use constraints instead. Constraints are explicit, cheaper, and don't introduce the ambiguity of example-based inference.

Does this model already know how to do this task? Test zero-shot first. If the output quality is within 90% of what you need, add constraints to close the gap instead of examples. You'll likely get better results for fewer tokens.

The shift happening in 2026 isn't from prompting to no-prompting. It's from example-packed prompts to constraint-defined prompts. From showing the model what you want to telling it precisely. From prompt hacking to context architecture.

Your prompts should be getting shorter, more specific, and more structured. If you're still defaulting to three-to-five examples on every prompt, you're likely paying more for worse results.

Strip the examples. Add constraints. Measure the difference.

Want hands-on training on constraint-based prompting and modern techniques for your team? Connect with Kief Studio on Discord or schedule a session.

prompt optimization

Meta-Prompting: Write Prompts That Generate Better Prompts Than You Can

Few-Shot Prompting Is Dead Weight in 2026: When Zero-Shot With Constraints Outperforms Examples