Claude Code Meesterschap Deel 2: Het Mentale Model

Hier is een waarheid die developers die van Claude Code houden scheidt van degenen die het frustrerend vinden: begrijpen hoe het denkt verandert alles.

De meeste mensen benaderen Claude Code als een zoekmachine — typ een vraag, krijg een antwoord. Maar Claude Code is geen zoekmachine. Het is een autonome agent die in een loop draait, beslissingen neemt, tools gebruikt, en bijstuurt op basis van resultaten. Zodra je deze architectuur begrijpt, weet je precies waarom bepaalde prompts briljant werken terwijl andere plat vallen.

De Agentische Loop: Hoe Claude Code Echt Werkt

Onder de motorkap draait Claude Code een bedrieglijk simpel patroon:

Denk → Handel → Observeer → Corrigeer → Herhaal

Zo ziet dat er in de praktijk uit:

1. Denk — Claude analyseert je verzoek en beslist wat te doen
2. Handel — Het gebruikt een tool (een bestand lezen, een commando draaien, code bewerken)
3. Observeer — Het ziet het resultaat van die actie
4. Corrigeer — Het past zijn aanpak aan op basis van wat er is gebeurd
5. Herhaal — De loop gaat door totdat Claude beslist dat de taak af is

Dit is geen lineair gesprek. Het is een recursieve loop die blijft draaien totdat Claude expliciet beslist dat het klaar is. Het standaardgedrag is ga door tot opgelost, niet reageer één keer en stop.

Waarom dit belangrijk is: Als je Claude vraagt om "authenticatie toe te voegen aan deze app," genereert het niet alleen code en geeft het aan je. Het leest je bestaande code, begrijpt je patronen, schrijft de implementatie, draait tests om te verifiëren dat het werkt, fixt eventuele problemen die het vindt, en rapporteert pas dan terug. Dat is de loop in actie.

Het Context Window: Claude's Werkgeheugen

Claude heeft een "context window" — zie het als werkgeheugen. Alles wat Claude moet weten over je gesprek, je codebase, en de huidige taak moet in dit venster passen.

