De waarde van je Claude Code-sessies maximaliseren

• Categorie: Claude Code, Enterprise AI
• Product: Claude Code
• Datum: 14 augustus 2026
• Leestijd: 5 min
• Auteur: Lydia Hallie

TL;DR

• Run /clear tussen taken. Dit voorkomt dat irrelevante context uit eerdere taken opnieuw naar het model wordt gestuurd, wat het tokengebruik vermindert.
• Stel je model en effort-niveau in voordat je begint. Het wijzigen van een van beide tijdens een gesprek kan je prompt-cache verbreken, wat de tokenkosten verhoogt.
• Gebruik @-mentions voor bestanden in plaats van ze alleen bij naam te noemen. Het bestand wordt direct aan je bericht gekoppeld, wat een 'Read'-aanroep of een zoekopdracht bespaart.
• Voeg 'quiet flags' toe aan luidruchtige commando's, of run ze in een subagent. De output van commando's wordt aan het gesprek toegevoegd zoals een bestand en blijft daar voor de rest van de sessie aanwezig.
• Run eenmaal /context in een nieuwe sessie. Dit laat zien wat er is geladen (zoals CLAUDE.md en MCP-tooldefinities), zodat je onnodige zaken kunt verwijderen.
• Gebruik /compact voordat je een pauze neemt. De prompt-cache verloopt na een uur; het samenvatten van een gesprek is veel goedkoper terwijl dit nog gecached is.

---

Waarde maximaliseren

Tot voor kort waren de tools waarmee je code schreef gebaseerd op een vast bedrag (of gratis). Je editor kostte hetzelfde, of je die middag nu één of vijftig tests repareerde, waardoor een individuele taak geen eigen prijs had.

Bij agentic coding-tools zoals Claude Code is dat anders. Dezelfde voltooide taak kan verschillende bedragen kosten, afhankelijk van hoe je deze uitvoert.

In de ene sessie leest Claude de test en het bijbehorende bestand, voert de wijziging door en is klaar in een paar beurten. In een andere sessie doorzoekt het model eerst de repository met grep, leest een dozijn bestanden voordat het bij de juiste twee uitkomt, en elke beurt sleept bovendien alles mee wat sinds die ochtend in het gesprek is gelezen.

Het resultaat is dezelfde fix, maar je hebt een ander aantal tokens verbruikt en het model moest de hele tijd nadenken over tien bestanden die niet nodig waren.

Efficiënt omgaan met tokens betekent niet dat je er in totaal minder moet gebruiken. Het betekent dat je ervoor zorgt dat de tokens die je gebruikt, daadwerkelijk bijdragen aan waar je om hebt gevraagd.

Laten we kijken naar wat de prijs van een token bepaalt, hoeveel tokens een sessie verzendt, en wat dit betekent voor de manier waarop je een sessie beheert.

Wat bepaalt de prijs van een token?

Je betaalt per token, maar waar je feitelijk voor betaalt is inference: de tijd die een GPU (of TPU) nodig heeft om het model over je tokens te draaien.

Drie factoren bepalen hoeveel tijd een token in beslag neemt: welk model je gebruikt, of het een input-token (gaand) of een output-token (komend) is, en of het gecached was.

Model

Een groter model doet meer werk bij zowel input- als output-tokens. Gebruik een groter model wanneer het probleem echt moeilijk of ambigu is, en een kleiner model wanneer het werk routineus is. Alles wat we hierna bespreken, wordt vermenigvuldigd met de prijs van het gekozen model.

Input- en output-tokens

Een verzoek gaat in twee fasen door de GPU, en deze kosten verschillende bedragen:

1. Prefill (Input): Het model leest je verzoek en de context (de systeemprompt, je CLAUDE.md, je bericht en alles wat sindsdien aan het gesprek is toegevoegd, zoals gelezen bestanden en command-outputs). Dit zijn je input-tokens.
2. Decode (Output): Het model schrijft output-tokens (zijn denkproces, de tool-aanroepen en de tekst die je ziet). Dit gebeurt token voor token. Omdat decode de GPU veel langer bezet houdt, is output ongeveer 5x zo duur als input.

Veel van de output-tokens in een sessie zijn 'thinking tokens'. De hoeveelheid nadenken per beurt wordt bepaald door het effort level.

Tip: Run eenmaal /model en /effort in een nieuwe sessie om te zien welke instellingen actief zijn. Beide onthouden je laatste keuze, en je wilt dat deze beslissing bewust is.

Tip: Als je weet dat een sessie puur routineklusjes zijn, kun je met MAXTHINKINGTOKENS=0 claude het nadenken uitschakelen voor die sessie (behalve bij Fable 5), wat een stap lager is dan /effort low.

Prompt caching

Als een verzoek begint met exact dezelfde tokens als een verzoek dat de server net heeft gezien, kan de server de staat van dat begingedeelte onthouden. Dit heet prompt caching.

• Lezen uit de cache: Kost 0,1x de input-prijs.
• Schrijven naar de cache: Kost iets meer dan normale input (tot 2x), maar dit gebeurt slechts één keer per token, waarna de goedkope reads volgen in elke volgende beurt.

Claude Code beheert de prompt-cache automatisch, maar je kunt deze onbewust verbreken. De cache moet vanaf het begin van het verzoek exact overeenkomen. De volgorde is altijd: tooldefinities → systeemprompt → gesprek (met CLAUDE.md vooraan).

