One-Shot Prompting

One-shot prompting provides a language model with exactly one worked example inside the prompt before asking it to handle the real input. It sits between zero-shot prompting, which supplies no examples, and few-shot prompting, which supplies several. The single demonstration shows the model the desired input-output pattern — the format, the tone, the level of detail — anchoring its response far more reliably than instructions alone often can.

The vocabulary comes from the research literature on in-context learning, where the striking discovery was that large models can pick up a task from demonstrations in the prompt alone — no gradient updates, no training run, just examples read at inference time. "Shots" are simply the number of demonstrations provided, and the zero/one/few framing became the standard way to measure how much hand-holding a model needs. That research context explains why the distinction matters at all: the ability to learn a task from a single example was one of the clearest early signals that scale had bought models something qualitatively new, and it remains the cheapest capability you can exploit — every example is free to add and free to remove.

How it works

A one-shot prompt typically pairs a natural-language description of the task with one completed example, then presents the actual query in the same shape. You might show a single messy sentence rewritten into a formal one, then supply the sentence you actually want rewritten; or show one support ticket labeled with a category, then present the ticket to classify. Like all in-context approaches, the model picks up the pattern at inference time, with no change to its weights — the example lives only in the context window for the duration of that request. This is what makes the technique free to iterate on: adjusting your example costs nothing but a retry.

Why one example is often the sweet spot

A single example is frequently enough to lock in formatting and style while keeping the prompt short and the token cost low. It also sidesteps a subtle failure mode of multi-example prompts: with several demonstrations, models sometimes over-fit to incidental details — if all your examples happen to be short, or share a topic, the model may infer those accidents are requirements. One well-chosen example gives guidance without over-constraining. The craft is in choosing it: pick an example that is representative of the real inputs, unambiguous in what it demonstrates, and formatted exactly as you want every output formatted, because the model will copy your example's shape more faithfully than your instructions' words.

Where it earns its keep locally

For self-hosted models, one-shot prompting has extra teeth. Prompt tokens cost real processing time on your own hardware, and compact local models served through Ollama or llama.cpp often have modest usable context — every token spent on examples is a token unavailable for the actual work. One-shot delivers most of few-shot's formatting benefit at a fraction of that cost. Smaller models also tend to be weaker at following abstract instructions but respectable at imitating concrete patterns, so a single vivid example often outperforms a paragraph of careful specification. Practical illustration: to make a local model emit clean JSON summaries of miner log lines, showing it one log line with its exact desired JSON output will typically beat any amount of prose describing the schema.

Choosing between zero, one, and few

A reasonable workflow is to escalate only as needed. Try zero-shot first — capable models handle many tasks on instructions alone. If the output format or style drifts, add one example and retest; this fixes the majority of formatting problems. Reserve multi-example prompts for genuinely ambiguous tasks where the boundaries between categories need several illustrations to pin down. For simple tasks, one-shot frequently matches the accuracy of much larger few-shot prompts at a fraction of the context cost — a meaningful edge for sovereign Bitcoiners running compact models on their own silicon. It is one of the core shot-based methods within prompt engineering, and usually the first tool worth reaching for when instructions alone fall short.