Standaardcontext: 200.000 tokens (ruwweg 500 pagina's tekst)

Uitgebreide context: Claude Sonnet 4 ondersteunt nu tot 1 miljoen tokens via de API — genoeg voor complete codebases met 75.000+ regels code. Dit vereist tier 4 API-toegang en kost 2x voor invoertokens boven 200K.

Hier is het cruciale inzicht: elk bericht dat je stuurt bevat de volledige gespreksgeschiedenis. Zo "onthoudt" Claude wat je eerder besproken hebt. Maar het betekent ook dat lange gesprekken exponentieel meer tokens verbruiken.

Wat Je Context Vult

Context komt uit meerdere bronnen, en ze tellen allemaal op:

Je prompts — Elk bericht dat je hebt gestuurd in deze sessie

Claude's antwoorden — Alles wat Claude heeft teruggestuurd

Tool-resultaten — Bestandsinhoud die Claude heeft gelezen, commando-output, zoekresultaten

Systeemcontext — CLAUDE.md-inhoud, git status, projectstructuur

Sessiegeschiedenis — Het volledige heen-en-weer sinds je laatste /clear

Als je Claude vraagt om "dit bestand te lezen," wordt de volledige bestandsinhoud aan de context toegevoegd. Vraag het om tien bestanden te lezen, en je hebt potentieel duizenden tokens verbruikt voordat Claude zelfs maar begint te werken aan je eigenlijke verzoek.

Een Opmerking over Abonnementen

Hoeveel je je zorgen moet maken over context hangt af van je plan:

Max 5x / Max 20x plannen — Je hebt ruime tokenlimieten. Contextbeheer is nog steeds goede praktijk voor outputkwaliteit, maar je hoeft niet elk token te bewaken.

Pro plan / Pay-as-you-go API — Elke tool-aanroep, elk bestand dat gelezen wordt, elk uitgebreid antwoord kost je. Agressief contextbeheer heeft direct impact op je rekening.

De strategieën hieronder zijn het belangrijkst voor kostenbewuste gebruikers, maar zelfs op onbeperkte plannen produceert schonere context betere output.

Context Beheren: De Commando's Die Ertoe Doen

/clear — De Aanbevolen Standaard

/clear

Wist alles. Schone start. Nul context.

Hier is een perspectiefverschuiving: /clear zou je standaard moeten zijn, niet je laatste redmiddel. Ervaren Claude Code-gebruikers clearen agressief — niet omdat er iets mis ging, maar als standaardpraktijk tussen taken.

Wanneer gebruiken:

• Een nieuwe feature starten (altijd)
• Tussen ongerelateerde taken (klaar met auth, nu bezig met UI)
• Wanneer minder dan 50% van je huidige context relevant is
• Wanneer Claude verward lijkt of in loops draait
• Na het afronden van een feature
• Wanneer je repetitieve of off-track antwoorden opmerkt

Het /clear + /catchup patroon:

Sommige developers maken een custom /catchup-commando dat Claude alle gewijzigde bestanden in hun git branch laat lezen. Na /clear, draai /catchup om relevante context te herstellen zonder de rommel. (Zie de volledige implementatie in Deel 4)

/clear
/catchup
"Ga verder met het implementeren van de betaalflow"

Dit geeft je verse context met precies wat relevant is.

/compact — Gebruik Met Voorzichtigheid

Januari 2026 Update: Sinds v2.0.64 is /compact nu instant — geen wachten meer. Probeer ook /context om te checken of MCP-servers ruimte opeten voordat je compacteert.

/compact

In plaats van alles te wissen, maakt /compact een intelligente samenvatting van je gesprek en begint opnieuw met die samenvatting als context.

De eerlijke waarheid: Veel ervaren gebruikers vermijden /compact wanneer mogelijk. De automatische samenvatting is ondoorzichtig — je weet niet precies wat behouden blijft of verloren gaat.

Wanneer /compact zinvol is:

• Je bent midden in een taak en moet specifieke beslissingen bewaren
• Je hebt complexe context die pijnlijk zou zijn om opnieuw op te bouwen
• Je wilt doorgaan maar de context is op 70%+

Wanneer je /clear moet prefereren:

• Iets nieuws beginnen
• Minder dan de helft van je context is relevant
• Je kunt makkelijk herstellen wat ertoe doet

Als je /compact toch gebruikt, stuur het:

/compact Focus op het bewaren van onze authenticatie-implementatie
en de databaseschema-beslissingen die we hebben genomen

Dit vertelt Claude wat het belangrijkst is in de samenvatting.

De "Documenteer & Clear" Strategie

Voor complexe taken die meerdere sessies duren, is er een beter patroon dan vertrouwen op compressie:

1. Documenteer: Laat Claude zijn plan en voortgang dumpen in een markdown-bestand
2. Clear: /clear de sessie volledig
3. Ga verder: Begin opnieuw door Claude te vertellen het markdown te lezen en verder te gaan

"Sla onze huidige voortgang en de resterende TODO's op in docs/auth-migration-plan.md"
/clear
"Lees docs/auth-migration-plan.md en ga verder waar we gebleven waren"

Dit creëert duurzaam extern geheugen dat sessies perfect overleeft — geen verliesgevende samenvatting.

Januari 2026 Update: Dit patroon is nu ingebouwd in Plan Mode. Wanneer je een plan accepteert, wist Claude automatisch de context en laadt het plan in een vers venster. Dit verbetert de planaanhouding aanzienlijk. Je kunt je afmelden als je liever context behoudt.

Auto-Compact: Het Vangnet Waar Je Niet Op Moet Leunen

Januari 2026 Update: Auto-compact triggert nu bij 75% capaciteit (niet 92-95%), waardoor ~50k tokens vrij blijven voor redenering. Dit is een aanzienlijke verbetering.

Claude Code comprimeert automatisch wanneer je context op capaciteit raakt. Dit voorkomt dat je midden in een taak zonder ruimte komt te zitten.

Maar leun er niet te veel op. Auto-compressie is nog steeds noodgedrag, geen strategie. Tegen de tijd dat het triggert, heb je mogelijk al verminderde outputkwaliteit ervaren.

Betere aanpak: clear proactief bij natuurlijke breekpunten in plaats van context te laten opzwellen totdat het systeem ingrijpt.

Extended Thinking: Wanneer Claude Harder Moet Nadenken

Claude Code ondersteunt denkmodustriggers die meer redeneringsbudget toewijzen:

"think" — ~4.000 tokens denkbudget

"think hard" — ~10.000 tokens denkbudget

"ultrathink" — ~31.999 tokens denkbudget (maximum)

Voeg deze woorden gewoon toe aan je prompt:

"ultrathink over hoe je dit betalingssysteem moet architecturen"
"think hard over de edge cases in deze validatielogica"

Wanneer te gebruiken:

• Architectuurbeslissingen → ultrathink + plan mode
• Vast in loops → ultrathink om door te breken
• Complex debuggen → think hard
• Routinetaken → geen keyword nodig

Let op: Deze keywords werken alleen in de terminalinterface van Claude Code, niet in de webchat of API. Voor een diepere duik in alle triggerwoorden en laatste updates, zie Deel 9: Power User Secrets.

Plan Mode: Denk Voor Je Handelt

Hier gaan de meeste mensen de mist in: ze vragen Claude om dingen te doen zonder eerst te vragen om dingen te plannen.

Plan mode is een read-only modus waarin Claude onderzoekt, analyseert en benaderingen voorstelt zonder bestanden aan te raken. Het is van onschatbare waarde voor complexe taken.

Hoe Je Plan Mode Activeert

Druk op Shift+Tab om door de modi te wisselen:

1. Eerste keer: Auto-accept modus (Claude vraagt geen toestemming per actie)
2. Tweede keer: Plan mode (Claude kan alleen lezen, niet schrijven)
3. Derde keer: Terug naar normale bewerkingsmodus

Kijk naar de prompt onderaan je terminal om te zien in welke modus je zit.

Wat Claude Kan Doen in Plan Mode

Plan mode beperkt Claude tot onderzoekstools:

• Read — Bestanden en inhoud bekijken
• LS/Glob — Mappen weergeven en bestandspatronen doorzoeken
• Grep — Inhoud doorzoeken over bestanden heen
• WebSearch/WebFetch — Online onderzoek doen
• Task — Onderzoeks-subagenten spawnen
• TodoRead/TodoWrite — Takenlijsten beheren

Wat het niet kan doen: Bestanden bewerken, commando's uitvoeren, wijzigingen aanbrengen.

Wanneer Plan Mode Gebruiken

Onbekende code verkennen:

[Activeer plan mode met Shift+Tab twee keer]
"Leg uit hoe authenticatie werkt in deze codebase.
Welke bestanden handelen sessies af? Waar worden tokens gevalideerd?"

Claude graaft door je code en legt het uit zonder risico om iets te breken.

Een refactor plannen:

"Ik wil migreren van REST naar GraphQL.
Wat moet er veranderen? Wat is de volgorde van operaties?"

Claude analyseert afhankelijkheden en stelt een migratiepad voor.

Architectuur begrijpen:

"Hoe zou je real-time notificaties toevoegen aan deze app?
Wat zijn de afwegingen tussen WebSockets en SSE hier?"

Claude overweegt je bestaande code en stelt opties voor.

Het kerninzicht: plannen is goedkoop, ongedaan maken is duur. Vijf minuten in plan mode bespaart vaak uren aan het terugdraaien van slechte implementaties.

De Junior Developer Analogie (Verfijnd)

In Deel 1 introduceerden we het "enthousiaste junior dev" mentale model. Laten we het nu verfijnen nu je de architectuur begrijpt:

Claude Code is als een zeer bekwame junior developer die:

Duidelijke instructies nodig heeft — Vage verzoeken produceren vage resultaten omdat de agentische loop geen duidelijke stopconditie heeft

Baat heeft bij context — Meer relevante informatie betekent betere tool-selectie en minder verspilde iteraties

Het beste werkt met specifieke taken — "Voeg foutafhandeling toe aan de login-functie" geeft een duidelijke afronding; "verbeter de code" niet

Leert van de patronen van je project — Claude observeert conventies in bestanden die het leest en past ze toe op bestanden die het schrijft

Vraagt voordat het grote wijzigingen maakt — Het permissiesysteem bestaat omdat de loop anders oneindig zou doorgaan

Vast kan raken in loops — Als een taak niet goed gedefinieerd is, kan Claude vergelijkbare acties herhalen zonder vooruitgang

Effectieve Prompting Patronen

Nu je de loop begrijpt, leer je hier prompts te schrijven die ermee samenwerken:

Wees Specifiek Over Afronding

De loop moet weten wanneer te stoppen.

❌ "Fix de bugs"
   (Welke bugs? Hoe weet Claude wanneer het klaar is?)

✅ "Fix de null pointer exception in src/auth.ts regel 42
   waar user.email wordt benaderd vóór de null check"
   (Specifieke locatie, specifiek probleem, duidelijke afronding)

Geef Context Vooraf

Elke tool-aanroep verbruikt tokens en tijd. Help Claude sneller te vinden wat het nodig heeft.

❌ "Voeg een loginpagina toe"
   (Claude moet je hele codebase verkennen om patronen te begrijpen)

✅ "Voeg een loginpagina toe met dezelfde styling als src/pages/signup.tsx
   en onze auth-service in src/services/auth.ts"
   (Claude weet precies waar het moet kijken)

Let op: Op Max 5x/20x plannen met ruime tokenlimieten kun je het je veroorloven om Claude vrijer te laten verkennen. Maar zelfs dan produceren specifieke verwijzingen snellere, consistentere resultaten.

Breek Grote Taken Op

Eén lange loop is slechter dan meerdere korte loops.

❌ "Bouw een compleet gebruikersdashboard met instellingen,
    notificaties en profielbeheer"
   (Enorme scope, onduidelijke volgorde, makkelijk om te verdwalen)

✅ Stap 1: "Maak het dashboard layout-component"
   Stap 2: "Voeg het instellingenpaneel toe"
   Stap 3: "Implementeer notificaties"
   Stap 4: "Bouw profielbeheer"
   (Duidelijke afrondingspunten, makkelijker bij te sturen)

Verwijs naar Bestanden via Pad

Laat Claude niet zoeken naar patronen die het direct kan vinden.

❌ "Gebruik hetzelfde patroon als de andere componenten"
   (Claude moet elk component lezen om het patroon te vinden)

✅ "Volg het patroon in src/components/Button.tsx"
   (Eén bestand lezen, minimaal contextverbruik)

Wanneer Claude Vastloopt

Tekenen dat de agentische loop draait zonder vooruitgang:

• Repetitieve antwoorden (steeds dezelfde suggesties)
• Circulaire logica (steeds dezelfde fix proberen)
• Vragen stellen die het al gesteld heeft
• Vergelijkbare incorrecte code produceren in cycli

Oplossingen, in volgorde:

1. /clear en opnieuw beginnen — Het meest effectief. Een schone context ontblokkeert vaak meteen.

2. Gebruik ultrathink — "ultrathink over dit probleem" wijst maximaal redeneringsbudget toe en breekt vaak door waar normale prompts falen.

3. Geef meer specifieke context — De loop zoekt misschien breed omdat het niet weet waar te kijken.

4. Maak de taak kleiner — De afrondingsconditie is misschien te vaag.

5. Probeer een andere insteek — "In plaats van deze functie te fixen, laten we hem vanaf nul herschrijven."

6. Schakel naar Opus — Als je op Sonnet zit (Pro plan standaard), kan het overschakelen naar Opus via /model helpen bij oprecht complex redeneren. Max plan-gebruikers hebben Opus al als standaard.

De Feedbackloop

Effectief Claude Code-gebruik is iteratief. Verwacht geen perfectie bij de eerste poging.

Jij: Eerste verzoek
Claude: Eerste poging
Jij: "Goed begin, maar de foutafhandeling dekt netwerkfouten niet"
Claude: Verfijnde poging
Jij: "Beter. Kun je ook logging toevoegen?"
Claude: Definitieve versie
Jij: Accepteren

Dit is niet Claude dat faalt — dit is de agentische loop die werkt zoals ontworpen. Elke iteratie voegt informatie toe die de volgende cyclus stuurt.

Vertrouwenskalibratie Over Tijd

Je relatie met Claude Code zou moeten evolueren:

Week 1: Bekijk elke wijziging zorgvuldig. Begrijp wat Claude doet en waarom.

Week 2: Sta auto-accept modus toe voor veilige operaties (lezen, testbestanden, documentatie).

Maand 1: Vertrouw routinetaken. Verifieer complexe refactors en alles wat kritieke paden raakt.

Doorlopend: Verifieer altijd beveiligingskritieke code, database-operaties, en alles met externe effecten.

Het doel is niet blind vertrouwen — het is geïnformeerd vertrouwen. Je traint je intuïtie voor wanneer Claude supervisie nodig heeft.

Anti-Patronen om te Vermijden

Hele bestanden in je prompt dumpen — Laat Claude ze zelf lezen. "Lees src/auth.ts en leg de sessieafhandeling uit" is beter dan 500 regels plakken.

Claude's vragen negeren — Wanneer Claude om verduidelijking vraagt, is het omdat de loop niet genoeg informatie heeft om met vertrouwen verder te gaan. Antwoord volledig.

Toestemmingsprompts doorhaasten — Lees wat je goedkeurt. "Altijd toestaan" is handig maar verwijdert een veiligheidscheck.

Verouderde context bewaren — /clear kost niets. Verouderde context kost tokens en nauwkeurigheid.

Claude gebruiken voor triviale taken — Soms is git status typen sneller dan uitleggen wat je wilt zien.

Wat Volgt

Je begrijpt nu hoe Claude Code denkt. In Deel 3: Projectconfiguratie duiken we in CLAUDE.md — het bestand dat Claude's gedrag vormt voor jouw specifieke project. Een goed opgestelde CLAUDE.md is het verschil tussen Claude dat je codebase begrijpt en Claude dat tegen je patronen in vecht.