Prompting Methods: The Different Ways We Talk to AI
Here’s something a little unfair about AI: the exact same model, on the exact same question, will hand one person a lazy, wrong answer and hand another person a careful, correct one. Nothing changed about the model. The only difference was how they asked.
That gap is what “prompting” is about, and over the last few years it stopped being guesswork and became a real, named toolkit. There’s a method for when you have no examples, one for when you have a few, one that makes the model show its work and suddenly get much smarter, one that asks the model the same thing several times and takes a vote, and one that lets it reason and act. Each has a name, an origin, and a moment when it’s the right tool.
Let me walk you through them, from the simplest to the cleverest, with real examples. I’ll keep it plain enough for a first-timer, and I’ll end with the honest 2026 twist: the newest models quietly changed which of these you still need to do by hand.
The whole point, in one picture
1. Zero-shot: just ask
The simplest method, and the one you use without thinking. Zero-shot means you give the model a task with no examples at all and rely on everything it learned during training to figure out what you want. “Translate this to French.” “Is this review positive or negative?” No demonstrations, just the instruction.
It works remarkably often, because a big model has seen so much during training that most everyday tasks are already familiar. Zero-shot is your default: quick, clean, no setup. You only reach for something fancier when zero-shot stumbles.
2. Few-shot: show, don’t just tell
Sometimes an instruction isn’t enough, the model needs to see the pattern you want. Few-shot prompting gives it a handful of examples right inside the prompt, then asks it to continue the pattern. The remarkable part is that the model learns the pattern on the spot, without any retraining. This is called in-context learning, and it’s one of the genuinely surprising abilities of large models.
3. Chain-of-thought: make it show its work
This is the one that changed everything, and it came from a 2022 paper by Jason Wei and colleagues at Google. The insight is almost childishly simple: if you want the model to reason correctly, make it reason out loud before answering. Instead of jumping straight to the answer, it writes out the intermediate steps, exactly like a student showing their working in a math exam.
The results were striking enough to see as bars. Same model, same questions, the only change is whether it was asked to reason step by step first:
There’s a lovely shortcut version too. You don’t always need examples, sometimes just adding the words “Let’s think step by step” to a plain zero-shot prompt is enough to switch on that same careful reasoning. A five-word phrase, measurable gains. That’s zero-shot chain-of-thought.
4. Self-consistency: ask several times, take a vote
Chain-of-thought has one weakness: it produces one line of reasoning, and if that one path takes a wrong turn early, the whole answer is wrong. Self-consistency (from Wang and colleagues, 2022) fixes this with a beautifully simple idea borrowed from how humans check hard problems: solve it several different ways, then go with the answer you land on most often.
The cost is obvious: you’re paying to run the prompt several times instead of once. So you save self-consistency for problems where getting it right matters more than getting it cheap.
5. Role and system prompting: set the stage
A different lever entirely: instead of shaping the reasoning, you shape the persona and rules. Role prompting tells the model who to be (“You are a meticulous security reviewer”), which quietly pulls its answers toward that frame. System prompting sets the standing rules for the whole conversation, the constraints, the tone, the format, before the user even speaks. These are less about cleverness and more about framing: give the model a clear identity and clear boundaries, and its answers get more consistent and on-target.
6. ReAct: reason and act
The most advanced one, and if you read my post on how agents work, you already met it. ReAct (Yao and colleagues, 2022) interleaves reasoning with actions, the model thinks a step, then actually does something (searches, runs code, calls an API), sees the real result, and reasons again. It’s the bridge from “a model that talks” to “an agent that acts,” and in 2026 nearly every AI agent runs on a ReAct-style loop underneath. I won’t re-teach it here; just know it belongs on this list as the method that turns prompting into doing.
Putting it together: which method, when
Here’s the whole toolkit as a ladder, from reach-for-it-first to save-it-for-when-you-need-it:
| Method | What it does | Best for | Cost |
|---|---|---|---|
| Zero-shot | Ask with no examples | Common, well-understood tasks | Lowest |
| Few-shot | Show a few examples | Specific formats, niche tasks | Low |
| Chain-of-thought | Reason step by step | Math, logic, multi-step problems | Low to medium |
| Self-consistency | Vote over many tries | High-stakes correctness | Higher (many runs) |
| Role / system | Set persona and rules | Tone, consistency, constraints | Lowest |
| ReAct | Reason + use tools | Agents that act in the world | Varies |
The honest 2026 twist
Here’s the part most guides won’t tell you, and it matters. The newest models changed the game. Claude’s extended thinking, GPT-5’s reasoning modes, and similar features do chain-of-thought automatically, internally, before they answer. You don’t have to type “let’s think step by step” anymore; the model already does, on its own.
So does that make these methods obsolete? No, but it reshuffles them. Two honest shifts:
- Manual chain-of-thought matters less on the strongest reasoning models, because they already reason internally. On smaller or older models, it still helps a lot.
- Few-shot examples are quietly changing job. Recent research on strong models found that adding worked examples often doesn’t boost their reasoning anymore, instead, the examples mostly serve to lock in the output format you want. The example’s job shifted from “teach the model to think” to “show the model exactly how to shape its answer.”
The deeper lesson underneath all of it: prompt engineering became writing clear specs. State what you want, the constraints, the format, give structure and maybe an example, and let the model’s own reasoning do the rest. Structure beats length. A short, precise, well-shaped ask beats a long rambling one every time.
The takeaway
The same model can be dull or brilliant depending on how you talk to it, and now you know the vocabulary. Zero-shot to just ask. Few-shot to show the pattern. Chain-of-thought to make it reason. Self-consistency to vote away mistakes. Role and system prompts to set the stage. ReAct to let it act. Start at the simplest rung and climb only as high as the problem needs.
And as models keep getting better at reasoning on their own, the skill quietly shifts from tricking the model into thinking, toward clearly telling it what good looks like. Which, when you step back, is just good communication, the same thing that gets you a good answer from a sharp human colleague. Ask clearly, show what you mean, and give them room to think.