Chain of Thought Prompting in 2026: Wanneer Het Helpt, Wanneer Het Tegenwerkt

Chain of thought prompting heeft in 2026 een probleem dat de meeste gidsen overslaan: dezelfde truc die modellen in 2022 slimmer maakte, kan een redeneermodel vandaag juist zwakker maken. Wei et al. introduceerden de techniek in 2022 en verhoogden de nauwkeurigheid bij lastige wiskunde en logica door modellen hun redeneerstappen te laten tonen. Er zat een addertje onder het gras: het werkte pas zodra modellen ongeveer 100 miljard parameters passeerden. Inmiddels doen o-series- en GPT-5-redeneermodellen dat denkwerk intern, waardoor "denk stap voor stap" vaak alleen maar tokens verspilt. Wanneer gebruik je het dan nog wel, en wanneer sla je het over?

Belangrijkste inzichten:

• Chain of thought prompting toont de redeneerstappen van een model en verhoogt de nauwkeurigheid bij wiskunde, logica en code met meerdere stappen.
• Het is een emergente eigenschap: bij kleine modellen helpt het nauwelijks, en redeneermodellen doen het al intern.
• Bij o-series, GPT-5 reasoning en Claude extended thinking is handmatig "denk stap voor stap" vaak overbodig.
• Gebruik handmatige CoT nog wel bij non-reasoning en lokale open-source modellen, of wanneer je een controleerbaar redeneerpad nodig hebt.

Wat Is Chain of Thought Prompting?

Chain of thought (CoT) prompting is een techniek waarbij je een taalmodel vraagt om een probleem in expliciete tussenstappen te doorlopen voordat het een eindantwoord geeft. Geïntroduceerd door Wei et al. in 2022, verbetert het de nauwkeurigheid bij wiskunde, logica en gezond-verstandtaken met meerdere stappen, en het maakt de redenering van het model zichtbaar.

Stel een gewoon model zomaar een tekstsom en het gooit er vaak zonder nadenken het verkeerde getal uit. Vraag het eerst te redeneren, en de kans op een goed antwoord stijgt flink. Neem dit voorbeeld: "Een plank heeft 3 dozen met 7 boeken; ik haal er 5 weg. Wat blijft er over?" Zonder aansporing antwoordt een klein model soms "21." Voeg "Laten we stap voor stap nadenken" toe en het schrijft: 3 x 7 = 21, dan 21 - 5 = 16. Zelfde model, beter antwoord, en je ziet precies waar het misging als dat toch gebeurt. CoT is één instrument in de bredere toolkit uit onze gids voor prompt engineering; dit artikel zoomt helemaal in op die ene techniek.

Hoe Het Werkt (en Waarom Het Pas op Schaal Aansloeg)

CoT werkt doordat het model token voor token een redeneerpad in natuurlijke taal genereert, waardoor elke tussenconclusie de volgende beïnvloedt. Wei et al. (2022) ontdekten dat dit een emergente eigenschap is: bij kleine modellen helpt het nauwelijks, en pas zodra modellen ongeveer 100 miljard parameters passeren, ontstaan er grote nauwkeurigheidswinsten.

Zie het als het tonen van je uitwerking bij een wiskundetoets. Een model voorspelt één token tegelijk, en elk woord dat het schrijft wordt onderdeel van de invoer voor het volgende woord. Schrijft het "21" als tussenresultaat, dan staat die "21" nu in de context en stuurt die de laatste stap richting "16." Sla de stappen over en het model moet direct naar het antwoord springen, zonder houvast. Het rare is dat dit voordeel alleen op schaal optreedt. In de oorspronkelijke paper ontdekte het team van Wei dat kleine modellen nauwelijks vooruitgang boekten, en soms zelfs slechter presteerden. Daarom kan dezelfde prompt die faalt op een lokaal 7B-model, een frontier-model juist transformeren.

De Drie Varianten: Zero-Shot, Few-Shot en Self-Consistency

Er zijn drie belangrijke CoT-varianten. Zero-shot CoT voegt simpelweg "Laten we stap voor stap nadenken" toe (Kojima et al., 2022). Few-shot CoT toont eerst uitgewerkte redeneervoorbeelden. Self-consistency (Wang et al., 2022) neemt meerdere redeneerpaden en laat de meerderheid het antwoord bepalen, de betrouwbaarste en tegelijk duurste van de drie.