Als iets in dit prefix verandert, moet alles daarna opnieuw worden geladen (prefilled) tegen volle prijs. Factoren die de cache verbreken zijn:

• /model: Elk model heeft zijn eigen cache.
• /effort: Het effort-niveau maakt deel uit van de cache-sleutel.
• Fast mode: Ook onderdeel van de sleutel; zet dit aan het begin aan.
• /compact: Het gesprek wordt vervangen door een kortere versie, waardoor de match verdwijnt (behalve de systeemprompt). Het is goedkoper om te compacteren terwijl de oude conversatie nog in de cache staat (dus vóór een lange pauze).
• Tijd: De cache verloopt na een uur (bij een abonnement) of vijf minuten (bij een API-sleutel).

Tip: Als de laatste paar beurten een verkeerde richting opgingen, gebruik dan /rewind in plaats van /compact. Rewinding verwijdert alleen de laatste beurten, waardoor alles daarvóór gecached blijft en het niets kost. Compacting herschrijft het hele gesprek en kost altijd iets.

Wat bepaalt hoeveel tokens een sessie verzendt?

Het belangrijkste om te onthouden is dat niets slechts één keer wordt verzonden. Alles wat in het gesprek terechtkomt—een bestand dat Claude heeft gelezen of de output van een commando—wordt in elke volgende beurt opnieuw meegestuurd voor de rest van de sessie.

Hoewel dit gecached is en dus goedkoop, neemt het wel ruimte in beslag in het contextvenster waarin het model moet werken.

Wat komt er in de context?

Sommige zaken zijn er al voordat je iets typt: tooldefinities, de systeemprompt, CLAUDE.md en andere startup-instellingen.

Tip: Run /context in een nieuwe sessie om te zien wat er standaard is geladen. Houd CLAUDE.md beperkt tot specifieke instructies en verplaats workflow-specifieke instructies naar skills. Schakel onnodige MCP-servers uit met /mcp.

Het grootste deel van de context wordt gevuld door tool-resultaten:

1. Bestanden die Claude leest Hoe specifieker je bent, hoe minder Claude hoeft te zoeken. "De tests falen" dwingt Claude tot grep en het openen van diverse bestanden. "Fix de falende test in utils.test.ts" bespaart die zoektocht.

Tip: Gebruik @-mentions voor bestanden in plaats van het pad te typen. Claude Code koppelt het bestand direct aan je eerste bericht, waardoor een aparte 'Read'-aanroep wordt overgeslagen. Mention een bestand slechts één keer per gesprek; het blijft in de context aanwezig.

2. Output van commando's Elke keer dat Claude tests draait of een build uitvoert, wordt de output toegevoegd aan het gesprek. Zeer grote outputs (boven 30.000 tekens) worden automatisch naar een bestand geschreven met een korte preview in de chat.

Het probleem zijn de "middelgrote" outputs: bijvoorbeeld een test-runner die 400 geslaagde tests regel voor regel print. Deze 400 regels worden nu onderdeel van elke volgende beurt.

Tip: Zet de twee of drie commando's die je dagelijks gebruikt (inclusief 'quiet flags') in CLAUDE.md, bijvoorbeeld: "run a single test file with npx vitest run <file> --reporter=dot". Dit bespaart beurten en honderden regels output.

Hoe lang blijft informatie in de context?

Eén lange sessie is duurder dan hetzelfde werk verdeeld over korte sessies, omdat beurt 40 ook de 39 voorgaande beurten opnieuw leest.

• Gebruik /clear wanneer je aan een nieuwe taak begint.
• Gebruik /compact wanneer het eerste deel van een taak is afgerond.

Tip: Gebruik /rename voordat je /clear uitvoert als je de sessie later wilt terugvinden. Als je /compact gebruikt, geef dan aan wat er bewaard moet blijven, of voeg een sectie "Compact instructions" toe aan je CLAUDE.md.

Let ook op beurten die plaatsvinden terwijl je niet typt. Een /loop telt als een volledige beurt in de sessie waarin deze is opgezet. Als er meer dan een uur tussen de beurten zit, is er bovendien sprake van een cache-miss. Start in dat geval een nieuwe sessie in een andere terminal om de loop te draaien.

Subagents

Een andere manier om je context schoon te houden, is door werk uit te besteden aan subagents. Een subagent heeft zijn eigen contextvenster (met systeemprompt, tools en CLAUDE.md), maar niet jouw huidige gesprek. Alleen het uiteindelijke antwoord komt terug in de hoofdsessie.

Dit is vooral nuttig bij taken die veel output genereren die je niet hoeft te bewaren, zoals het doorzoeken van een logbestand. Je kunt dit direct aanvragen: "go through this log in a subagent".

Tip: Als je vaak een luidruchtige taak uitbesteedt, geef deze dan een eigen subagent-definitie met model: haiku (of sonnet), anders gebruikt de subagent standaard hetzelfde model als je hoofdsessie.

Waar eerst naar te kijken

Van alles wat hierboven is genoemd, zijn er vier zaken die de meeste impact hebben op de kosten (gesorteerd van hoogste naar laagste kosten):

(Tekst breekt hier af in bronbestand)