Two techniques. One has aged well. The other has aged badly.
Lesson 01 set up the six-knob prompt scaffold (role, task, context, format, examples, constraints). This lesson is about two of the most-cited prompting techniques: few-shot examples and chain-of-thought (CoT). They were both gospel in 2023. By 2026, one is still gospel; the other has become a trap.
Few-shot — still works, when used right
Few-shot prompting is putting 2–5 example input/output pairs in the prompt before the real query:
Classify these records as 'bug', 'billing',
or 'how-to'. Here are three examples:
Record: 'page crashes when I click save' -> bug
Record: 'why did my card get charged twice' -> billing
Record: 'how do I export to CSV' -> how-to
Now classify: 'my exports are blank since yesterday'
The model sees the pattern and follows it. Three places this genuinely earns its keep:
- Format lock-in. When you need the output in a specific shape (label only, JSON, fixed prefix), examples teach the shape better than instructions can describe it.
- Domain disambiguation. "Classify these records" means a different thing in different products. Examples ground the classifier in your labels, not the model's prior.
- Output style. Tone, formality, brand voice — show, don't tell. Even three examples set tone better than a paragraph.
It also has failure modes — covered in steps 6 and 7 — most notably format lock-in working too well (model rigidly mimics example format even when the user's actual query needs different formatting).
CoT — the trap on reasoning models
Chain-of-thought prompting (adding "think step by step" or "explain your reasoning before answering") was the single highest-leverage technique on GPT-4 and Claude 3 in 2023–2024. On modern reasoning models (OpenAI's o-series, Claude with extended thinking, Gemini 2.5+), it's at best redundant and at worst harmful.
Why: reasoning models do step-by-step reasoning internally — that's the whole feature. Asking them to "think step by step" out loud:
- Adds output tokens (and cost).
- Doesn't improve accuracy on most benchmarks.
- Sometimes hurts — explicit CoT in the prompt can interfere with the model's internal reasoning trace, lowering answer quality.
Cited evidence:
- Wharton's Decreasing Value of Chain-of-Thought (2025) — measured CoT's value shrinking on newer reasoning models: still a small net accuracy gain, but often not worth the added variability and time/token cost.
- OpenAI's reasoning best-practices guide advises against chain-of-thought prompts on its reasoning models: because these models reason internally, telling them to "think step by step" or "explain your reasoning" is unnecessary and can sometimes hurt performance.
The 2026 rule: CoT helps non-reasoning models (Sonnet, GPT-4o, Haiku). It doesn't help reasoning models (o-series, Claude with extended thinking, Gemini 2.5+). Always ask: which model class am I prompting?
What everyone calls these techniques
| Technique | Names you'll see |
|---|---|
| Few-shot | "in-context learning," "in-prompt examples," "k-shot" (k=2,3,5...) |
| Chain-of-thought | "CoT," "step-by-step," "scratchpad," "reasoning prefix" |
| Reasoning models | OpenAI o-series (o1, o3, o4), Claude with extended thinking, Gemini 2.5 Thinking, DeepSeek R1 |
| Non-reasoning models | "Standard models" — Sonnet without extended thinking, GPT-4o, Haiku |
What you'll build
A build_few_shot_prompt(task, examples, query) that assembles
the canonical example-driven prompt format. Then the bug step 6
fixes: bolting "think step by step" onto a reasoning-model prompt
(redundant at best, harmful at worst). Then the bug step 7 fixes:
example format mismatching the actual query format (the model
locks in on the wrong template).
Two techniques. One has aged well. The other has aged badly.
Lesson 01 set up the six-knob prompt scaffold (role, task, context, format, examples, constraints). This lesson is about two of the most-cited prompting techniques: few-shot examples and chain-of-thought (CoT). They were both gospel in 2023. By 2026, one is still gospel; the other has become a trap.
Few-shot — still works, when used right
Few-shot prompting is putting 2–5 example input/output pairs in the prompt before the real query:
Classify these actions as 'ship-this-week', 'backlog',
or 'page'. Here are three examples:
Action: 'retry storm on payments, owner named' -> ship-this-week
Action: 'docs typo found in the timeline' -> backlog
Action: 'error rate still climbing' -> page
Now classify: 'follow-up has no service on the approved list'
The model sees the pattern and follows it. Three places this genuinely earns its keep:
- Format lock-in. When you need the output in a specific shape (label only, JSON, fixed prefix), examples teach the shape better than instructions can describe it.
- Domain disambiguation. "Classify incident notes" means a different thing in different products. Examples ground the classifier in your labels, not the model's prior.
- Output style. Tone, formality, brand voice — show, don't tell. Even three examples set tone better than a paragraph.
It also has failure modes — covered in steps 6 and 7 — most notably format lock-in working too well (model rigidly mimics example format even when the user's actual query needs different formatting).
CoT — the trap on reasoning models
Chain-of-thought prompting (adding "think step by step" or "explain your reasoning before answering") was the single highest-leverage technique on GPT-4 and Claude 3 in 2023–2024. On modern reasoning models (OpenAI's o-series, Claude with extended thinking, Gemini 2.5+), it's at best redundant and at worst harmful.
Why: reasoning models do step-by-step reasoning internally — that's the whole feature. Asking them to "think step by step" out loud:
- Adds output tokens (and cost).
- Doesn't improve accuracy on most benchmarks.
- Sometimes hurts — explicit CoT in the prompt can interfere with the model's internal reasoning trace, lowering answer quality.
Cited evidence:
- Wharton's Decreasing Value of Chain-of-Thought (2025) — measured CoT's value shrinking on newer reasoning models: still a small net accuracy gain, but often not worth the added variability and time/token cost.
- OpenAI's reasoning best-practices guide advises against chain-of-thought prompts on its reasoning models: because these models reason internally, telling them to "think step by step" or "explain your reasoning" is unnecessary and can sometimes hurt performance.
The 2026 rule: CoT helps non-reasoning models (Sonnet, GPT-4o, Haiku). It doesn't help reasoning models (o-series, Claude with extended thinking, Gemini 2.5+). Always ask: which model class am I prompting?
What everyone calls these techniques
| Technique | Names you'll see |
|---|---|
| Few-shot | "in-context learning," "in-prompt examples," "k-shot" (k=2,3,5...) |
| Chain-of-thought | "CoT," "step-by-step," "scratchpad," "reasoning prefix" |
| Reasoning models | OpenAI o-series (o1, o3, o4), Claude with extended thinking, Gemini 2.5 Thinking, DeepSeek R1 |
| Non-reasoning models | "Standard models" — Sonnet without extended thinking, GPT-4o, Haiku |
What you'll build
A build_few_shot_prompt(task, examples, query) that assembles
the canonical example-driven prompt format. Then the bug step 6
fixes: bolting "think step by step" onto a reasoning-model prompt
(redundant at best, harmful at worst). Then the bug step 7 fixes:
example format mismatching the actual query format (the model
locks in on the wrong template).
Two techniques. One has aged well. The other has aged badly.
Lesson 01 set up the six-knob prompt scaffold (role, task, context, format, examples, constraints). This lesson is about two of the most-cited prompting techniques: few-shot examples and chain-of-thought (CoT). They were both gospel in 2023. By 2026, one is still gospel; the other has become a trap.
Few-shot — still works, when used right
Few-shot prompting is putting 2–5 example input/output pairs in the prompt before the real query:
Classify these assets as 'ship', 'slip',
or 'legal-hold'. Here are three examples:
Asset: 'email draft, channel owner named' -> ship
Asset: 'date missing from the calendar' -> slip
Asset: 'claim still in legal review' -> legal-hold
Now classify: 'landing page ready, no ship date'
The model sees the pattern and follows it. Three places this genuinely earns its keep:
- Format lock-in. When you need the output in a specific shape (label only, JSON, fixed prefix), examples teach the shape better than instructions can describe it.
- Domain disambiguation. "Classify campaign assets" means a different thing in different products. Examples ground the classifier in your labels, not the model's prior.
- Output style. Tone, formality, brand voice — show, don't tell. Even three examples set tone better than a paragraph.
It also has failure modes — covered in steps 6 and 7 — most notably format lock-in working too well (model rigidly mimics example format even when the user's actual query needs different formatting).
CoT — the trap on reasoning models
Chain-of-thought prompting (adding "think step by step" or "explain your reasoning before answering") was the single highest-leverage technique on GPT-4 and Claude 3 in 2023–2024. On modern reasoning models (OpenAI's o-series, Claude with extended thinking, Gemini 2.5+), it's at best redundant and at worst harmful.
Why: reasoning models do step-by-step reasoning internally — that's the whole feature. Asking them to "think step by step" out loud:
- Adds output tokens (and cost).
- Doesn't improve accuracy on most benchmarks.
- Sometimes hurts — explicit CoT in the prompt can interfere with the model's internal reasoning trace, lowering answer quality.
Cited evidence:
- Wharton's Decreasing Value of Chain-of-Thought (2025) — measured CoT's value shrinking on newer reasoning models: still a small net accuracy gain, but often not worth the added variability and time/token cost.
- OpenAI's reasoning best-practices guide advises against chain-of-thought prompts on its reasoning models: because these models reason internally, telling them to "think step by step" or "explain your reasoning" is unnecessary and can sometimes hurt performance.
The 2026 rule: CoT helps non-reasoning models (Sonnet, GPT-4o, Haiku). It doesn't help reasoning models (o-series, Claude with extended thinking, Gemini 2.5+). Always ask: which model class am I prompting?
What everyone calls these techniques
| Technique | Names you'll see |
|---|---|
| Few-shot | "in-context learning," "in-prompt examples," "k-shot" (k=2,3,5...) |
| Chain-of-thought | "CoT," "step-by-step," "scratchpad," "reasoning prefix" |
| Reasoning models | OpenAI o-series (o1, o3, o4), Claude with extended thinking, Gemini 2.5 Thinking, DeepSeek R1 |
| Non-reasoning models | "Standard models" — Sonnet without extended thinking, GPT-4o, Haiku |
What you'll build
A build_few_shot_prompt(task, examples, query) that assembles
the canonical example-driven prompt format. Then the bug step 6
fixes: bolting "think step by step" onto a reasoning-model prompt
(redundant at best, harmful at worst). Then the bug step 7 fixes:
example format mismatching the actual query format (the model
locks in on the wrong template).
Two techniques. One has aged well. The other has aged badly.
Lesson 01 set up the six-knob prompt scaffold (role, task, context, format, examples, constraints). This lesson is about two of the most-cited prompting techniques: few-shot examples and chain-of-thought (CoT). They were both gospel in 2023. By 2026, one is still gospel; the other has become a trap.
Few-shot — still works, when used right
Few-shot prompting is putting 2–5 example input/output pairs in the prompt before the real query:
Classify these brand assets as 'off-kit', 'needs-export',
or 'approved'. Here are three examples:
Asset: 'logo uses last year's purple' -> off-kit
Asset: 'banner is 2x the max width' -> needs-export
Asset: 'icon matches the kit list' -> approved
Now classify: 'wordmark is a new weight since yesterday'
The model sees the pattern and follows it. Three places this genuinely earns its keep:
- Format lock-in. When you need the output in a specific shape (label only, JSON, fixed prefix), examples teach the shape better than instructions can describe it.
- Domain disambiguation. "Classify brand assets" means a different thing in different products. Examples ground the classifier in your labels, not the model's prior.
- Output style. Tone, formality, brand voice — show, don't tell. Even three examples set tone better than a paragraph.
It also has failure modes — covered in steps 6 and 7 — most notably format lock-in working too well (model rigidly mimics example format even when the user's actual query needs different formatting).
CoT — the trap on reasoning models
Chain-of-thought prompting (adding "think step by step" or "explain your reasoning before answering") was the single highest-leverage technique on GPT-4 and Claude 3 in 2023–2024. On modern reasoning models (OpenAI's o-series, Claude with extended thinking, Gemini 2.5+), it's at best redundant and at worst harmful.
Why: reasoning models do step-by-step reasoning internally — that's the whole feature. Asking them to "think step by step" out loud:
- Adds output tokens (and cost).
- Doesn't improve accuracy on most benchmarks.
- Sometimes hurts — explicit CoT in the prompt can interfere with the model's internal reasoning trace, lowering answer quality.
Cited evidence:
- Wharton's Decreasing Value of Chain-of-Thought (2025) — measured CoT's value shrinking on newer reasoning models: still a small net accuracy gain, but often not worth the added variability and time/token cost.
- OpenAI's reasoning best-practices guide advises against chain-of-thought prompts on its reasoning models: because these models reason internally, telling them to "think step by step" or "explain your reasoning" is unnecessary and can sometimes hurt performance.
The 2026 rule: CoT helps non-reasoning models (Sonnet, GPT-4o, Haiku). It doesn't help reasoning models (o-series, Claude with extended thinking, Gemini 2.5+). Always ask: which model class am I prompting?
What everyone calls these techniques
| Technique | Names you'll see |
|---|---|
| Few-shot | "in-context learning," "in-prompt examples," "k-shot" (k=2,3,5...) |
| Chain-of-thought | "CoT," "step-by-step," "scratchpad," "reasoning prefix" |
| Reasoning models | OpenAI o-series (o1, o3, o4), Claude with extended thinking, Gemini 2.5 Thinking, DeepSeek R1 |
| Non-reasoning models | "Standard models" — Sonnet without extended thinking, GPT-4o, Haiku |
What you'll build
A build_few_shot_prompt(task, examples, query) that assembles
the canonical example-driven prompt format. Then the bug step 6
fixes: bolting "think step by step" onto a reasoning-model prompt
(redundant at best, harmful at worst). Then the bug step 7 fixes:
example format mismatching the actual query format (the model
locks in on the wrong template).
Two techniques. One has aged well. The other has aged badly.
Lesson 01 set up the six-knob prompt scaffold (role, task, context, format, examples, constraints). This lesson is about two of the most-cited prompting techniques: few-shot examples and chain-of-thought (CoT). They were both gospel in 2023. By 2026, one is still gospel; the other has become a trap.
Few-shot — still works, when used right
Few-shot prompting is putting 2–5 example input/output pairs in the prompt before the real query:
Classify these support tickets as 'bug', 'billing',
or 'how-to'. Here are three examples:
Ticket: 'page crashes when I click save' -> bug
Ticket: 'why did my card get charged twice' -> billing
Ticket: 'how do I export to CSV' -> how-to
Now classify: 'my exports are blank since yesterday'
The model sees the pattern and follows it. Three places this genuinely earns its keep:
- Format lock-in. When you need the output in a specific shape (label only, JSON, fixed prefix), examples teach the shape better than instructions can describe it.
- Domain disambiguation. "Classify support tickets" means a different thing in different products. Examples ground the classifier in your labels, not the model's prior.
- Output style. Tone, formality, brand voice — show, don't tell. Even three examples set tone better than a paragraph.
It also has failure modes — covered in steps 6 and 7 — most notably format lock-in working too well (model rigidly mimics example format even when the user's actual query needs different formatting).
CoT — the trap on reasoning models
Chain-of-thought prompting (adding "think step by step" or "explain your reasoning before answering") was the single highest-leverage technique on GPT-4 and Claude 3 in 2023–2024. On modern reasoning models (OpenAI's o-series, Claude with extended thinking, Gemini 2.5+), it's at best redundant and at worst harmful.
Why: reasoning models do step-by-step reasoning internally — that's the whole feature. Asking them to "think step by step" out loud:
- Adds output tokens (and cost).
- Doesn't improve accuracy on most benchmarks.
- Sometimes hurts — explicit CoT in the prompt can interfere with the model's internal reasoning trace, lowering answer quality.
Cited evidence:
- Wharton's Decreasing Value of Chain-of-Thought (2025) — measured CoT's value shrinking on newer reasoning models: still a small net accuracy gain, but often not worth the added variability and time/token cost.
- OpenAI's reasoning best-practices guide advises against chain-of-thought prompts on its reasoning models: because these models reason internally, telling them to "think step by step" or "explain your reasoning" is unnecessary and can sometimes hurt performance.
The 2026 rule: CoT helps non-reasoning models (Sonnet, GPT-4o, Haiku). It doesn't help reasoning models (o-series, Claude with extended thinking, Gemini 2.5+). Always ask: which model class am I prompting?
What everyone calls these techniques
| Technique | Names you'll see |
|---|---|
| Few-shot | "in-context learning," "in-prompt examples," "k-shot" (k=2,3,5...) |
| Chain-of-thought | "CoT," "step-by-step," "scratchpad," "reasoning prefix" |
| Reasoning models | OpenAI o-series (o1, o3, o4), Claude with extended thinking, Gemini 2.5 Thinking, DeepSeek R1 |
| Non-reasoning models | "Standard models" — Sonnet without extended thinking, GPT-4o, Haiku |
What you'll build
A build_few_shot_prompt(task, examples, query) that assembles
the canonical example-driven prompt format. Then the bug step 6
fixes: bolting "think step by step" onto a reasoning-model prompt
(redundant at best, harmful at worst). Then the bug step 7 fixes:
example format mismatching the actual query format (the model
locks in on the wrong template).
Two techniques. One has aged well. The other has aged badly.
Lesson 01 set up the six-knob prompt scaffold (role, task, context, format, examples, constraints). This lesson is about two of the most-cited prompting techniques: few-shot examples and chain-of-thought (CoT). They were both gospel in 2023. By 2026, one is still gospel; the other has become a trap.
Few-shot — still works, when used right
Few-shot prompting is putting 2–5 example input/output pairs in the prompt before the real query:
Classify these claims as 'cleared', 'struck',
or 'needs-source'. Here are three examples:
Claim: 'badge from last quarter's G2 report' -> cleared
Claim: 'fastest in class, no source cell' -> needs-source
Claim: 'SOC2 line expired in March' -> struck
Now classify: 'used by 40,000 teams, source tab blank'
The model sees the pattern and follows it. Three places this genuinely earns its keep:
- Format lock-in. When you need the output in a specific shape (label only, JSON, fixed prefix), examples teach the shape better than instructions can describe it.
- Domain disambiguation. "Classify claims" means a different thing in different products. Examples ground the classifier in your labels, not the model's prior.
- Output style. Tone, formality, brand voice — show, don't tell. Even three examples set tone better than a paragraph.
It also has failure modes — covered in steps 6 and 7 — most notably format lock-in working too well (model rigidly mimics example format even when the user's actual query needs different formatting).
CoT — the trap on reasoning models
Chain-of-thought prompting (adding "think step by step" or "explain your reasoning before answering") was the single highest-leverage technique on GPT-4 and Claude 3 in 2023–2024. On modern reasoning models (OpenAI's o-series, Claude with extended thinking, Gemini 2.5+), it's at best redundant and at worst harmful.
Why: reasoning models do step-by-step reasoning internally — that's the whole feature. Asking them to "think step by step" out loud:
- Adds output tokens (and cost).
- Doesn't improve accuracy on most benchmarks.
- Sometimes hurts — explicit CoT in the prompt can interfere with the model's internal reasoning trace, lowering answer quality.
Cited evidence:
- Wharton's Decreasing Value of Chain-of-Thought (2025) — measured CoT's value shrinking on newer reasoning models: still a small net accuracy gain, but often not worth the added variability and time/token cost.
- OpenAI's reasoning best-practices guide advises against chain-of-thought prompts on its reasoning models: because these models reason internally, telling them to "think step by step" or "explain your reasoning" is unnecessary and can sometimes hurt performance.
The 2026 rule: CoT helps non-reasoning models (Sonnet, GPT-4o, Haiku). It doesn't help reasoning models (o-series, Claude with extended thinking, Gemini 2.5+). Always ask: which model class am I prompting?
What everyone calls these techniques
| Technique | Names you'll see |
|---|---|
| Few-shot | "in-context learning," "in-prompt examples," "k-shot" (k=2,3,5...) |
| Chain-of-thought | "CoT," "step-by-step," "scratchpad," "reasoning prefix" |
| Reasoning models | OpenAI o-series (o1, o3, o4), Claude with extended thinking, Gemini 2.5 Thinking, DeepSeek R1 |
| Non-reasoning models | "Standard models" — Sonnet without extended thinking, GPT-4o, Haiku |
What you'll build
A build_few_shot_prompt(task, examples, query) that assembles
the canonical example-driven prompt format. Then the bug step 6
fixes: bolting "think step by step" onto a reasoning-model prompt
(redundant at best, harmful at worst). Then the bug step 7 fixes:
example format mismatching the actual query format (the model
locks in on the wrong template).
Two techniques. One has aged well. The other has aged badly.
Lesson 01 set up the six-knob prompt scaffold (role, task, context, format, examples, constraints). This lesson is about two of the most-cited prompting techniques: few-shot examples and chain-of-thought (CoT). They were both gospel in 2023. By 2026, one is still gospel; the other has become a trap.
Few-shot — still works, when used right
Few-shot prompting is putting 2–5 example input/output pairs in the prompt before the real query:
Classify these cuts as 'act', 'caveat',
or 'hold'. Here are three examples:
Cut: 'row count stable, receipt attached' -> act
Cut: 'source file is a week stale' -> caveat
Cut: 'segment missing from the cut list' -> hold
Now classify: 'finding looks strong, method note blank'
The model sees the pattern and follows it. Three places this genuinely earns its keep:
- Format lock-in. When you need the output in a specific shape (label only, JSON, fixed prefix), examples teach the shape better than instructions can describe it.
- Domain disambiguation. "Classify research cuts" means a different thing in different products. Examples ground the classifier in your labels, not the model's prior.
- Output style. Tone, formality, brand voice — show, don't tell. Even three examples set tone better than a paragraph.
It also has failure modes — covered in steps 6 and 7 — most notably format lock-in working too well (model rigidly mimics example format even when the user's actual query needs different formatting).
CoT — the trap on reasoning models
Chain-of-thought prompting (adding "think step by step" or "explain your reasoning before answering") was the single highest-leverage technique on GPT-4 and Claude 3 in 2023–2024. On modern reasoning models (OpenAI's o-series, Claude with extended thinking, Gemini 2.5+), it's at best redundant and at worst harmful.
Why: reasoning models do step-by-step reasoning internally — that's the whole feature. Asking them to "think step by step" out loud:
- Adds output tokens (and cost).
- Doesn't improve accuracy on most benchmarks.
- Sometimes hurts — explicit CoT in the prompt can interfere with the model's internal reasoning trace, lowering answer quality.
Cited evidence:
- Wharton's Decreasing Value of Chain-of-Thought (2025) — measured CoT's value shrinking on newer reasoning models: still a small net accuracy gain, but often not worth the added variability and time/token cost.
- OpenAI's reasoning best-practices guide advises against chain-of-thought prompts on its reasoning models: because these models reason internally, telling them to "think step by step" or "explain your reasoning" is unnecessary and can sometimes hurt performance.
The 2026 rule: CoT helps non-reasoning models (Sonnet, GPT-4o, Haiku). It doesn't help reasoning models (o-series, Claude with extended thinking, Gemini 2.5+). Always ask: which model class am I prompting?
What everyone calls these techniques
| Technique | Names you'll see |
|---|---|
| Few-shot | "in-context learning," "in-prompt examples," "k-shot" (k=2,3,5...) |
| Chain-of-thought | "CoT," "step-by-step," "scratchpad," "reasoning prefix" |
| Reasoning models | OpenAI o-series (o1, o3, o4), Claude with extended thinking, Gemini 2.5 Thinking, DeepSeek R1 |
| Non-reasoning models | "Standard models" — Sonnet without extended thinking, GPT-4o, Haiku |
What you'll build
A build_few_shot_prompt(task, examples, query) that assembles
the canonical example-driven prompt format. Then the bug step 6
fixes: bolting "think step by step" onto a reasoning-model prompt
(redundant at best, harmful at worst). Then the bug step 7 fixes:
example format mismatching the actual query format (the model
locks in on the wrong template).
Two techniques. One has aged well. The other has aged badly.
Lesson 01 set up the six-knob prompt scaffold (role, task, context, format, examples, constraints). This lesson is about two of the most-cited prompting techniques: few-shot examples and chain-of-thought (CoT). They were both gospel in 2023. By 2026, one is still gospel; the other has become a trap.
Few-shot — still works, when used right
Few-shot prompting is putting 2–5 example input/output pairs in the prompt before the real query:
Classify these initiatives as 'on-track', 'scope-cut',
or 'blocked'. Here are three examples:
Item: 'launch date slipped one week, owner named' -> on-track
Item: 'two teams, one date, no cut list' -> scope-cut
Item: 'compliance review still open' -> blocked
Now classify: 'staffing gap on the dependency, no new date'
The model sees the pattern and follows it. Three places this genuinely earns its keep:
- Format lock-in. When you need the output in a specific shape (label only, JSON, fixed prefix), examples teach the shape better than instructions can describe it.
- Domain disambiguation. "Classify roadmap risks" means a different thing in different products. Examples ground the classifier in your labels, not the model's prior.
- Output style. Tone, formality, brand voice — show, don't tell. Even three examples set tone better than a paragraph.
It also has failure modes — covered in steps 6 and 7 — most notably format lock-in working too well (model rigidly mimics example format even when the user's actual query needs different formatting).
CoT — the trap on reasoning models
Chain-of-thought prompting (adding "think step by step" or "explain your reasoning before answering") was the single highest-leverage technique on GPT-4 and Claude 3 in 2023–2024. On modern reasoning models (OpenAI's o-series, Claude with extended thinking, Gemini 2.5+), it's at best redundant and at worst harmful.
Why: reasoning models do step-by-step reasoning internally — that's the whole feature. Asking them to "think step by step" out loud:
- Adds output tokens (and cost).
- Doesn't improve accuracy on most benchmarks.
- Sometimes hurts — explicit CoT in the prompt can interfere with the model's internal reasoning trace, lowering answer quality.
Cited evidence:
- Wharton's Decreasing Value of Chain-of-Thought (2025) — measured CoT's value shrinking on newer reasoning models: still a small net accuracy gain, but often not worth the added variability and time/token cost.
- OpenAI's reasoning best-practices guide advises against chain-of-thought prompts on its reasoning models: because these models reason internally, telling them to "think step by step" or "explain your reasoning" is unnecessary and can sometimes hurt performance.
The 2026 rule: CoT helps non-reasoning models (Sonnet, GPT-4o, Haiku). It doesn't help reasoning models (o-series, Claude with extended thinking, Gemini 2.5+). Always ask: which model class am I prompting?
What everyone calls these techniques
| Technique | Names you'll see |
|---|---|
| Few-shot | "in-context learning," "in-prompt examples," "k-shot" (k=2,3,5...) |
| Chain-of-thought | "CoT," "step-by-step," "scratchpad," "reasoning prefix" |
| Reasoning models | OpenAI o-series (o1, o3, o4), Claude with extended thinking, Gemini 2.5 Thinking, DeepSeek R1 |
| Non-reasoning models | "Standard models" — Sonnet without extended thinking, GPT-4o, Haiku |
What you'll build
A build_few_shot_prompt(task, examples, query) that assembles
the canonical example-driven prompt format. Then the bug step 6
fixes: bolting "think step by step" onto a reasoning-model prompt
(redundant at best, harmful at worst). Then the bug step 7 fixes:
example format mismatching the actual query format (the model
locks in on the wrong template).
Two techniques. One has aged well. The other has aged badly.
Lesson 01 set up the six-knob prompt scaffold (role, task, context, format, examples, constraints). This lesson is about two of the most-cited prompting techniques: few-shot examples and chain-of-thought (CoT). They were both gospel in 2023. By 2026, one is still gospel; the other has become a trap.
Few-shot — still works, when used right
Few-shot prompting is putting 2–5 example input/output pairs in the prompt before the real query:
Classify these notes as 'advance', 'hold',
or 'reject'. Here are three examples:
Note: 'strong systems examples, panel aligned' -> advance
Note: 'missing the competency we still need to probe' -> hold
Note: 'score sheet blank on two required skills' -> reject
Now classify: 'debrief says maybe, no owner on the follow-up'
The model sees the pattern and follows it. Three places this genuinely earns its keep:
- Format lock-in. When you need the output in a specific shape (label only, JSON, fixed prefix), examples teach the shape better than instructions can describe it.
- Domain disambiguation. "Classify interview notes" means a different thing in different products. Examples ground the classifier in your labels, not the model's prior.
- Output style. Tone, formality, brand voice — show, don't tell. Even three examples set tone better than a paragraph.
It also has failure modes — covered in steps 6 and 7 — most notably format lock-in working too well (model rigidly mimics example format even when the user's actual query needs different formatting).
CoT — the trap on reasoning models
Chain-of-thought prompting (adding "think step by step" or "explain your reasoning before answering") was the single highest-leverage technique on GPT-4 and Claude 3 in 2023–2024. On modern reasoning models (OpenAI's o-series, Claude with extended thinking, Gemini 2.5+), it's at best redundant and at worst harmful.
Why: reasoning models do step-by-step reasoning internally — that's the whole feature. Asking them to "think step by step" out loud:
- Adds output tokens (and cost).
- Doesn't improve accuracy on most benchmarks.
- Sometimes hurts — explicit CoT in the prompt can interfere with the model's internal reasoning trace, lowering answer quality.
Cited evidence:
- Wharton's Decreasing Value of Chain-of-Thought (2025) — measured CoT's value shrinking on newer reasoning models: still a small net accuracy gain, but often not worth the added variability and time/token cost.
- OpenAI's reasoning best-practices guide advises against chain-of-thought prompts on its reasoning models: because these models reason internally, telling them to "think step by step" or "explain your reasoning" is unnecessary and can sometimes hurt performance.
The 2026 rule: CoT helps non-reasoning models (Sonnet, GPT-4o, Haiku). It doesn't help reasoning models (o-series, Claude with extended thinking, Gemini 2.5+). Always ask: which model class am I prompting?
What everyone calls these techniques
| Technique | Names you'll see |
|---|---|
| Few-shot | "in-context learning," "in-prompt examples," "k-shot" (k=2,3,5...) |
| Chain-of-thought | "CoT," "step-by-step," "scratchpad," "reasoning prefix" |
| Reasoning models | OpenAI o-series (o1, o3, o4), Claude with extended thinking, Gemini 2.5 Thinking, DeepSeek R1 |
| Non-reasoning models | "Standard models" — Sonnet without extended thinking, GPT-4o, Haiku |
What you'll build
A build_few_shot_prompt(task, examples, query) that assembles
the canonical example-driven prompt format. Then the bug step 6
fixes: bolting "think step by step" onto a reasoning-model prompt
(redundant at best, harmful at worst). Then the bug step 7 fixes:
example format mismatching the actual query format (the model
locks in on the wrong template).
Two techniques. One has aged well. The other has aged badly.
Lesson 01 set up the six-knob prompt scaffold (role, task, context, format, examples, constraints). This lesson is about two of the most-cited prompting techniques: few-shot examples and chain-of-thought (CoT). They were both gospel in 2023. By 2026, one is still gospel; the other has become a trap.
Few-shot — still works, when used right
Few-shot prompting is putting 2–5 example input/output pairs in the prompt before the real query:
Classify these steps as 'clear', 'blocked',
or 'needs-approval'. Here are three examples:
Step: 'gate signed, next shift named' -> clear
Step: 'approval still open on step 4' -> needs-approval
Step: 'exception with no owner' -> blocked
Now classify: 'handoff note says wait, no gate checked'
The model sees the pattern and follows it. Three places this genuinely earns its keep:
- Format lock-in. When you need the output in a specific shape (label only, JSON, fixed prefix), examples teach the shape better than instructions can describe it.
- Domain disambiguation. "Classify handoff exceptions" means a different thing in different products. Examples ground the classifier in your labels, not the model's prior.
- Output style. Tone, formality, brand voice — show, don't tell. Even three examples set tone better than a paragraph.
It also has failure modes — covered in steps 6 and 7 — most notably format lock-in working too well (model rigidly mimics example format even when the user's actual query needs different formatting).
CoT — the trap on reasoning models
Chain-of-thought prompting (adding "think step by step" or "explain your reasoning before answering") was the single highest-leverage technique on GPT-4 and Claude 3 in 2023–2024. On modern reasoning models (OpenAI's o-series, Claude with extended thinking, Gemini 2.5+), it's at best redundant and at worst harmful.
Why: reasoning models do step-by-step reasoning internally — that's the whole feature. Asking them to "think step by step" out loud:
- Adds output tokens (and cost).
- Doesn't improve accuracy on most benchmarks.
- Sometimes hurts — explicit CoT in the prompt can interfere with the model's internal reasoning trace, lowering answer quality.
Cited evidence:
- Wharton's Decreasing Value of Chain-of-Thought (2025) — measured CoT's value shrinking on newer reasoning models: still a small net accuracy gain, but often not worth the added variability and time/token cost.
- OpenAI's reasoning best-practices guide advises against chain-of-thought prompts on its reasoning models: because these models reason internally, telling them to "think step by step" or "explain your reasoning" is unnecessary and can sometimes hurt performance.
The 2026 rule: CoT helps non-reasoning models (Sonnet, GPT-4o, Haiku). It doesn't help reasoning models (o-series, Claude with extended thinking, Gemini 2.5+). Always ask: which model class am I prompting?
What everyone calls these techniques
| Technique | Names you'll see |
|---|---|
| Few-shot | "in-context learning," "in-prompt examples," "k-shot" (k=2,3,5...) |
| Chain-of-thought | "CoT," "step-by-step," "scratchpad," "reasoning prefix" |
| Reasoning models | OpenAI o-series (o1, o3, o4), Claude with extended thinking, Gemini 2.5 Thinking, DeepSeek R1 |
| Non-reasoning models | "Standard models" — Sonnet without extended thinking, GPT-4o, Haiku |
What you'll build
A build_few_shot_prompt(task, examples, query) that assembles
the canonical example-driven prompt format. Then the bug step 6
fixes: bolting "think step by step" onto a reasoning-model prompt
(redundant at best, harmful at worst). Then the bug step 7 fixes:
example format mismatching the actual query format (the model
locks in on the wrong template).
Two techniques. One has aged well. The other has aged badly.
Lesson 01 set up the six-knob prompt scaffold (role, task, context, format, examples, constraints). This lesson is about two of the most-cited prompting techniques: few-shot examples and chain-of-thought (CoT). They were both gospel in 2023. By 2026, one is still gospel; the other has become a trap.
Few-shot — still works, when used right
Few-shot prompting is putting 2–5 example input/output pairs in the prompt before the real query:
Classify these passages as 'privileged', 'produce',
or 'redact'. Here are three examples:
Passage: 'counsel advised we hold the draft' -> privileged
Passage: 'the price is in section 4.2' -> produce
Passage: 'client home address in the footer' -> redact
Now classify: 'the privilege log cites the same memo twice'
The model sees the pattern and follows it. Three places this genuinely earns its keep:
- Format lock-in. When you need the output in a specific shape (label only, JSON, fixed prefix), examples teach the shape better than instructions can describe it.
- Domain disambiguation. "Classify privilege calls" means a different thing in different products. Examples ground the classifier in your labels, not the model's prior.
- Output style. Tone, formality, brand voice — show, don't tell. Even three examples set tone better than a paragraph.
It also has failure modes — covered in steps 6 and 7 — most notably format lock-in working too well (model rigidly mimics example format even when the user's actual query needs different formatting).
CoT — the trap on reasoning models
Chain-of-thought prompting (adding "think step by step" or "explain your reasoning before answering") was the single highest-leverage technique on GPT-4 and Claude 3 in 2023–2024. On modern reasoning models (OpenAI's o-series, Claude with extended thinking, Gemini 2.5+), it's at best redundant and at worst harmful.
Why: reasoning models do step-by-step reasoning internally — that's the whole feature. Asking them to "think step by step" out loud:
- Adds output tokens (and cost).
- Doesn't improve accuracy on most benchmarks.
- Sometimes hurts — explicit CoT in the prompt can interfere with the model's internal reasoning trace, lowering answer quality.
Cited evidence:
- Wharton's Decreasing Value of Chain-of-Thought (2025) — measured CoT's value shrinking on newer reasoning models: still a small net accuracy gain, but often not worth the added variability and time/token cost.
- OpenAI's reasoning best-practices guide advises against chain-of-thought prompts on its reasoning models: because these models reason internally, telling them to "think step by step" or "explain your reasoning" is unnecessary and can sometimes hurt performance.
The 2026 rule: CoT helps non-reasoning models (Sonnet, GPT-4o, Haiku). It doesn't help reasoning models (o-series, Claude with extended thinking, Gemini 2.5+). Always ask: which model class am I prompting?
What everyone calls these techniques
| Technique | Names you'll see |
|---|---|
| Few-shot | "in-context learning," "in-prompt examples," "k-shot" (k=2,3,5...) |
| Chain-of-thought | "CoT," "step-by-step," "scratchpad," "reasoning prefix" |
| Reasoning models | OpenAI o-series (o1, o3, o4), Claude with extended thinking, Gemini 2.5 Thinking, DeepSeek R1 |
| Non-reasoning models | "Standard models" — Sonnet without extended thinking, GPT-4o, Haiku |
What you'll build
A build_few_shot_prompt(task, examples, query) that assembles
the canonical example-driven prompt format. Then the bug step 6
fixes: bolting "think step by step" onto a reasoning-model prompt
(redundant at best, harmful at worst). Then the bug step 7 fixes:
example format mismatching the actual query format (the model
locks in on the wrong template).