Zero-shot is het luie trucje dat toch werkt. Je voegt één zin toe en het model redeneert zonder enig voorbeeld. Kojima et al. toonden aan dat alleen al "Laten we stap voor stap nadenken" een groot model in een degelijke zero-shot redeneerder verandert.

# Zero-shot CoT: append the trigger phrase. Best on non-reasoning models.
# Model names change fast, so treat the string below as a placeholder.
from openai import OpenAI
client = OpenAI()

prompt = (
    "Q: A shelf holds 3 boxes. Each box has 7 books. "
    "I remove 5 books. How many are left?\n"
    "A: Let's think step by step."
)

resp = client.chat.completions.create(
    model="your-non-reasoning-model",
    messages=[{"role": "user", "content": prompt}],
)
print(resp.choices[0].message.content)

Few-shot CoT gaat een stap verder: je geeft het model twee of drie uitgewerkte voorbeelden zodat het het redeneerpatroon van jouw domein overneemt. Self-consistency is de nauwkeurigheidsknop. In plaats van op één keten te vertrouwen, sample je er vijf bij een hogere temperature en laat je ze stemmen. Wang et al. ontdekten dat het meerderheidsantwoord meestal klopt, zelfs als individuele ketens afdwalen.

# Self-consistency: sample N reasoning paths, majority-vote the answer.
# More accurate, more expensive. Wang et al., 2022.
from collections import Counter

def self_consistency(prompt, n=5, temperature=0.7):
    answers = []
    for _ in range(n):
        resp = client.chat.completions.create(
            model="your-non-reasoning-model",
            messages=[{"role": "user", "content": prompt}],
            temperature=temperature,  # diversity across paths
        )
        answers.append(extract_final_answer(resp.choices[0].message.content))
    return Counter(answers).most_common(1)[0][0]  # majority vote

Wil je die redenering als nette JSON in plaats van vrije tekst? Combineer CoT met de patronen uit onze gids voor gestructureerde uitvoer, zodat een volgende stap het probleemloos kan parsen.

De Verschuiving van 2026: Redeneermodellen Veranderden de Spelregels

Redeneermodellen, OpenAI's o-series en GPT-5 reasoning, Claude's extended thinking en DeepSeek R1, passen chain of thought al intern toe voordat ze antwoorden. OpenAI's eigen documentatie zegt expliciet dat het overbodig is om deze modellen te vertellen "denk stap voor stap", en dat een redeneermodel vragen om meer te redeneren de prestaties zelfs kan schaden. Die structuur zit er al standaard in.

Dit is het deel dat oudere gidsen liever negeren. Een redeneermodel produceert een privé chain of thought voordat het je ooit een antwoord toont, dus de stap-voor-stap-uitleg die je vroeger zelf schreef, gebeurt nu onder de motorkap. OpenAI's best practices voor reasoning stellen het bot: "Vermijd chain-of-thought-prompts: aangezien deze modellen intern redeneren, is het overbodig om ze te vragen 'stap voor stap na te denken' of 'je redenering uit te leggen'." Hun o3/o4-mini-promptgids gaat nog een stap verder: "Een redeneermodel vragen om meer te redeneren kan de prestaties juist schaden."

Anthropic's extended thinking is hetzelfde idee, maar dan als product. Je geeft Claude een denkbudget in plaats van een stap-voor-stap-script, en de nieuwste modellen bepalen zelf hoe diep ze nadenken. Bij dit soort modellen stel je reasoning_effort of het denkbudget bij, niet de formulering. Voor de open-source kant van redeneermodellen, inclusief DeepSeek R1, zie onze uitsplitsing Qwen vs DeepSeek vs GLM.

Wanneer Handmatige CoT Nog Helpt vs Wanneer Het Averechts Werkt

Handmatige CoT helpt nog steeds bij non-reasoning en kleine of lokale open-source modellen, of wanneer je één specifieke redeneerstructuur of een controleerbaar spoor nodig hebt. Het werkt averechts bij native redeneermodellen (overbodig en trager), bij eenvoudige taken in één stap, en op latency- of kostengevoelige paden, waar het alleen maar tokens verbrandt zonder nauwkeurigheidswinst.

