A user provides the following input to a large language model to get it to classify the sentiment of movie reviews. The model has not been specifically trained or fine-tuned on this particular task.

```
Classify the sentiment of the movie review.

Review: "The plot was predictable and the acting was wooden."
Sentiment: Negative

Review: "An absolute masterpiece of modern cinema!"
Sentiment:
```

Which in-context learning approach does this prompt demonstrate?

A startup is developing a feature to summarize customer support tickets using a large, general-purpose language model. They have a very limited budget, no time for model fine-tuning, and only a small, unannotated dataset of 50 past tickets. Their immediate goal is to create a functional prototype as quickly as possible to demonstrate the concept.

Which in-context learning approach (Zero-shot, One-shot, or Few-shot) would be the most effective to *start* with for this initial prototype? Justify your choice by explaining its primary advantage given the startup's specific constraints.

Choosing an In-Context Learning Strategy

A developer is building an application that uses a large language model to perform a novel task. They are considering using zero-shot, one-shot, or few-shot prompting. Analyze the primary trade-offs between these three approaches in terms of task performance, prompt complexity, and computational cost. In your analysis, explain how the number of examples provided in the prompt influences these factors.

Analyzing Trade-offs in In-Context Learning Strategies

Zero-shot, one-shot, and few-shot learning are fundamental concepts within the framework of in-context learning for Large Language Models. Their application is broad and extends beyond specific techniques like Chain-of-Thought (CoT) prompting.

Google

In-context learning (ICL) is a method for improving the performance of large language models by providing demonstrations of how to solve a problem directly within the prompt. The model then conditions its predictions on these examples, learning to perform the task without requiring updates to its underlying parameters.

In-Context Learning (ICL)

Reference of Foundations of Large Language Models Course

One-shot and few-shot learning methods are primarily utilized when a Large Language Model lacks the inherent zero-shot capability to perform a specific task. In such cases, providing one or a few demonstrations within the prompt becomes a crucial strategy for guiding the model's behavior and successfully addressing new tasks through in-context learning.

Rationale for Using One-Shot and Few-Shot Learning

Few-shot learning is a technique for adapting a large language model to new tasks by providing a small number of demonstrations in the prompt. These demonstrations establish a pattern of input-to-output mappings, which the model then attempts to follow when making predictions on new inputs. This approach contrasts with zero-shot learning, where no examples are given, and traditional training, which requires a large dataset.

Few-Shot Learning

In-context learning is considered an emergent capability of Large Language Models that manifests after the pre-training phase, allowing them to perform tasks without explicit fine-tuning for them.

In-Context Learning as an Emergent Ability

In-context learning provides an efficient method for adapting Large Language Models to new tasks because it bypasses the need for additional training or parameter updates. This process enables the quick adaptation of LLMs to novel problems, expanding their capabilities beyond what was achieved during pre-training without requiring task-specific fine-tuning.

Efficiency of In-Context Learning for Model Adaptation

In-context learning is part of a significant trend toward making AI systems more general-purpose and accessible. It enables users to guide LLMs intuitively using examples and context, reducing the reliance on specialized engineers who would traditionally be needed to fine-tune models for specific tasks.

Contribution of In-Context Learning to AI Generalization and Usability

Zero-shot learning is a prompting method where a Large Language Model is applied directly to solve new problems not seen during its training, without any task-specific examples. This approach, which does not involve a traditional learning process, relies solely on instructions within the prompt to leverage the model's generalized knowledge.

Zero-Shot Learning with LLMs

One-shot learning is a technique that enhances a prompt by adding a single, complete example of a task, known as a demonstration. For instance, in grammar correction, this would involve showing how a sentence is corrected. This added demonstration allows the Large Language Model to learn from the provided experience and apply that learning to new inputs.

One-Shot Learning

The practical success of in-context learning is determined by two key elements: the quality of the prompts, which often requires substantial engineering effort, and the inherent capabilities of the pre-trained LLM. More powerful models are better equipped to leverage in-context learning, whereas models lacking relevant pre-training data for a specific task may fail regardless of prompt quality.

Factors Influencing In-Context Learning Effectiveness

A key area of research involves understanding how in-context learning emerges as a capability during the pre-training of Large Language Models and the precise mechanisms that allow it to function effectively during inference.

Understanding the Emergence and Mechanics of In-Context Learning

To explain the underlying mechanisms of in-context learning, researchers have proposed several theoretical frameworks. These approaches interpret the phenomenon from various angles, including as a form of Bayesian inference, an implicit gradient descent optimization, a type of linear regression, or a meta-learning process.

