# How Few-Shot Prompting Works in LLMs: In-Context Learning Explained > Understand how few-shot prompting works in LLMs. Learn about in-context learning, where models infer patterns from a few examples in the prompt without needing parameter updates. Boost your AI capabilities today. - Repository: [DAIR.AI/Prompt-Engineering-Guide](https://github.com/dair-ai/Prompt-Engineering-Guide) - Tags: deep-dive - Published: 2026-03-03 --- **Few-shot prompting enables large language models to perform tasks by providing a small number of input-output examples directly in the prompt, allowing the model to infer patterns through in-context learning without parameter updates.** Few-shot prompting is a fundamental technique in modern prompt engineering that leverages **in-context learning** to guide large language model (LLM) behavior. According to the `dair-ai/Prompt-Engineering-Guide` repository, this method embeds task demonstrations inside the prompt to steer the model toward better performance without requiring fine-tuning. Understanding how few-shot prompting works is essential for developers building reliable AI applications that require specific formatting or domain expertise. ## The Mechanics of Few-Shot Prompting ### Conditioning on Demonstrations At its core, few-shot prompting operates by **conditioning the model on explicit demonstrations**. The prompt contains one or more input-output pairs—referred to as *shots*—that act as conditioning signals. As documented in `pages/techniques/fewshot.en.mdx`, these demonstrations enable in-context learning where the model treats examples as part of the active context and implicitly learns the desired pattern before generating the answer for the new query. ### Scaling Effects and Model Capacity The effectiveness of few-shot prompting scales directly with model size. Large-scale models acquire the ability to generalize from just a few examples once they have been trained on massive corpora. The phenomenon was first observed when models reached sufficient scale, as noted in references to Touvron et al. (2023) and Kaplan et al. (2020) within the guide. Smaller models often fail to extract patterns from limited examples, while sufficiently large LLMs can interpret the underlying mapping from as few as one to three examples. ### Standard Prompt Structure A typical few-shot prompt follows a strict skeleton that separates examples from the final query. As shown in `pages/techniques/fewshot.en.mdx`, the structure typically appears as: ```markdown # Instruction (optional) Input: Output: Input: Output: ... Input: Output: ``` The model processes the preceding "Input/Output" blocks, infers the latent mapping, and produces the completion after the final `Output:` token. This format standardization helps the model distinguish between demonstrations and the target task. ## Label Sensitivity and Format Flexibility Surprisingly, few-shot prompting exhibits robustness to label accuracy. The guide notes that **"the label space and the distribution of the input text specified by the demonstrations are both important"**—however, additional results demonstrate that selecting random labels also helps rather than hinders performance. This indicates that the model learns the structural *relationship* between inputs and outputs rather than memorizing specific label mappings. Even inconsistent formatting can work because the model captures the meta-pattern of transformation rather than the literal content. ## Practical Examples of Few-Shot Prompting ### One-Shot Vocabulary Learning The classic "whatpu" and "farduddle" example from `pages/techniques/fewshot.en.mdx` demonstrates how a single example establishes a pattern: ```markdown A "whatpu" is a small, furry animal native to Tanzania. An example of a sentence that uses the word whatpu is: We were traveling in Africa and we saw these very cute whatpus. To do a "farduddle" means to jump up and down really fast. An example of a sentence that uses the word farduddle is: ``` **Expected model output:** ```markdown When we won the game, we all started to farduddle in celebration. ``` This one-shot demonstration teaches the model to generate a contextual sentence using a novel word defined in the prompt. ### Random-Label Classification (3-Shot) Even with deliberately incorrect labels, the model can infer the correct classification logic. The guide provides this sentiment analysis example in `pages/techniques/fewshot.en.mdx`: ```markdown This is awesome! // Negative This is bad! // Positive Wow that movie was rad! // Positive What a horrible show! // ``` **Model output:** ```text Negative ``` Despite the inverted labels in the demonstrations, the model recognizes the semantic content of the final query and produces the correct classification, proving that the input text distribution matters more than label accuracy. ### Multi-Step Reasoning Limitations Few-shot prompting fails on tasks requiring complex logical deduction without additional scaffolding. The guide demonstrates this limitation with an arithmetic reasoning task: ```markdown The odd numbers in this group add up to an even number: 4, 8, 9, 15, 12, 2, 1. A: The answer is False. The odd numbers in this group add up to an even number: 17, 10, 19, 4, 8, 12, 24. A: The answer is True. The odd numbers in this group add up to an even number: 15, 32, 5, 13, 82, 7, 1. A: ``` **Model output:** ```text The answer is True. ``` The model incorrectly answers "True" because standard few-shot prompting lacks the explicit reasoning steps required for multi-step arithmetic. As implemented in `pages/techniques/cot.en.mdx`, combining few-shot prompting with **Chain-of-Thought** prompting—adding intermediate reasoning steps to the examples—resolves this limitation. ## Advanced Techniques and Related Resources When standard few-shot prompting proves insufficient, the Prompt Engineering Guide recommends combining it with advanced methods documented in related files: - **`pages/techniques/cot.en.mdx`** – Chain-of-Thought prompting augments few-shot examples with step-by-step reasoning traces. - **`pages/techniques/consistency.en.mdx`** – Self-consistency samples multiple few-shot Chain-of-Thought paths and selects the most consistent answer through majority voting. - **`pages/techniques/meta-prompting.en.mdx`** – Meta-prompting uses few-shot examples to teach the model how to generate or improve prompts dynamically. - **`pages/prompts/classification/sentiment-fewshot.en.mdx`** – Contains concrete sentiment-analysis few-shot templates for immediate implementation. ## Summary - **Few-shot prompting** provides task demonstrations directly in the prompt to enable in-context learning without model fine-tuning. - **Effectiveness scales with model size**; sufficiently large LLMs generalize from 1-3 examples while smaller models may fail. - **Structure matters**: Clear Input/Output delimiters help the model distinguish examples from the target query. - **Label accuracy is flexible**: Random or inverted labels often work because models learn structural relationships rather than literal mappings. - **Reasoning limitations exist**: Standard few-shot prompting struggles with multi-step logic and requires augmentation with Chain-of-Thought techniques as described in `pages/techniques/cot.en.mdx`. ## Frequently Asked Questions ### What is the difference between few-shot and zero-shot prompting? **Zero-shot prompting** asks the model to perform a task without any examples, relying solely on pre-trained knowledge and natural language instructions. **Few-shot prompting**, documented in `pages/techniques/zeroshot.en.mdx` as the next-step solution when zero-shot fails, provides 1-5 concrete examples of the desired input-output behavior. Few-shot prompting typically yields higher accuracy for specific formatting requirements or domain-specific tasks that deviate from standard training distributions. ### How many examples should I use in few-shot prompting? Research cited in `pages/techniques/fewshot.en.mdx` indicates that **3-5 examples** typically suffice for large-scale models to grasp a pattern. Adding more than six examples often yields diminishing returns and increases token costs unnecessarily. The optimal number depends on task complexity: simple classification may require only one example, while nuanced generation tasks benefit from three to four diverse demonstrations covering edge cases. ### Why does few-shot prompting fail on complex reasoning tasks? Standard few-shot prompting provides input-output pairs without exposing the intermediate reasoning process. For multi-step arithmetic or logical puzzles, the model cannot infer the hidden calculation steps from the final answer alone. The guide's examples in `pages/techniques/fewshot.en.mdx` demonstrate that such tasks require **Chain-of-Thought prompting**, which augments few-shot examples with explicit "thinking steps" before the final answer, allowing the model to simulate the reasoning process. ### Can few-shot prompting work with random or incorrect labels? Yes. According to the analysis in `pages/techniques/fewshot.en.mdx`, models can perform well even when demonstration labels are randomly assigned or deliberately inverted. This occurs because the model learns the structural transformation from input to output distribution rather than memorizing the specific labels. However, consistent formatting and diverse input text distribution remain crucial for optimal performance, even when labels are noisy.