Hier is een echt voorbeeld uit onze eigen praktijk. De 12-agent-pipeline die dit artikel schreef, draait op Claude-modellen, en we vertellen die agents bewust nooit "denk stap voor stap", omdat de modellen al intern redeneren en het alleen maar ruis zou toevoegen. Wat we wél met de hand schrijven, zijn strikte, doorzoekbare redeneerschema's. Onze validator-agent draait een vaste rubriek van 100 punten (50 kwaliteit, 50 SEO) plus acht opeenvolgende controles. De vertaler volgt een vaste checklist: het aantal H2's van de bron matchen, een diacritics-grep draaien die meer dan nul moet opleveren, en binnen een regelaantal van 80 tot 120 procent van de bron blijven. De publisher draait pre- en post-publish controles die de publishedAt-datumtijd met een regex checken, en vraagt daarna het CMS uit om te bevestigen dat de body niet leeg is.

Niets daarvan gaat over méér nadenken. Het is een vast, controleerbaar pad dat we kunnen inspecteren en doorzoeken, precies het geval waarin "handmatige CoT nog helpt". We hebben die controles om een reden toegevoegd: een publishedAt-waarde met alleen een datum verborg ooit stilletjes een heel artikel voor onze blogindex, dus de strikte stappenreeks bestaat nu om te voorkomen dat het model een verificatie overslaat. Eén eerlijke kanttekening: dit is een operationele observatie, geen benchmark. We hebben geen gecontroleerde nauwkeurigheids-A/B getest tussen "denk stap voor stap" en geen instructie, dus zie het als een les over structuur en controleerbaarheid, niet als een cijferclaim.

Draai je lokale modellen waarbij handmatige CoT nog loont? Ons overzicht van de beste open-source LLM's van 2026 behandelt het hele veld. En als je ooit de chain of thought van een model aan gebruikers toont, behandel die dan als onbetrouwbare uitvoer; onze gids over prompt injection preventie legt uit waarom.

De Verborgen Kosten: Tokens, Latency en Je Rekening

CoT is niet gratis. Elke redeneerstap bestaat uit output-tokens waar je voor betaalt, en langere generaties verhogen de latency. Redeneermodellen rekenen verborgen reasoning-tokens bovenop het zichtbare antwoord. Bij high-volume of realtime endpoints kan het afdwingen van stap-voor-stap-uitvoer de kosten stilletjes vermenigvuldigen, dus begroot ervoor of begrens het met reasoning_effort.

Elke "stap 1, stap 2, stap 3" die het model schrijft, zijn output-tokens, en output-tokens zijn de dure soort. Een keten die vijf keer langer is dan het kale antwoord, kost op die aanroep ruwweg vijf keer zoveel, en komt trager terug. Redeneermodellen voegen een addertje toe: ze rekenen reasoning-tokens voor het interne denkwerk dat je nooit ziet, waardoor een kort eindantwoord een lange, betaalde keten kan verbergen. Bij een low-volume endpoint is dat ruis; bij een druk endpoint loopt het snel op. Twee gewoontes houden het beheersbaar. Cache de stabiele delen van je context zodat je niet betaalt om ze telkens opnieuw te lezen (onze prompt caching-gids laat zien hoe), en meet of de extra tokens daadwerkelijk nauwkeurigheid opleveren voordat je CoT overal uitrolt. Onze LLM-evaluatiegids behandelt die meting, zodat je niet betaalt voor redeneren dat de score niet verbetert.

Hoe Gebruik Je CoT in 2026: Een Beslissingschecklist

Bepaal eerst welke modelklasse je hebt. Bij een redeneermodel sla je handmatige CoT over en stel je in plaats daarvan reasoning_effort of het denkbudget bij. Bij een non-reasoning of lokaal model voeg je zero-shot "Laten we stap voor stap nadenken" toe, upgrade je naar few-shot voor domeintaken, en voeg je self-consistency alleen toe wanneer nauwkeurigheid zwaarder weegt dan tokenkosten.

Hier is de hele beslissing in vijf stappen:

1. Bepaal je modelklasse. Redeneermodel of niet? Dat ene gegeven bepaalt alles hieronder.
2. Bij een redeneermodel schrijf je geen CoT met de hand. Stel in plaats daarvan reasoning_effort of het denkbudget bij, en laat het model intern redeneren.
3. Bij een non-reasoning of lokaal model voeg je zero-shot "Laten we stap voor stap nadenken" toe. Het is één regel en kost niets om te proberen.
4. Voor domeinspecifieke taken upgrade je naar few-shot CoT met twee of drie uitgewerkte voorbeelden. Voeg self-consistency alleen toe wanneer nauwkeurigheid zwaarder weegt dan tokenkosten.
5. Als je de redenering blootgeeft, meet die dan met evals en behandel de zichtbare keten als onbetrouwbare uitvoer.