Theoretical Interpretations of In-Context Learning

Beyond using demonstrations for in-context learning, prompts can be enhanced by incorporating any form of relevant text to create an enriched context. This technique leverages the advanced language understanding of LLMs, enabling them to generate predictions based on the specific information supplied. A key application of this method is to constrain the model's output, ensuring that its responses are confined to the provided text rather than being unconstrained predictions.

Providing Reference Information in Prompts

In the Self-Instruct process, a Large Language Model generates new instructions through in-context learning. This is achieved by providing the LLM with a selection of instructions sampled from the task pool, which serve as demonstration examples. By learning from these examples within the prompt, the model is guided to produce a new, relevant instruction.

Instruction Generation in Self-Instruct

One-shot Chain-of-Thought (CoT) prompting is a technique where a single demonstration, complete with step-by-step reasoning, is provided in the prompt. This example serves to guide the language model in its own reasoning process for a similar, subsequent task.

One-Shot Chain-of-Thought (CoT) Prompting

Scope of Zero-shot, One-shot, and Few-shot Learning

Few-shot learning is a method of context scaling that augments a prompt with multiple input-output examples, known as demonstrations. By explicitly providing these examples, the language model can implicitly learn task behavior from them and condition its predictions on this prior information, all without requiring any updates to its internal parameters.

Few-Shot Learning in Prompting

Zero-shot, one-shot, and few-shot learning are three distinct methods that illustrate the concept of in-context learning. They are differentiated by the number of problem-solving demonstrations provided in the prompt: zero-shot uses none, one-shot uses a single example, and few-shot uses multiple examples.

Comparison of Zero-shot, One-shot, and Few-shot Learning

A simple interpretation of in-context learning is that it serves as a guiding mechanism for Large Language Models. While LLMs possess general problem-solving knowledge from pre-training, they may struggle to distinguish between numerous possible predictions for a new problem. By providing demonstrations, in-context learning helps steer the model towards the correct predictive path.

In-Context Learning as a Guiding Mechanism for LLM Predictions

Calculation annotation is a formatting convention used within demonstrations for Large Language Models to make the reasoning process explicit. It involves enclosing detailed calculation steps in special markers, such as `≪ ... ≫`, to distinguish them from the main narrative of the solution.

Calculation Annotation

A specific formatting technique used in few-shot prompts is to employ a special token, such as `####`, to clearly demarcate the final answer of a problem. This helps the Large Language Model learn to structure its output in a consistent and predictable way, separating the final result from the intermediate reasoning steps.

Final Answer Formatting Token

A developer needs a large language model to translate technical jargon into plain language. They construct a prompt containing several pairs of 'Jargon-to-Plain Language' examples, followed by a new piece of technical text. The model successfully provides a plain language translation for the new text. Which statement best analyzes the fundamental mechanism of this approach?

A junior data scientist is tasked with using a large language model to classify customer support tickets. They have developed two potential prompts. Evaluate which prompt is more likely to yield accurate and consistent classifications and justify your choice based on the principles of how models learn from information provided at the time of prediction.

Evaluating Prompting Strategies for Task Adaptation

When a Large Language Model has difficulty providing a correct answer directly, a straightforward method to improve its accuracy is to include demonstrations of similar problems in the prompt. This approach enables the model to learn from the provided examples.

Using Demonstrations to Improve LLM Accuracy

In-context learning can be understood as a mechanism that activates and reorganizes a Large Language Model's pre-existing knowledge. Instead of updating model parameters through training, this process leverages the information learned during pre-training to solve new problems efficiently.

In-Context Learning as Knowledge Activation

An engineer is tasked with making a large language model perform a new task: summarizing legal documents. They try two different approaches.

Approach A: They create a prompt that includes three examples of a full legal document paired with its correct summary. They then add the new document to the end of this prompt and ask the model for a summary.

Approach B: They gather a dataset of 10,000 legal documents and their summaries. They use this dataset to run a training process that adjusts the model's internal structure over several hours.

Based on the defining characteristics of in-context learning, which approach (A or B) is an example of it? Explain the fundamental difference between the two approaches that justifies your choice.

Differentiating Learning Methods

Your team is rolling out an internal LLM assistant...

You’re building an internal LLM workflow to produc...

You’re building an internal LLM assistant to help ...

You’re leading an internal enablement team buildin...

