Teaching by Example

Start with the imperative

So far, most of our prompting has been imperative: we give the model direct instructions — specific commands that spell out what to do. Imperative is the grammatical mood of a command: "summarize this," "translate to Norwegian," "fix the causal language." You state the operation, the model performs it. It is the most natural way to tell any worker what you want, and it takes you a long way.

But issuing commands is not the only way to teach a model what you want. Sometimes the thing you want is hard to say as a rule and easy to show — and for a machine whose one talent is pattern recognition, showing turns out to be extraordinarily powerful. That second way — teaching by example — is what this lesson is about. To feel its force, first remember what showing a machine a pattern used to cost.

Teaching a machine, the old way

To feel the force of teaching by example, you have to remember what the world was like just a few years ago. Suppose, back then, you wanted a computer to learn a pattern — say, to read a product review and decide whether it's positive or negative. Sentiment analysis: a simple-sounding classification task. Here is what it took:

And sentiment was a success story. The genuinely hard cases — sarcasm, implication, tone — sank whole research programs, because annotators couldn't even agree on the labels.

The same machine, rebuilt in six lines

Now watch:

The research community calls this in-context learning — the discovery, startling at the time, that large models can learn a task from a few examples in the prompt itself (Brown et al., 2020). For you it means something extraordinarily practical: you now carry an on-demand model factory, and its entire engineering interface is showing it things. The rest of this lesson is about wielding that — and the right frame for wielding it turns out to be exactly how you would teach a person.

How would you teach someone to write like Tolstoy?

Suppose that's my assignment: teach you to write like Tolstoy. There are two ways I could go about it, and one of them is the way we instinctively reach for — write it all down. Produce the manual: the complete rules of writing like Tolstoy. Let's try:

The manual is farce, and not because the rules are wrong — each one is defensible. It's farce because the rules never end, they contradict, and knowing all of them still wouldn't produce a page of Tolstoy. The second way is what anyone would actually do: hand you Anna Karenina and say — like this.

And notice what that choice relies on. Your pattern recognition does the heavy lifting: you extract the rules on the fly, in the context of applying them, keeping only the ones the current sentence needs — most of them rules neither of us could have articulated. For a task like this, examples aren't the lazy option. They are extraordinarily information-dense: a page of Tolstoy carries more of "how to write like Tolstoy" than a volume of rules about it.

Show, don't describe

Now bring that to the machine we have. We just watched the model complete patterns — nursery rhymes it memorized, and a fishermen's scene invented seconds earlier. Pattern recognition is the one thing this machine does — which means the Tolstoy method, teaching by showing, is its native mode of learning. Watch the same contrast on a task-sized problem:

The left column is the imperative approach pushed to its limit — the Tolstoy manual again, in miniature — and it has the same disease: still writing, edge cases still coming. In the right column, each labeled example lays a pattern down in the document. A rule tries to describe the boundary between categories; an example simply sits on the correct side of it, and the model infers the boundary the same way it inferred how Magnus talks. This is the first big lesson of prompting: examples are often denser than rules — and frequently cheaper, word for word, than the rules they replace.

Classification, taught in one prompt

The cleanest demonstration. No definitions, no rules — just labeled examples, then a new case:

The same pattern reaches problems that don't look like ticket routing at all. Here it is doing qualitative research:

A gallery of little impossible machines

Once you see the pattern, it's hard to stop building these. Each of the following would have been a funded project a decade ago — a labeled corpus, a custom model, a defended thesis. Each is funny precisely because of how casually it now works. Watch four different kinds of learning, all taught the same way:

Chain of thought: the trajectory toward correctness

So far the examples taught answers. The next step teaches thinking — and it starts from the trajectory idea. Consider a person: if you have them write down their problem-solving plan first, and the plan is right, the answer that follows the plan is much more likely to be right. The same holds for next-word prediction: words that state a correct solution are far more probable when they follow from a correct chain of reasoning than when they must appear from nowhere. The technique is called chain of thought, and its simplest form is a single instruction — think step by step:

Teaching the chain itself by example

Now put the two ideas together. "Think step by step" asks for some reasoning — the model decides what the steps are. But you can go further: show a worked example of the thinking you want, and the model will reason your way. Problem, then Think step by step:, then the reasoning, then the solution — and a new problem after it:

Teaching a voice

Now the case where rules fail almost completely. Try to write rules for how you write. "Short sentences. Concrete. Warm but not casual…" — every writer's style guide sounds the same, and none of them captures a voice. But samples do:

The principle

Refining by preference: examples as the steering wheel

So far the examples came first and the output came after. Now reverse it — because this becomes the simplest and most practical way to improve a prompt you already have. The method comes from one of our own papers (Preference-Driven Refinement of Prompts, White et al., 2025), and it works like this:

Watch one round:

The refinement loop is worth naming as a habit, because it changes your relationship to a misbehaving prompt. When the model makes a mistake, your first instinct is to explain the mistake in words. Often the stronger move is to capture the mistake itself — paste it into the prompt as an explicit negative example — and to capture the best output you've seen as a positive one. The model never changes; the prompt does. But the effect is the one you wanted: behavior, steered — one example at a time.

The conversation teaches itself

One last thing to carry out of this lesson, and it changes how you read every conversation from here on. You have been placing examples into the prompt deliberately. But the conversation itself becomes a pattern — one that grows as the conversation grows. Every turn adds to the document, and the model learns from all of it, including the parts it wrote. As a conversation lengthens, patterns inside it start to repeat, and repetition is exactly what this machine is built to continue.

This cuts both ways, and you must watch for both:

The lesson from teaching-by-example is that examples are powerful teachers. The warning is that the conversation is always teaching — whether or not you meant it to. A pattern you let stand early becomes a pattern the model reinforces later, on itself. Later in the course this becomes a design tool: we will deliberately seed and prune the conversation to steer the patterns it reinforces. For now, simply start noticing — a conversation is a pattern that grows, and it will teach the model whatever it is allowed to repeat.