De triggerzin zelf staat meestal in je system prompt. Onze system prompt-voorbeelden laten zien waar die hoort en hoe je die formuleert.

# On a reasoning model, don't hand-write CoT. Tune the effort instead.
# Param names and levels change per provider and version, so check current docs.
resp = client.responses.create(
    model="your-reasoning-model",
    reasoning={"effort": "medium"},   # e.g. low | medium | high
    input="Prove that the square root of 2 is irrational.",
)

# Anthropic equivalent: an extended-thinking budget.
# budget_tokens MUST be less than max_tokens.
# thinking = {"type": "enabled", "budget_tokens": 4000}

Dit in een productiestack verwerken is lastiger dan een blogvoorbeeld doet vermoeden. Wil je liever niet zelf redeneerbudgetten en eval-harnasses afstemmen? Ons team bouwt deze pipelines end-to-end. Bekijk AI-integratie of neem contact op.

Veelgestelde Vragen

Is chain of thought prompting nog relevant in 2026?

Ja, maar de rol is kleiner geworden. Bij non-reasoning en kleine of lokale open-source modellen verhoogt handmatige CoT nog steeds de nauwkeurigheid bij taken met meerdere stappen. Bij redeneermodellen is het meestal overbodig. Het sterkste overgebleven gebruik is het afdwingen van één vast, controleerbaar redeneerpad dat je kunt inspecteren.

Werkt chain of thought prompting op redeneermodellen zoals GPT-5, o3 of Claude?

Deze modellen redeneren al intern, dus handmatige CoT is meestal overbodig en soms zelfs schadelijk. OpenAI's documentatie zegt dat het vragen om "stap voor stap na te denken" onnodig is, en dat vragen om meer te redeneren "de prestaties juist kan schaden". Stel liever reasoning effort bij dan zelf stappen te schrijven.

Wat is zero-shot chain of thought prompting?

Zero-shot CoT betekent dat je een triggerzin toevoegt, meestal "Laten we stap voor stap nadenken", zonder eerst uitgewerkte voorbeelden te geven. Kojima et al. (2022) toonden aan dat dit alleen al een groot model in een degelijke redeneerder verandert. Het is de goedkoopste CoT-variant: één regel, geen voorbeelden samenstellen, snel te testen.

Wat is self-consistency binnen chain of thought prompting?

Self-consistency, afkomstig van Wang et al. (2022), sampelt meerdere onafhankelijke redeneerketens bij een hogere temperature en laat vervolgens de meerderheid het eindantwoord bepalen. Het is de nauwkeurigste CoT-variant omdat foute ketens zelden overeenstemmen, maar je betaalt voor elk gesampeld pad, dus het is ook de duurste.

Wat is het verschil tussen chain of thought en few-shot prompting?

Few-shot prompting toont het model voorbeelden van input-outputparen. Chain of thought richt zich op de redenering tussen input en output. Ze combineren goed: few-shot CoT geeft uitgewerkte voorbeelden inclusief de redeneerstappen, zodat het model jouw redeneerpatroon overneemt, niet alleen je antwoordformaat.

Chain of thought vs prompt chaining vs tree of thought: wat is het verschil?

Chain of thought redeneert binnen één prompt. Prompt chaining splitst een taak op over meerdere afzonderlijke modelaanroepen, waarbij outputs worden doorgegeven. Tree of thought verkent meerdere redeneertakken en snoeit de zwakke weg. CoT is één lineair pad; de andere twee voegen externe structuur rond het model toe.

Wie bedacht chain of thought prompting?

Chain of thought prompting werd geïntroduceerd door Jason Wei en collega's bij Google, in het paper uit 2022 "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models." Kojima et al. voegden later zero-shot CoT toe, en Wang et al. voegden self-consistency toe, beide ook in 2022.

Werkt chain of thought prompting voor het genereren van code?

Ja, bij non-reasoning modellen. Het model vragen om eerst de logica te plannen voordat het code schrijft, vangt edge cases op en vermindert bugs bij complexe taken. Bij redeneermodellen gebeurt die planning intern, dus een eenvoudige instructie werkt meestal beter dan een handgeschreven "redeneer stap voor stap"-prefix.