You are deploying an LLM inside an internal finance tool that must answer multi-step policy questions (e.g., “Is this expense reimbursable given these 6 policy clauses and these 3 trip details?”). Constraints: (1) you have a strict context window budget, so you can include at most ONE short worked example in the prompt; (2) the model’s first-pass answers are often incomplete (it sometimes explains reasoning but forgets to state a final decision); (3) you need a workflow that is reliable across many different question shapes, not just one template.

Write an essay proposing a concrete prompting workflow that combines: in-context learning (if you use it), chain-of-thought prompting (including whether you would use zero-shot CoT), explicit problem decomposition (including whether you would use a least-to-most progression), and an iterative self-refinement loop. Your answer must (a) explain why your chosen combination fits the constraints, (b) describe the exact sequence of LLM calls or prompt sections you would use, (c) explain how intermediate sub-answers feed into later steps, and (d) specify how you will force a clear final decision despite the risk of incomplete zero-shot CoT outputs. Include at least two tradeoffs you are accepting (e.g., latency vs. accuracy, context budget vs. guidance, error propagation vs. transparency) and how you would mitigate them.

Choosing and Justifying a Prompting Strategy Under Context and Quality Constraints

You are deploying an LLM inside a corporate workflow to draft a first-pass analysis for a high-stakes internal decision memo (e.g., whether to approve a vendor contract). The input is a long, messy bundle of notes and constraints, and early pilots show two failure modes: (1) when asked directly, the model misses key constraints and produces confident but shallow conclusions; (2) when you add a generic “let’s think step by step” instruction, it produces lengthy reasoning but sometimes never states a clear final recommendation.

Write a proposed prompting workflow (you may describe it as a sequence of prompts) that uses: in-context learning with demonstrations, chain-of-thought prompting (including a zero-shot trigger where appropriate), least-to-most prompting, explicit problem decomposition, and an iterative self-refinement loop. Your answer must explain how these techniques work together (not independently) to reduce the two failure modes above, and must justify at least two tradeoffs you are making (e.g., latency/cost vs. accuracy, transparency vs. risk of overlong reasoning, fixed vs. dynamic decomposition). Conclude by giving one concrete example of a “final answer formatting” instruction you would include to ensure the model always outputs a clear recommendation at the end.

Designing a Prompting Workflow for a High-Stakes, Multi-Step Task

You are building an internal LLM assistant that helps a finance operations team investigate invoice-payment discrepancies. A typical ticket requires (a) extracting key entities from a messy email thread, (b) reconciling amounts across two systems, (c) identifying the most likely root cause (e.g., duplicate invoice, partial payment, currency conversion, timing), and (d) drafting a customer-facing explanation.

Your first implementation uses a single prompt with the full ticket text and the instruction “Let’s think step by step and give the final answer.” It often produces plausible reasoning but (1) misses a critical sub-check (e.g., currency conversion), (2) sometimes never states a clear final conclusion, and (3) varies in format so downstream automation breaks.

Write an essay that proposes a revised prompting workflow that integrates: in-context learning (demonstrations), explicit problem decomposition, least-to-most sequencing of sub-problems, chain-of-thought prompting (including when you would use zero-shot CoT vs a demonstrated CoT example), and an iterative self-refinement loop. Your answer must explain how these elements work together (not as independent tips), what tradeoffs you are making (e.g., context length, reliability, error propagation), and include at least two concrete prompt snippets (not full prompts) that illustrate (i) how you would elicit structured intermediate reasoning while still forcing a final answer, and (ii) how you would run critique-and-revision in self-refinement without losing the decomposed structure.

Diagnosing and Redesigning a Prompting Approach for a Decomposed Workflow

You are deploying an internal LLM assistant to help procurement analysts decide whether a proposed vendor contract requires (a) a standard review, (b) an enhanced review, or (c) an automatic rejection. The decision depends on multiple interdependent rules (e.g., data types handled, cross-border transfers, subcontractors, and exception clauses). In pilot testing, a single prompt that asks for the final decision often misses a key condition; a zero-shot “Let’s think step by step” prompt sometimes produces a long rationale but forgets to clearly state the final decision; and when you add a few demonstrations, the model becomes more consistent but still makes occasional early-step mistakes that cascade into the wrong outcome.

Design a prompting workflow (you may describe it as a sequence of LLM calls) that uses: (1) in-context learning via demonstrations, (2) explicit problem decomposition in a least-to-most progression, and (3) an iterative self-refinement loop. Your answer must explain how information flows from one step to the next, how you would prevent or detect cascading errors from early steps, and how you would ensure the model always outputs an unambiguous final decision label (a/b/c) even when using chain-of-thought style reasoning.

