---
title: "Claude prompting best practices: de complete gids"
date: 2026-06-09
author: ""
---
# Claude prompting best practices: de complete gids
# Claude prompting best practices
De complete Nederlandse gids bij de officiële Anthropic-richtlijnen voor de nieuwste Claude-modellen (Fable 5, Mythos 5, Opus 4.8 en verder). 44 technieken met uitleg én kopieer-klare voorbeeld-prompts — als naslagwerk en als studiemateriaal.
Anthropic bracht nieuwe Claude-modellen uit, en daarmee een vernieuwde prompt-handleiding. Wij hebben die volledig doorgenomen en vertaald naar een heldere Nederlandse gids: van de algemene principes (helder zijn, context geven, voorbeelden, XML, rollen) tot output-opmaak, tool use, denken & redeneren, agentic systemen en migratie van oudere modellen.
De voorbeeld-prompts houden we in het Engels — dat zijn kopieer-klare system-prompts die je direct kunt gebruiken. De uitleg eromheen is van ons. Twijfel je of jouw eigen prompt goed zit? Check ‘m gratis in de [Prompt Coach](/prompt-coach/), of leer het stap voor stap in een [coaching](/coaching/).
[1. De modellen (lineup)](#bp-model-lineup)
[2. Algemene principes](#bp-general-principles)
[3. Output & opmaak](#bp-output-formatting)
[4. Tool use](#bp-tool-use)
[5. Denken & redeneren](#bp-thinking)
[6. Agentic: context & state](#bp-agentic-state)
[7. Agentic: gedrag sturen](#bp-agentic-control)
[8. Vision en frontend](#bp-capability-tips)
[9. Migratie van oudere modellen](#bp-migration)
Sectie 1## De modellen (lineup)
Anthropic levert prompt-richtlijnen voor een hele reeks Claude-modellen, van de lichte Haiku tot de krachtige Opus. Sommige modellen hebben hun eigen prompt-pagina met afwijkend gedrag, maar de technieken uit deze gids gelden voor alle huidige modellen. Daarnaast laat de bron zien hoe je Claude zichzelf correct laat identificeren in je prompts.
### De huidige Claude-lineup kennen
De officiële Anthropic-referentie voor prompt engineering dekt de nieuwste modellen: Claude Fable 5, Claude Mythos 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6 en Claude Haiku 4.5. Het is belangrijk te weten welk model je gebruikt, want prompttechnieken en gedrag verschillen per model. De algemene technieken uit deze gids werken op alle huidige modellen, inclusief Fable 5 en Mythos 5. Dat geeft je een stabiele basis ongeacht welk model je inzet.
### Modellen met een eigen prompt-pagina
Enkele modellen hebben een eigen, specifieke prompt-pagina omdat ze afwijkend gedrag vertonen. Fable 5 en Mythos 5 delen de pagina 'Prompting Claude Fable 5': die gaat over gedragsverschillen ten opzichte van Opus 4.8 en over aanpassingen aan effort-levels, instructie-opvolging, claims over voortgang bij lange runs, memory-systemen en de weiger-categorie reasoning\_extraction. Opus 4.8 heeft de pagina 'Prompting Claude Opus 4.8', die ingaat op het kalibreren van responslengte, effort en thinking-diepte, het triggeren van tool-use, letterlijke instructie-opvolging, subagent-controle en defaults voor design/frontend. Het loont dus om deze modelspecifieke pagina's te raadplegen als je met Fable 5, Mythos 5 of Opus 4.8 werkt.
### Claude zichzelf correct laten identificeren
Wil je dat Claude weet welk model het is en zichzelf juist voorstelt, geef dat dan expliciet mee in je systeemprompt. Claude weet niet uit zichzelf altijd zeker welk exact model draait, dus deze regel voorkomt verkeerde zelfidentificatie. Dit is vooral handig in apps of agents waar het model zichzelf moet benoemen.
Voorbeeld-promptSystem-prompt: zelfidentificatie van het model
```
The assistant is Claude, created by Anthropic. The current model is Claude Opus 4.8.
```
### Een standaardmodel instellen voor apps
Bouw je een applicatie die zelf een model moet kiezen, geef Claude dan een duidelijke default plus de exacte model-string. Zo voorkom je dat de app een verouderd of verkeerd model selecteert wanneer de gebruiker geen voorkeur opgeeft. De exacte string (zoals claude-opus-4-8) is nodig omdat API-aanroepen de technische model-identifier vereisen, niet de leesbare naam.
Voorbeeld-promptSystem-prompt: standaardmodel + exacte model-string
```
When an LLM is needed, please default to Claude Opus 4.8 unless the user requests otherwise. The exact model string for Claude Opus 4.8 is claude-opus-4-8.
```
Sectie 2## Algemene principes
Deze algemene principes vormen het fundament van goed prompten met Claude. Ze gaan over hoe je instructies helder formuleert, context meegeeft, voorbeelden en rollen inzet, en je prompt overzichtelijk structureert. Pas je ze toe, dan haal je veel betrouwbaardere en bruikbaardere output uit het model.
### Wees helder en direct
Claude presteert het best bij expliciete, ondubbelzinnige instructies. Zeg precies welk outputformaat en welke beperkingen je wilt, en vraag uitdrukkelijk om extra inzet als je dat verwacht in plaats van te hopen dat het model het zelf aanvoelt. Behandel Claude als een briljante maar nieuwe collega die jouw normen en werkwijzen nog niet kent. De gouden regel: zou een collega met minimale context je prompt begrijpen? Raakt die in de war, dan Claude ook. Geef instructies bij voorkeur als genummerde stappen wanneer volgorde of volledigheid belangrijk is.
**Minder effectief**`Create an analytics dashboard`
**Effectiever**`Create an analytics dashboard. Include as many relevant features and interactions as possible. Go beyond the basics to create a fully-featured implementation.`
### Voeg context toe voor betere prestaties
Leg uit waarom een instructie of gewenst gedrag belangrijk is, niet alleen wat Claude moet doen. Claude is slim genoeg om vanuit die motivatie te generaliseren naar situaties die je niet expliciet hebt benoemd. Een kale regel als 'gebruik nooit puntjes' werkt minder goed dan dezelfde regel met de reden erbij (bijvoorbeeld dat de tekst wordt voorgelezen door een spraakengine die er geen raad mee weet). De uitleg geeft het model houvast om de juiste keuzes te maken.
**Minder effectief**`NEVER use ellipses`
**Effectiever**`Your response will be read aloud by a text-to-speech engine, so never use ellipses since the text-to-speech engine will not know how to pronounce them.`
### Zet voorbeelden effectief in
Voorbeelden (few-shot of multishot) zijn een van de betrouwbaarste manieren om outputformaat, toon en structuur te sturen. Zorg dat ze relevant zijn (lijken op jouw echte use case), divers (dekken edge cases af, zodat Claude geen onbedoelde patronen overneemt) en gestructureerd (verpak ze in <example>-tags, en meerdere in <examples>). Drie tot vijf voorbeelden geven meestal het beste resultaat. Je kunt Claude zelfs vragen om je voorbeelden te beoordelen op relevantie en diversiteit, of om extra voorbeelden te genereren.
### Structureer prompts met XML-tags
XML-tags helpen Claude een complexe prompt eenduidig te ontleden, vooral wanneer instructies, context, voorbeelden en variabele invoer door elkaar lopen. Verpak elk type inhoud in een eigen tag, zoals <instructions>, <context> en <input>. Gebruik consistente, beschrijvende tagnamen en nest tags waar een natuurlijke hiërarchie bestaat (bijvoorbeeld meerdere documenten in <documents>, elk in <document index="n">). Zo weet het model precies welk deel van je prompt waarvoor dient.
### Geef Claude een rol
Een rol in de system prompt richt het gedrag en de toon van Claude. Al één zin maakt verschil: door bijvoorbeeld te zeggen dat Claude een behulpzame coding-assistent gespecialiseerd in Python is, krijg je antwoorden die beter aansluiten op die context. De rol stuur je mee via het system-veld van de API-aanroep, los van de eigenlijke vraag van de gebruiker.
Voorbeeld-promptPython (Anthropic SDK): rol via de system prompt
```
import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
model="claude-opus-4-8",
max_tokens=1024,
system="You are a helpful coding assistant specializing in Python.",
messages=[{"role": "user", "content": "How do I sort a list of dictionaries by key?"}],
)
print(message.content)
```
### Prompten met lange context
Bij grote documenten (20k+ tokens) plaats je de langformige data bovenaan, boven je vraag, instructies en voorbeelden. Bij complexe input over meerdere documenten kan het stellen van je vraag aan het eind de kwaliteit met tot 30% verbeteren. Structureer de data met XML: verpak elk document in een <document> met daarin <document\_content> en <source>. Een extra krachtige techniek is je antwoorden in citaten gronden: vraag Claude eerst de relevante passages te citeren (in <quotes>-tags) voordat het de taak uitvoert. Zo snijdt het model door de ruis heen voordat het redeneert.
Voorbeeld-promptXML-structuur voor multi-document long-context prompt
```
annual_report_2023.pdf{{ANNUAL_REPORT}}competitor_analysis_q2.xlsx{{COMPETITOR_ANALYSIS}}
Analyze the annual report and competitor analysis. Identify strategic advantages and recommend Q3 focus areas.
```
Sectie 3## Output & opmaak
Hoe Claude antwoordt qua toon, lengte en opmaak kun je grotendeels sturen vanuit je prompt. In deze sectie zie je hoe je verbositeit, opmaak (markdown, XML, LaTeX) en documentcreatie naar je hand zet. Ook behandelen we waarom prefilled responses niet meer werken in de nieuwste modellen en wat je in plaats daarvan gebruikt.
### Communicatiestijl en verbositeit
De nieuwste Claude-modellen zijn standaard beknopter en natuurlijker: ze antwoorden directer en feitelijker, klinken conversationeler en laten overbodige samenvattingen weg om efficiënter te zijn. Soms slaat het model na een tool call de verbale samenvatting helemaal over. Wil je juist meer zicht op wat er gebeurd is en op de redenering, vraag dan expliciet om een korte samenvatting na afloop. Zo krijg je meer transparantie zonder de standaard-beknoptheid op te geven.
Voorbeeld-promptInstructie: korte samenvatting na tool-gebruik
```
After completing a task that involves tool use, provide a quick summary of the work you've done.
```
### Het formaat van antwoorden sturen
Je krijgt de gewenste opmaak het beste voor elkaar door positief te formuleren: zeg wat Claude WEL moet doen in plaats van wat het moet laten. Schrijf dus niet 'Gebruik geen markdown', maar 'Schrijf je antwoord in vloeiende prozaparagrafen'. Verder helpen XML-tags als format-indicator (laat het model in specifieke tags schrijven), en match je promptstijl aan de gewenste output: haal je zelf markdown uit je prompt, dan krijg je ook minder markdown terug. Voor wie markdown echt wil minimaliseren is er een uitgebreid promptblok dat proza afdwingt en lijstjes alleen toestaat bij echt losse items of op verzoek.
**Minder effectief**`Do not use markdown`
**Effectiever**`Your response should be composed of smoothly flowing prose paragraphs.`
Voorbeeld-promptSystem-prompt: markdown en bullets minimaliseren
```
When writing reports, documents, technical explanations, analyses, or any long-form content, write in clear, flowing prose using complete paragraphs and sentences. Use standard paragraph breaks for organization and reserve markdown primarily for `inline code`, code blocks, and simple headings. Avoid using **bold** and *italics*.
DO NOT use ordered or unordered lists unless: a) you're presenting truly discrete items where a list is best, or b) the user explicitly requests a list or ranking.
Instead of listing items, incorporate them naturally into sentences. Using prose instead of excessive formatting will improve user satisfaction. NEVER output a series of overly short bullet points.
Your goal is readable, flowing text that guides the reader naturally through ideas rather than fragmenting information into isolated points.
```
### LaTeX-output uitschakelen
De nieuwste modellen gebruiken standaard LaTeX voor wiskunde en technische uitleg, wat mooi rendert in omgevingen die dat ondersteunen maar onleesbaar wordt als platte tekst. Wil je gewone tekst, instrueer Claude dan expliciet om geen LaTeX, MathJax of markup zoals ( ), $ of frac{}{} te gebruiken en in plaats daarvan wiskunde met standaard tekens te schrijven (/ voor delen, \* voor vermenigvuldigen, ^ voor machten). Zo voorkom je onleesbare markup-codes in contexten zonder LaTeX-weergave.
Voorbeeld-promptInstructie: platte tekst in plaats van LaTeX
```
Format your response in plain text only. Do not use LaTeX, MathJax, or any markup notation such as ( ), $, or frac{}{}. Write all math expressions using standard text characters (e.g., "/" for division, "*" for multiplication, and "^" for exponents).
```
### Documenten creëren
De nieuwste modellen zijn sterk in het maken van presentaties, animaties en visuele documenten: ze volgen instructies nauwkeurig en leveren vaak in één keer bruikbare output. Vraag dus gerust om een afgewerkt resultaat met aandacht voor ontwerp en visuele hiërarchie, in plaats van alleen een ruwe tekstdump. Door expliciet om doordachte designelementen en passende animaties te vragen, haal je het meeste uit deze capaciteit.
Voorbeeld-promptVoorbeeld-prompt: professionele presentatie
```
Create a professional presentation on [topic]. Include thoughtful design elements, visual hierarchy, and engaging animations where appropriate.
```
### Weg van prefilled responses
Vanaf de Claude 4.6-modellen en Claude Mythos Preview worden prefilled responses (zelf het begin van de laatste assistant-beurt invullen) niet meer ondersteund: dat levert nu een 400-error op. Voor de gangbare redenen om vroeger te prefillen bestaan betere alternatieven. Outputformaat afdwingen (JSON/YAML/classificatie) doe je nu met de Structured Outputs-feature of door simpelweg je schema te laten volgen; voor classificatie werken tools met een enum-veld goed. Preambles zoals 'Here is the requested summary:' elimineer je met een directe instructie in de system prompt om zonder inleiding te antwoorden, eventueel aangevuld met XML-tags of post-processing. Slechte refusals omzeilen is niet meer nodig omdat het model nu gepaster weigert. Een afgekapt antwoord laat je voortzetten via een instructie in de user-message, en context- of rolconsistentie die je vroeger prefilde injecteer je nu in de user-beurt of via tools.
Voorbeeld-promptSystem-prompt: zonder inleiding antwoorden
```
Respond directly without preamble. Do not start with phrases like 'Here is...', 'Based on...', etc.
```
### Onderbroken antwoord laten voortzetten (continuation)
Werd een antwoord midden in een zin afgekapt, dan zette je dat vroeger voort met een prefill. Nu zet je de voortzetting in de user-message: plak de afgekapte tekst erbij en vraag Claude om verder te gaan waar het stopte. Vul daarbij de werkelijk ontvangen tekst in op de plek van de placeholder. Een simpele retry is in veel gevallen ook een geldige optie.
Voorbeeld-promptUser-message: voortzetten na onderbreking
```
Your previous response was interrupted and ended with `[previous_response]`. Continue from where you left off.
```
Sectie 4## Tool use
Wanneer Claude met tools werkt (bestanden bewerken, zoeken, code uitvoeren), bepaalt je formulering of het model daadwerkelijk actie onderneemt of alleen meedenkt. Deze sectie laat zien hoe je Claude precies de juiste mate van proactiviteit geeft en hoe je parallelle tool-aanroepen optimaliseert voor snelheid.
### Stuur expliciet aan op het gebruik van tools
De nieuwste Claude-modellen volgen instructies heel letterlijk. Vraag je 'kun je wat verbeteringen voorstellen?', dan krijg je soms alleen suggesties terug in plaats van doorgevoerde wijzigingen. Formuleer daarom als een directe opdracht ('Verander deze functie…') wanneer je wilt dat Claude de tool ook echt gebruikt. Wil je juist het tegenovergestelde — alleen actie als je er expliciet om vraagt — dan kun je dat met een system prompt vastleggen. Let op: Opus 4.5 en 4.6 reageren sterker op de system prompt, dus oude prompts met agressieve taal ('CRITICAL: You MUST…') kunnen nu over-triggeren; zwak die af naar bijvoorbeeld 'Use this tool when…'.
**Minder effectief**`Can you suggest some changes to improve this function?`
**Effectiever**`Change this function to improve its performance.`
Voorbeeld-promptSystem-prompt: standaard proactief handelen
```
By default, implement changes rather than only suggesting them. If the user's intent is unclear, infer the most useful likely action and proceed, using tools to discover any missing details instead of guessing. Try to infer the user's intent about whether a tool call (e.g., file edit or read) is intended or not, and act accordingly.
```
### Stuur juist aan op voorzichtigheid (alleen actie op verzoek)
Het spiegelbeeld van proactief handelen: soms wil je dat Claude niet meteen bestanden aanpast maar eerst onderzoekt en aanbevelingen geeft. Met deze system-prompt-instructie blijft Claude bij twijfel informeren en adviseren, en pakt het alleen de tools op zodra je daar expliciet om vraagt. Handig bij gevoelige codebases of wanneer je eerst wilt overleggen voordat er iets verandert.
Voorbeeld-promptSystem-prompt: alleen handelen op expliciet verzoek
```
Do not jump into implementation or change files unless clearly instructed to make changes. When the user's intent is ambiguous, default to providing information, doing research, and providing recommendations rather than taking action. Only proceed with edits, modifications, or implementations when the user explicitly requests them.
```
### Optimaliseer parallelle tool-aanroepen
De nieuwste modellen zijn sterk in het tegelijk uitvoeren van meerdere tools — meerdere zoekopdrachten, meerdere bestanden tegelijk lezen, of bash-commando's parallel draaien. Het slagingspercentage is van zichzelf al hoog, maar je kunt het richting de 100% duwen met een expliciete instructie. De kern: roep onafhankelijke tools tegelijk aan, maar zodra een aanroep een waarde nodig heeft uit een vorige, doe je het juist na elkaar. Gebruik nooit placeholders of gegokte parameters. Vermijd formuleringen die juist sequentieel werken afdwingen, want die remmen de snelheidswinst.
**Minder effectief**`Execute operations sequentially with brief pauses between each step to ensure stability.`
Voorbeeld-promptSystem-prompt: parallelle tool-aanroepen maximaliseren
```
If you intend to call multiple tools and there are no dependencies between the tool calls, make all of the independent tool calls in parallel. Prioritize calling tools simultaneously whenever the actions can be done in parallel rather than sequentially. For example, when reading 3 files, run 3 tool calls in parallel to read all 3 files into context at the same time. Maximize use of parallel tool calls where possible. However, if some tool calls depend on previous calls to inform dependent values like the parameters, do NOT call these tools in parallel and instead call them sequentially. Never use placeholders or guess missing parameters in tool calls.
```
Sectie 5## Denken & redeneren
Hoe Claude nadenkt voordat het antwoordt, bepaalt een groot deel van de kwaliteit. Met de nieuwste modellen (Opus 4.6, Sonnet 4.6) kun je dat denkproces sturen: meer of minder uitgebreid, en op precies de momenten dat het loont. Deze sectie laat zien hoe je overdenken voorkomt, het redeneren juist benut en je prompts migreert naar de nieuwe adaptive-thinking-aanpak.
### Overdenken en te grondige exploratie afremmen
Claude Opus 4.6 verkent een probleem vooraf veel uitgebreider dan oudere modellen, zeker bij een hogere effort-instelling. Dat helpt meestal, maar soms gaat het model ongevraagd extra context verzamelen die je niet nodig hebt. Vervang daarom brede standaardinstructies door gerichte (bijvoorbeeld 'gebruik tool X wanneer het je begrip van het probleem echt vergroot' in plaats van 'gebruik standaard tool X'). Haal ook oude over-prompting weg: zinnen als 'bij twijfel, gebruik de tool' zorgen nu juist voor te veel triggeren, omdat de modellen al goed afwegen wanneer iets nodig is. Blijft het te agressief, dan kun je de effort gewoon lager zetten. Met een instructie om een aanpak te kiezen en die door te zetten voorkom je dat Claude eindeloos op beslissingen terugkomt.
**Minder effectief**`Default to using [tool].`
**Effectiever**`Use [tool] when it would enhance your understanding of the problem.`
Voorbeeld-promptRedeneren begrenzen: kies een aanpak en houd vol
```
When you're deciding how to approach a problem, choose an approach and commit to it. Avoid revisiting decisions unless you encounter new information that directly contradicts your reasoning. If you're weighing two approaches, pick one and see it through. You can always course-correct later if the chosen approach fails.
```
### Denken en interleaved thinking benutten
Opus 4.6 en Sonnet 4.6 gebruiken 'adaptive thinking' (thinking: {type: "adaptive"}): het model bepaalt zelf dynamisch wanneer en hoeveel het nadenkt, afgestemd op de gekozen effort en de complexiteit van je vraag. In interne evaluaties presteert adaptive thinking betrouwbaar beter dan het oudere extended thinking, dus de overstap is het overwegen waard. Het is vooral sterk voor agentic werk: taken met meerdere stappen, tools, complex coderen en lange agent-loops. Je kunt het denkgedrag bijsturen met instructies, bijvoorbeeld om na tool-resultaten eerst te reflecteren voordat het verdergaat, of juist om alleen te denken als dat het antwoord echt beter maakt. Extra tips: geef liever algemene instructies ('think thoroughly') dan voorgeschreven stappen; multishot-voorbeelden met <thinking>-tags werken goed; handmatige chain-of-thought met <thinking>/<answer> is een fallback als thinking uitstaat; en vraag Claude om zichzelf te controleren. Let op: met thinking UIT is Opus 4.5 gevoelig voor het woord 'think' — gebruik dan alternatieven als 'consider', 'evaluate' of 'reason through'.
Voorbeeld-promptDenkgedrag sturen: reflecteer op tool-resultaten
```
After receiving tool results, carefully reflect on their quality and determine optimal next steps before proceeding. Use your thinking to plan and iterate based on this new information, and then take the best next action.
```
### Triggeren afzwakken als Claude te vaak denkt
Soms denkt het model vaker na dan nodig, wat latency toevoegt zonder dat het antwoord beter wordt. Met een korte instructie maak je duidelijk dat uitgebreid denken alleen bedoeld is voor problemen die echt meerdere redeneerstappen vergen, en dat het bij twijfel direct mag antwoorden. Zo houd je de snelheid hoog voor eenvoudige vragen en reserveer je het denkwerk voor waar het loont.
Voorbeeld-promptDenken afremmen: alleen bij meerstaps-redeneren
```
Extended thinking adds latency and should only be used when it will meaningfully improve answer quality - typically for problems that require multi-step reasoning. When in doubt, respond directly.
```
### Migreren van extended thinking naar adaptive thinking
Op oudere modellen stuurde je het denkbudget met budget\_tokens (extended thinking). Op de nieuwe modellen schakel je over op adaptive thinking en verplaats je de budgetcontrole naar de effort-parameter (met niveaus max, xhigh, high, medium en low). Een harde plafond via budget\_tokens werkt nog op 4.6 en Sonnet 4.6, maar is deprecated; gebruik liever een lagere effort of max\_tokens. Het codevoorbeeld laat de oude en nieuwe configuratie naast elkaar zien.
Voorbeeld-promptPython: migratie van budget\_tokens naar adaptive + effort
```
# Voor (extended thinking, oudere modellen)
client.messages.create(model="claude-sonnet-4-5-20250929", max_tokens=64000, thinking={"type":"enabled","budget_tokens":32000}, messages=[...])
# Na (adaptive thinking)
client.messages.create(model="claude-opus-4-8", max_tokens=64000, thinking={"type":"adaptive"}, output_config={"effort":"high"}, messages=[...]) # effort: max/xhigh/high/medium/low
```
Sectie 6## Agentic: context & state
Bij langlopende, autonome taken is de grootste uitdaging niet het denken zelf, maar het vasthouden van de draad over de tijd heen. Deze sectie laat zien hoe je Claude helpt om voortgang, state en context goed te beheren, zodat het complexe klussen tot het einde afmaakt, ook over meerdere context-windows.
### Lange-termijn redeneren en state bijhouden
De nieuwste modellen zijn sterk in taken die lang doorlopen en waarbij je de stand van zaken moet onthouden. Claude blijft op koers door zich op stapsgewijze voortgang te richten: een paar dingen tegelijk aanpakken in plaats van alles tegelijk. Dat werkt vooral goed over meerdere context-windows heen, volgens het patroon: werk doen, state opslaan, en verdergaan in een vers window. Door incrementeel te werken raakt het model minder snel de oriëntatie kwijt.
### Context-besef en workflows over meerdere windows
Claude 4.6 en 4.5 hebben context-besef: het model houdt zelf bij hoeveel context-window er nog over is (zijn token budget). Als je harness context kan samenvatten of naar bestanden kan wegschrijven (zoals Claude Code), vertel dat dan expliciet in je prompt. Doe je dat niet, dan stopt Claude soms te vroeg omdat het denkt dat de limiet nadert. De memory-tool sluit hier naadloos op aan en zorgt voor soepele overgangen tussen windows.
Voorbeeld-promptSystem-prompt: stop niet vroeg, sla state op vóór compacteren
```
Your context window will be automatically compacted as it approaches its limit, allowing you to continue working indefinitely from where you left off. Therefore, do not stop tasks early due to token budget concerns. As you approach your token budget limit, save your current progress and state to memory before the context window refreshes. Always be as persistent and autonomous as possible and complete tasks fully, even if the end of your budget is approaching. Never artificially stop any task early regardless of the context remaining.
```
### Workflows over meerdere context-windows
Voor taken die niet in één window passen, gebruik je een paar concrete patronen. Geef het allereerste window een ander prompt dan de rest: laat het eerst een raamwerk opzetten (tests schrijven, setup-scripts), zodat latere windows alleen nog een todo-lijst hoeven af te werken. Laat tests in een gestructureerd formaat (zoals tests.json) bijhouden en maak duidelijk dat tests niet verwijderd of aangepast mogen worden. Zet quality-of-life-tools op (zoals init.sh) om servers, tests en linters te starten, zodat werk niet steeds opnieuw hoeft. Start liever vers dan te compacteren: de nieuwste modellen ontdekken hun state moeiteloos vanaf het filesystem, mits je prescriptief bent over waar ze moeten kijken. Geef ten slotte verificatie-tools (Playwright MCP, computer use) mee zodat Claude correctheid kan checken zonder menselijke feedback, en moedig aan om de volledige context te benutten.
Voorbeeld-promptPrompt: benut de volledige output-context
```
This is a very long task, so it may be beneficial to plan out your work clearly. It's encouraged to spend your entire output context working on the task - just make sure you don't run out of context with significant uncommitted work. Continue working systematically until you have completed this task.
```
### Best practices voor state-beheer
Kies het juiste formaat voor het juiste soort state. Gebruik gestructureerde formaten zoals JSON voor data die je machinaal wilt verwerken (testresultaten, taakstatus), en vrije tekst voor menselijke voortgangsnotities (progress.txt). Gebruik git voor het bijhouden van state via de log en checkpoints. De rode draad blijft: benadruk incrementele voortgang, zodat Claude steeds een betrouwbaar startpunt heeft als het verdergaat. Hieronder een voorbeeld van gestructureerde state (JSON) plus een voortgangsnotitie in vrije tekst.
Voorbeeld-promptVoorbeeld: state als JSON + voortgangsnotitie in vrije tekst
```
{ "tests": [ {"id":1,"name":"authentication_flow","status":"passing"}, {"id":2,"name":"user_management","status":"failing"} ], "total":200, "passing":150, "failing":25, "not_started":25 }
Session 3 progress:
- Fixed authentication token validation
- Next: investigate user_management test failures (test #2)
- Note: Do not remove tests as this could lead to missing functionality
```
Sectie 7## Agentic: gedrag sturen
Wanneer Claude als agent werkt — zelfstandig bestanden bewerkt, tests draait, research doet of subagents inzet — bepaal je met je systeem-prompt hoe voorzichtig, grondig en gefocust dat gebeurt. Deze technieken laten zien hoe je veiligheid, onderzoek, delegatie en minimalisme expliciet stuurt. Veel ervan zijn kant-en-klare prompt-snippets die je rechtstreeks in je instructies kunt plakken.
### Balans tussen autonomie en veiligheid
Zonder kaders kan een agentmodel (Opus 4.6) acties uitvoeren die je moeilijk terugdraait: bestanden wissen, een force-push doen of iets naar een externe dienst posten. Door Claude expliciet te laten nadenken over omkeerbaarheid en impact, geef je het toestemming om lokale, veilige acties (bestanden bewerken, tests draaien) zelf te doen, terwijl het voor destructieve of gedeelde acties eerst om bevestiging vraagt. Belangrijk detail: je voegt toe dat Claude obstakels niet mag omzeilen met destructieve shortcuts zoals –no-verify.
Voorbeeld-promptSystem-prompt: bevestiging vóór risicovolle acties
```
Consider the reversibility and potential impact of your actions. You are encouraged to take local, reversible actions like editing files or running tests, but for actions that are hard to reverse, affect shared systems, or could be destructive, ask the user before proceeding.
Examples of actions that warrant confirmation:
- Destructive operations: deleting files or branches, dropping database tables, rm -rf
- Hard to reverse operations: git push --force, git reset --hard, amending published commits
- Operations visible to others: pushing code, commenting on PRs/issues, sending messages, modifying shared infrastructure
When encountering obstacles, do not use destructive actions as a shortcut. For example, don't bypass safety checks (e.g. --no-verify) or discard unfamiliar files that may be in-progress work.
```
### Research en informatie verzamelen
Claude is sterk in agentische zoekopdrachten, maar levert beter onderzoek als je drie dingen meegeeft: heldere succescriteria, aanmoediging om bronnen over meerdere plekken te verifiëren, en een gestructureerde werkwijze. De voorbeeld-prompt laat Claude concurrerende hypotheses opstellen, vertrouwensniveaus bijhouden voor betere kalibratie, en research-notities in een bestand vastleggen voor transparantie. Zo wordt complex onderzoek systematisch opgedeeld in plaats van losse, ongeordende zoekacties.
Voorbeeld-promptSystem-prompt: gestructureerde research
```
Search for this information in a structured way. As you gather data, develop several competing hypotheses. Track your confidence levels in your progress notes to improve calibration. Regularly self-critique your approach and plan. Update a hypothesis tree or research notes file to persist information and provide transparency. Break down this complex research task systematically.
```
### Subagents aansturen (orchestration)
De nieuwste modellen herkennen zelf wanneer het loont om werk naar subagents te delegeren, ook zonder dat je dat vraagt. Geef daarom goed-gedefinieerde subagent-tools en laat Claude natuurlijk orkestreren. Let wel op overgebruik: Opus 4.6 heeft een sterke voorkeur voor subagents en spawnt ze soms waar een simpele directe grep sneller was geweest. De voorbeeld-prompt corrigeert dat door duidelijk te maken wanneer parallel delegeren wél zin heeft (parallelle taken, geïsoleerde context, onafhankelijke werkstromen) en wanneer Claude beter direct doorwerkt (simpele taken, sequentieel werk, single-file edits).
Voorbeeld-promptSystem-prompt: subagents alleen waar het loont
```
Use subagents when tasks can run in parallel, require isolated context, or involve independent workstreams that don't need to share state. For simple tasks, sequential operations, single-file edits, or tasks where you need to maintain context across steps, work directly rather than delegating.
```
### Complexe prompts aan elkaar ketenen (chaining)
Dankzij adaptive thinking en subagent-orkestratie doet Claude het meeste meerstaps-redeneren tegenwoordig intern, dus je hoeft taken minder vaak handmatig op te knippen. Expliciete prompt-chaining — een taak verdelen over opeenvolgende API-calls — blijft toch nuttig wanneer je tussenresultaten wilt inspecteren of een vaste pipeline wilt afdwingen. Het bekendste patroon is self-correction: genereer een draft, laat Claude die toetsen aan criteria, en laat het vervolgens verfijnen op basis van die review. Elke stap als losse call uitvoeren geeft je controle om te loggen, te evalueren en te branchen.
### Minder nieuwe bestanden bij agentic coding
De nieuwste modellen maken soms nieuwe bestanden aan — vooral python-scripts — als een soort tijdelijk kladblok. Dat verbetert vaak de uitkomst, dus het is niet per se slecht. Wil je toch dat je werkmap schoon blijft, vraag Claude dan om alle tijdelijke iteratie-bestanden aan het eind van de taak weer op te ruimen.
Voorbeeld-promptSystem-prompt: tijdelijke bestanden opruimen
```
If you create any temporary new files, scripts, or helper files for iteration, clean up these files by removing them at the end of the task.
```
### Overengineering tegengaan
Opus 4.5 en 4.6 neigen ernaar dingen te complex te maken: extra bestanden, onnodige abstracties en flexibiliteit die je nooit gevraagd hebt. Met deze prompt houd je de oplossing minimaal en gefocust. De instructie dekt vier concrete vlakken: scope (geen ongevraagde features of refactors), documentatie (geen docstrings/comments toevoegen aan code die je niet wijzigde), defensief coderen (geen error-handling voor scenario's die niet kunnen voorkomen, alleen valideren op systeemgrenzen) en abstracties (geen helpers voor eenmalige operaties). De juiste hoeveelheid complexiteit is het minimum dat de taak vereist.
Voorbeeld-promptSystem-prompt: minimaal en gefocust werken
```
Avoid over-engineering. Only make changes that are directly requested or clearly necessary. Keep solutions simple and focused:
- Scope: Don't add features, refactor code, or make "improvements" beyond what was asked.
- Documentation: Don't add docstrings, comments, or type annotations to code you didn't change. Only add comments where the logic isn't self-evident.
- Defensive coding: Don't add error handling, fallbacks, or validation for scenarios that can't happen. Only validate at system boundaries (user input, external APIs).
- Abstractions: Don't create helpers or abstractions for one-time operations. The right amount of complexity is the minimum needed for the current task.
```
### Niet fixeren op tests halen of hard-coden
Soms richt Claude zich te sterk op het laten slagen van de tests in plaats van het bouwen van een echte, algemene oplossing — wat leidt tot hard-coded waarden die alleen werken voor de testgevallen. Deze prompt verschuift de focus: maak een hoogwaardige, algemene oplossing die klopt voor álle geldige invoer, niet alleen de tests. Tests zijn er om correctheid te verifiëren, niet om de oplossing te definiëren. Een belangrijk extra: als de taak onredelijk of onhaalbaar is, of als een test zelf fout is, moet Claude dat melden in plaats van er omheen te werken.
Voorbeeld-promptSystem-prompt: algemene oplossing, geen hard-coding
```
Please write a high-quality, general-purpose solution using the standard tools available. Do not create helper scripts or workarounds. Implement a solution that works correctly for all valid inputs, not just the test cases. Do not hard-code values or create solutions that only work for specific test inputs. Tests are there to verify correctness, not to define the solution. If the task is unreasonable or infeasible, or if any of the tests are incorrect, please inform me rather than working around them.
```
### Hallucinaties minimaliseren bij agentic coding
De nieuwste modellen hallucineren minder en geven van zichzelf al gegronde antwoorden, maar je kunt dat verder versterken. Deze prompt verbiedt Claude om te speculeren over code die het niet heeft geopend: verwijst de gebruiker naar een specifiek bestand, dan moet Claude dat bestand eerst echt lezen voordat het antwoordt. Geen claims over de codebase zonder onderzoek, tenzij Claude het antwoord zeker weet. Het gebruik van XML-tags rond de instructie maakt de regel goed afgebakend in je systeem-prompt.
Voorbeeld-promptSystem-prompt: eerst onderzoeken, dan antwoorden
```
Never speculate about code you have not opened. If the user references a specific file, you MUST read the file before answering. Make sure to investigate and read relevant files BEFORE answering questions about the codebase. Never make any claims about code before investigating unless you are certain of the correct answer - give grounded and hallucination-free answers.
```
Sectie 8## Vision en frontend
Claude (Opus 4.5/4.6) is sterk geworden in twee specifieke gebieden: beeldverwerking en frontend-design. Maar zonder sturing levert het generieke resultaten op. Deze technieken laten zien hoe je het beste uit deze capaciteiten haalt.
### Betere vision: laat Claude inzoomen
Opus 4.5/4.6 zijn duidelijk beter geworden in beeldverwerking en data-extractie, vooral wanneer je meerdere afbeeldingen tegelijk aanbiedt, en betrouwbaarder bij computer use (screenshots en UI's herkennen). Video's kun je laten analyseren door ze eerst in losse frames op te knippen. Een bewezen truc die op image-evals consistent betere resultaten geeft: geef Claude een crop-tool of skill waarmee het zelf op de relevante regio van een afbeelding kan inzoomen. Net als bij een mens helpt het om detail van dichtbij te kunnen bekijken in plaats van alleen het hele beeld in één keer.
### Frontend-design: vermijd 'AI slop'
Opus 4.5/4.6 blinken uit in complexe webapps met sterk frontend-design, maar zonder sturing vallen ze terug op generieke patronen die gebruikers 'AI slop' noemen: voorspelbare lettertypes, clichematige kleuren en cookie-cutter layouts. De oplossing is een expliciete system-prompt die Claude dwingt creatieve, onderscheidende keuzes te maken op het gebied van typografie, kleur en thema, beweging (animaties) en achtergronden. Door concreet te benoemen wat je wilt vermijden (Inter, Roboto, Arial, paarse gradiënten op wit) en waar de focus moet liggen (één goed georkestreerd page-load-moment met gefaseerde reveals slaat verspreide micro-interacties), krijg je een frontend die echt op maat lijkt voor de context.
Voorbeeld-promptSystem-prompt: onderscheidend frontend-design
```
You tend to converge toward generic, "on distribution" outputs. In frontend design, this creates what users call the "AI slop" aesthetic. Avoid this: make creative, distinctive frontends that surprise and delight.
Focus on:
- Typography: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices.
- Color & Theme: Commit to a cohesive aesthetic. Use CSS variables. Dominant colors with sharp accents outperform timid, evenly-distributed palettes. Draw from IDE themes and cultural aesthetics.
- Motion: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Focus on high-impact moments: one well-orchestrated page load with staggered reveals beats scattered micro-interactions.
- Backgrounds: Create atmosphere and depth rather than defaulting to solid colors. Layer CSS gradients, use geometric patterns, or add contextual effects.
Avoid generic AI aesthetics: overused fonts (Inter, Roboto, Arial), clichéd color schemes (purple gradients on white), predictable layouts, cookie-cutter design. Make unexpected choices that feel genuinely designed for the context. Vary between light and dark themes. It is critical that you think outside the box!
```
Sectie 9## Migratie van oudere modellen
Stap je over van een oudere Claude-generatie naar de 4.6-modellen, dan werken sommige prompts net even anders. Onder de motorkap is er veel veranderd: het model is proactiever, denkt anders na en ondersteunt bepaalde oude trucs niet meer. Hieronder de aandachtspunten om je bestaande prompts soepel mee te nemen.
### Wees specifiek over het gewenste gedrag
Oudere modellen vulden zelf veel gaten op; de nieuwe 4.6-modellen volgen je instructies juist nauwgezetter. Daardoor loont het om precies te beschrijven wat je in de output wilt zien. Hoe explicieter je bent over de gewenste uitkomst, hoe beter het resultaat aansluit bij je bedoeling.
### Frame instructies met modifiers
Voeg aan een kale opdracht een aansporende zin toe die de lat hoger legt. In plaats van enkel om iets te vragen, beschrijf je expliciet dat het model verder mag gaan dan de basis en een volledig uitgewerkte versie moet maken. Deze 'modifiers' duwen het model richting rijkere, completere output, omdat 4.6 zich strikter aan je framing houdt.
**Minder effectief**`Create an analytics dashboard`
**Effectiever**`Create an analytics dashboard. Include as many relevant features and interactions as possible. Go beyond the basics to create a fully-featured implementation.`
Voorbeeld-promptVoorbeeld-modifier: vraag om een volledig uitgewerkte versie
```
Create an analytics dashboard. Include as many relevant features and interactions as possible. Go beyond the basics to create a fully-featured implementation.
```
### Vraag specifieke features expliciet
Wil je extra's zoals animaties of interactieve elementen, benoem die dan letterlijk in je prompt. Omdat de 4.6-modellen niet langer aannames doen over wat je impliciet bedoelt, krijg je die features alleen terug als je ze expliciet aanvraagt. Laat niets aan de fantasie van het model over.
### Update je thinking-configuratie
De 4.6-modellen gebruiken 'adaptive thinking': het model bepaalt zelf hoeveel het nadenkt, in plaats van dat jij handmatig een tokenbudget instelt. Vervang dus de oude manuele budget\_tokens-aanpak door de adaptive-config en stuur de denkdiepte voortaan via de effort-parameter. Zo sluit je aan op hoe de nieuwe generatie redeneert.
Voorbeeld-promptThinking-config voor 4.6: adaptive in plaats van budget\_tokens
```
thinking: {type: "adaptive"}
```
### Migreer weg van prefilled responses
Voorheen kon je het begin van Claude's antwoord alvast invullen om de output te sturen (een 'prefilled response' op de laatste assistant-beurt). Vanaf 4.6 wordt dit niet meer ondersteund. Gebruik je deze techniek nog, haal hem dan uit je pipeline en stuur het antwoord op een andere manier, bijvoorbeeld via duidelijke instructies in je prompt.
### Tune je anti-laziness-prompting bij
Bouwde je ooit zinnen in om een lui model grondiger te maken of agressiever tools te laten gebruiken, dan kun je die nu afzwakken. De 4.6-modellen zijn van zichzelf al veel proactiever en kunnen door zulke aansporingen juist overtriggeren: te veel doen, te vaak tools aanroepen. Verwijder of verzacht die oude 'doe-meer'-instructies om het gedrag in balans te houden.
### Specifiek bij Sonnet 4.5 naar 4.6
Ga je van Sonnet 4.5 naar 4.6, let dan extra op twee zaken: de standaardwaarde van de effort-parameter is gewijzigd, en er zijn twee verschillende migratiepaden voor extended thinking. Raadpleeg de officiële migratiegids om te zien welk pad bij jouw opzet past en hoe de nieuwe effort-default je resultaten beïnvloedt.
## Zelf beter leren prompten?
Pak een techniek, pas een voorbeeld-prompt aan naar jouw situatie en check ‘m gratis in de [Prompt Coach](/prompt-coach/). Wil je het echt onder de knie krijgen? In een [coaching-sessie](/coaching/) leren we je prompten met de KOMPAS-methode. Bekijk ook de [promptgidsen per AI-model](/promptgidsen/) en de [Codex use-cases](/codex-use-cases/).
Deze gids is een Nederlandse bewerking van de officiële Anthropic-documentatie “Prompting best practices” voor Claude’s nieuwste modellen. De voorbeeld-prompts komen uit die documentatie. Claude en Anthropic zijn handelsmerken van Anthropic.
## Verder lezen
Claude reageert sterk op duidelijke rol, context en beoordelingscriteria. Geef dus niet alleen de taak, maar ook hoe het antwoord beoordeeld wordt. Wil je zien hoe Claude zich verhoudt tot GPT en Gemini, kijk dan in de [promptgidsen per model](/promptgidsen/). Daar staat onder meer dat `effort` bij Sonnet 4.6 standaard op `high` staat terwijl `medium` meestal genoeg is.