Stabilizing an LLM Workflow for Multi-Step Policy Compliance Decisions

You are rolling out an internal LLM assistant for Legal Ops to triage vendor contract clauses into three labels: (A) "standard/low risk", (B) "needs legal review", (C) "reject". The assistant must also produce a short justification that can be audited. In a pilot, you observe two recurring failures: (1) on complex clauses, the model gives confident but wrong labels unless it is guided through intermediate reasoning; (2) when you add a simple instruction like "Let’s think step by step," the model often produces a long rationale but sometimes forgets to output a clear final label.

You are not allowed to fine-tune the model. You can only change the prompting workflow and the content placed in the prompt. You have a strict context window budget, so you can include at most ONE worked example in the prompt, and you must keep the number of model calls per clause to no more than 3.

Case: A new clause says: "Vendor may use Customer Data to improve its services and may share Customer Data with affiliates and subcontractors for that purpose. Customer may opt out of data sharing by emailing support within 10 days of signing." Your policy requires: (i) no sharing of Customer Data with third parties for model training/service improvement unless explicitly prohibited or strongly constrained; (ii) opt-out mechanisms are considered insufficient for sensitive data; (iii) subcontractor access must be tightly limited.

Design a prompting workflow (describe the sequence of prompts/calls and what each prompt contains) that uses in-context learning, problem decomposition/least-to-most prompting, chain-of-thought (including zero-shot CoT where appropriate), and self-refinement to reduce both failure modes while staying within the constraints. Your answer must explain how the techniques interact (e.g., why you place a worked example where you do, how you decompose the decision, how you ensure a final label is always produced, and how critique/revision is used without exceeding 3 calls).

Debugging a Multi-Step LLM Workflow for Contract Clause Risk Triage

You are rolling out an internal LLM assistant for SREs to perform root-cause analysis (RCA) from incident artifacts. The assistant receives: (1) a short incident timeline, (2) 30–60 lines of logs, and (3) a list of recent deploys. The desired output is a single RCA summary with: likely cause, supporting evidence, and a recommended next action.

Constraints: You can only include ONE short demonstration in the prompt due to context limits; the assistant must work on novel incidents; and the first pilot showed two failure modes: (a) the model jumps to a plausible cause without checking evidence across artifacts, and (b) when you add “Let’s think step by step,” it sometimes produces a long analysis but forgets to state a clear final RCA.

As the prompt/workflow designer, propose a concrete prompting plan that combines: (i) in-context learning with the single demonstration, (ii) explicit problem decomposition (including a least-to-most style progression of sub-questions), (iii) chain-of-thought elicitation (including how you would use or avoid zero-shot CoT triggers), and (iv) self-refinement (critique + revision) to reduce both failure modes. Your answer must include the exact structure of the prompt(s) you would send (section headings and what each section contains) and explain why each component is placed where it is.

Designing a Robust Prompting Workflow for Multi-Step Root-Cause Analysis with Limited Examples

An example of in-context learning involves presenting a similar problem and its corresponding answer within the prompt to demonstrate how to solve it. For instance: 'Tom has 12 marbles. He wins 7 more marbles in a game with his friend but then loses 5 marbles the next day. His brother gives him another 3 marbles as a gift. How many marbles does Tom have now? The answer is 17. Jack has 7 apples. He ate 2 of them for dinner, but then his mom gave him 5 more apples. The next day, Jack gave 3 apples to his friend John. How many apples does Jack have left in the end? The answer is 12.'

Example of In-Context Learning

In-context learning can be applied to translation tasks by prompting a Large Language Model with a few examples of translated phrases before presenting the target phrase. For example, a prompt instructing the model to translate Chinese to English might provide: 'Example 1: 你好 Translation: Hello' and 'Example 2: 谢谢你 Translation: Thank you', enabling the model to correctly translate the final target phrase '早上好' as 'Good Morning'.

Example of In-Context Learning for Translation

To provide demonstrations to a Large Language Model, the original user input ($$\mathbf{x}$$) is combined with a sequence of context messages ($$\mathbf{c}_1, \dots, \mathbf{c}_k$$). A specific prompting template, denoted as $$g$$, is used to structure these elements together (such as formatting them as a series of messages followed by an expected output). This process generates a single, combined sequence known as the augmented input ($$\mathbf{x}'$$). The creation of this augmented input can be formalized mathematically as: $$\mathbf{x}' = g(\mathbf{c}_1, \dots, \mathbf{c}_k, \mathbf{x})$$.

Learn Before

Related

Learn After