18 Claude Code Token Hacks Die Mijn Sessies Redden

18 Claude Code Token Hacks Die Mijn Sessies Redden

Ik zag 98,5% van mijn tokens verdwijnen voordat Claude Code ook maar begon na te denken over mijn eigenlijke vraag.

Dat getal is geen typfout. Een analyse van het tokenverbruik van Claude Code door een ontwikkelaar onthulde dat in een lang gesprek — zeg dertig berichten diep — bijna alle tokens die in rekening worden gebracht, worden besteed aan het opnieuw lezen van oude chatgeschiedenis. Niet aan het genereren van nieuwe code. Niet aan het nadenken over je probleem. Gewoon... hetzelfde gesprek keer op keer teruglezen, steeds duurder wordend bij elk bericht dat je stuurt.

Toen ik die uitsplitsing voor het eerst zag, werd ik er daadwerkelijk misselijk van. Ik had Anthropic's snelheidslimieten de schuld gegeven dat mijn sessies na twintig minuten opdroogden. Ik had het Max20-plan op het oog, overtuigd dat ik een groter quotum nodig had. Het probleem bleek niet mijn plangrootte te zijn. Het probleem was ikzelf.

Dit is wat de meeste Claude Code-gebruikers niet beseffen: tokengebruik schaalt niet lineair. Het stapelt zich op. Je eerste bericht in een sessie kost misschien 500 tokens. Bij bericht dertig kost datzelfde uitwisseling 15.000 tokens — omdat Claude de volledige gespreksgeschiedenis bij elke beurt opnieuw leest. Voeg daar systeemprompts, MCP-server tooldefinities, geladen skills en eventuele ingeplakte bestanden aan toe, en je lekt tokens uit bronnen die je nooit ziet.

Het goede nieuws? Zodra ik de mechanismen begreep, verminderde ik mijn effectieve tokenverspilling met ruwweg 60% — hetzelfde plan, dezelfde projecten, aanzienlijk langere sessies. Wat volgt zijn de 18 specifieke technieken die dat mogelijk maakten, georganiseerd in drie niveaus op basis van hoeveel inspanning ze vereisen en hoeveel impact ze opleveren.

Maar eerst moet je begrijpen waarom je sessies eigenlijk zo snel opraken.

Waarom Je Claude Code Sessies Zo Snel Opraken

Het mentale model dat de meeste ontwikkelaars hanteren is verkeerd. Ze denken aan tokengebruik als een brandstoftank: je begint vol, elk bericht verbruikt een vast bedrag, en uiteindelijk zit je op leeg. Simpel, lineair, voorspelbaar.

De realiteit lijkt meer op een sneeuwbal die van een heuvel rolt.

Elke keer dat je een bericht stuurt, verwerkt Claude niet alleen je nieuwe invoer. Het herleest alles — je systeemprompt, de tooldefinities van elke MCP-server, je CLAUDE.md-bestand, de volledige gespreksgeschiedenis vanaf bericht één, en dan je nieuwe prompt. Het antwoord wordt aan die geschiedenis toegevoegd. Volgend bericht? Het hele ding wordt opnieuw gelezen, nu met het vorige antwoord erbij.

Zo ziet dat er in de praktijk uit:

Dat dertigste bericht kost je dertig keer wat het eerste kostte. En het cumulatieve totaal is voorbij een kwart miljoen tokens geschoten — waarvan het meeste werd besteed aan herlezen, niet aan redeneren.

Er schuilt een tweede probleem hierin. Onderzoekers noemen het "loss in the middle" — wanneer het context window vol raakt, begint Claude minder aandacht te besteden aan informatie die in het midden van het gesprek begraven ligt. Je zorgvuldig geformuleerde instructies van bericht vijf? Bij bericht vijfentwintig zijn ze functioneel onzichtbaar. Het model is op dat punt niet alleen duur. Het wordt actief slechter.

Dit is waarom contexthygiëne meer uitmaakt dan plangrootte. Een ontwikkelaar op het Pro-plan met gedisciplineerd tokenbeheer zal beter presteren dan een Max20-abonnee die gesprekken behandelt als een stream-of-consciousness dagboek.

Nu je de mechanismen begrijpt, gaan we ze repareren — te beginnen met de veranderingen die je in de komende vijf minuten kunt maken.

Niveau 1: De Snelle Winsten (Vandaag Implementeren)

Deze negen technieken vereisen geen setup, minimale aanpassing van gewoontes en leveren direct resultaat op. Als je niets anders doet uit dit artikel, doe dan dit.

Begin Nieuwe Gesprekken voor Ongerelateerde Taken

Dit is de meest impactvolle gewoonteverandering op deze hele lijst, en het kost je niets.

Wanneer je klaar bent met het debuggen van een authenticatiestroom en overschakelt naar het stylen van een dashboard-component, zitten die authenticatietokens nog steeds in het gesprek. Claude herleest je volledige auth-debuggeschiedenis bij elk dashboard-stylingbericht. Je betaalt voor context die actief irrelevant is — en mogelijk het model in verwarring brengt.

Het /clear commando bestaat precies hierom. Gebruik het agressief. Ik wis mijn context wanneer ik overga op een echt andere taak, zelfs als het in hetzelfde project is. De vijf seconden die het kost om de context opnieuw op te bouwen, zijn niets vergeleken met de tokenbesparing van het niet meeslepen van twintig irrelevante berichten door elke volgende beurt.

Mijn vuistregel: als de volgende taak niet direct voortbouwt op de laatste drie berichten, /clear eerst.

Koppel Ongebruikte MCP-Servers Los

Deze verraste me toen ik voor het eerst /context uitvoerde en de uitsplitsing zag. Elke verbonden MCP-server laadt zijn volledige tooldefinitie-schema in het context window bij elk bericht. Een Figma MCP, een Slack MCP, een database MCP en een bestandssysteem MCP die gelijktijdig draaien, kunnen duizenden tokens per beurt opslokken — voordat je een enkel teken hebt getypt.

Als je code schrijft en Figma niet nodig hebt, koppel het los. Als je aan het ontwerpen bent en je databasetools niet nodig hebt, koppel ze los. Ik houd een minimale set MCPs actief voor mijn huidige taak en verbind andere alleen opnieuw wanneer ik ze specifiek nodig heb.

Het verschil is meetbaar. Op één project daalde mijn overhead per beurt met ruwweg 4.000 tokens door drie inactieve MCPs los te koppelen. Over een sessie van dertig berichten is dat 120.000 tokens bespaard — tokens die naar daadwerkelijk productief werk gingen in plaats van het laden van toolschema's die ik nooit heb aangeraakt.

Bundel Je Prompts in Enkele Berichten

Dit is basale rekenkunde, maar de meeste mensen missen het. Als je Claude nodig hebt om een component te maken, er tests voor te schrijven en het importbestand bij te werken, is dat één bericht — niet drie.

Drie afzonderlijke berichten betekent drie volledige context-herlezingen. Eén gebundeld bericht betekent één herlezing voor dezelfde hoeveelheid werk. De besparingen stapelen zich op naarmate je gesprek langer wordt.

Ik formatteer gebundelde verzoeken als volgt:

Do these three things in order:
1. Create a UserProfile component in src/components/ with name, email, and avatar props
2. Write tests for it using Vitest — cover the rendering, prop variations, and empty state
3. Update src/components/index.ts to export the new component

Claude gaat goed om met meerstaps-instructies. De sleutel is specifiek zijn over de volgorde en de verwachte output voor elke stap. Vage bundels creëren verwarring; precieze bundels besparen tokens.

Gebruik Planmodus Vóór Complexe Taken

Direct in de implementatie springen bij een complexe feature is een van de duurste fouten die je kunt maken. Niet omdat de eerste poging veel kost — maar omdat een verkeerde eerste poging een correctiecyclus triggert die je totale tokenuitgave verdubbelt of verdrievoudigt.

Planmodus vraagt Claude om zijn aanpak te schetsen voordat het code schrijft. Je bekijkt het plan, corrigeert indien nodig, en geeft dan groen licht. Dit concentreert afstemming in een enkele goedkope uitwisseling in plaats van misafstemming te ontdekken zes berichten diep wanneer het context window al opgeblazen is.

Ik gebruik planmodus voor alles wat meer dan twee bestanden raakt of architecturale beslissingen omvat. Voor eenvoudige single-file wijzigingen sla ik het over. De afweging is: "Als Claude dit bij de eerste poging fout doet, hoe duur is de correctie?" Als het antwoord "zeer" is, plan dan eerst.

Voer /context en /cost Uit om Te Zien Waar Tokens Heengaan

Je kunt niet optimaliseren wat je niet kunt meten. Het /context commando — geïntroduceerd in Claude Code v1.0.86 — splitst precies uit waar je tokens aan worden toegewezen: systeemprompt, tooldefinities, geheugenbestanden, skills, gespreksgeschiedenis en je daadwerkelijke prompt.

De eerste keer dat ik het uitvoerde, ontdekte ik dat mijn CLAUDE.md-bestand bij elke beurt 12% van mijn beschikbare context verbruikte. Een bestand dat ik eenmalig had geschreven en vergeten was, belastte stilletjes elke interactie. Ik snoeide het van 400 regels naar 120, en de besparing per beurt was onmiddellijk.

Het /cost commando toont het cumulatieve API-tokengebruik voor de sessie. Als je op een API-plan zit, vertelt dit je je uitgaven in realtime. Voor Max-abonnees gaat het minder om facturering en meer om te begrijpen hoe snel je door je gebruikstoewijzing brandt.

Voer beide commando's uit aan het begin van elke sessie. Maak het een reflex, zoals je spiegels controleren voor het rijden.

Stel een Token-Gebruik Statusregel In

Als het handmatig uitvoeren van /cost te veel wrijving voelt, configureer dan je terminal-statusregel om het tokengebruik continu weer te geven. Je ziet het percentage in realtime stijgen terwijl je werkt, wat een natuurlijke feedbacklus creëert — je begint op te merken welke typen berichten duur zijn en welke goedkoop.

Ik houd het tokenpercentage altijd zichtbaar in mijn terminal. Het is als een brandstofmeter op je dashboard. Je staart er niet constant naar, maar je werpt er vaak genoeg een blik op om niet onverwacht droog te vallen.

Houd het Dashboard Open

Het gebruiksdashboard van Anthropic toont je verbruik over sessies heen. Open het in een browsertab en controleer het een paar keer tijdens een werkdag, vooral tijdens intensieve ontwikkelsessies. Als je sneller door je vijf-uur-toewijzing brandt dan verwacht, merk je het vroeg genoeg om je aanpak aan te passen in plaats van het te ontdekken wanneer de sessie je buitensluit.

Plak Alleen Wat Relevant Is

Wanneer je wilt dat Claude een bestand begrijpt, plak dan niet het hele ding als slechts één functie ertoe doet. Ik heb ontwikkelaars bestanden van 800 regels zien plakken terwijl het relevante deel 40 regels was. Dat zijn 760 regels pure verspilling — geladen in de context bij elk volgend bericht.

Wees chirurgisch. Kopieer de specifieke functie, het specifieke configuratieblok, de specifieke foutuitvoer. Als Claude meer context nodig heeft, zal het erom vragen. Beginnen met minder is bijna altijd goedkoper dan beginnen met alles.

Bekijk Claude's Output in Realtime

Wanneer Claude een lang antwoord genereert — een groot component opbouwt, uitgebreide tests schrijft — kijk dan mee. Als je ziet dat het de verkeerde kant opgaat (verkeerd framework, verkeerde bestandsstructuur, verkeerd begrepen vereisten), stop het dan onmiddellijk.

Elke token die Claude genereert, wordt toegevoegd aan de gespreksgeschiedenis. Een antwoord van 2.000 tokens dat je niet wilde, is 2.000 tokens die je bij elk toekomstig bericht opnieuw leest. Een verkeerde afslag opmerken na 200 tokens in plaats van 2.000 bespaart je op het huidige bericht en elk bericht dat volgt.

Ik heb op deze manier hele sessies gered. Een keer begon Claude een REST API te genereren terwijl ik GraphQL resolvers nodig had. Ik ving het op binnen de eerste functiehandtekening en stopte het. Als ik was weggelopen en teruggekomen was bij een voltooide verkeerde implementatie, had de correctiecyclus mijn resterende contextbudget opgebrand.

Dat dekt de snelle winsten. Als je zelfs maar de helft hiervan hebt geïmplementeerd, loop je al voor op de meeste Claude Code-gebruikers. Maar de echte efficiëntiewinst komt van de structurele veranderingen in het volgende niveau — en een daarvan heeft volledig veranderd hoe ik over het CLAUDE.md-bestand denk.

Niveau 2: Structurele Optimalisaties (Weekendproject)

Deze vijf technieken vereisen enige voorafgaande investering — bestanden reorganiseren, gewoontes veranderen, timing aanpassen — maar ze leveren samengestelde rendementen op over elke sessie die volgt.

Houd Je CLAUDE.md Onder 200 Regels

Ik heb hier eerder over geschreven in mijn 50 Claude Code tips gids, maar het verdient herhaling omdat het zo belangrijk is. Je CLAUDE.md wordt bij elk bericht geladen. Het is geen eenmalige kost — het is een belasting per beurt.

Behandel CLAUDE.md als een index, niet als een encyclopedie. Het moet projectarchitectuur in één oogopslag bevatten, build-commando's, harde regels en verwijzingen naar langere documentatiebestanden. Niet de documentatie zelf.

Hier is het mentale model dat werkt: je CLAUDE.md is een inhoudsopgave. Wanneer Claude het daadwerkelijke hoofdstuk nodig heeft, kan het het bestand lezen. Maar elk hoofdstuk bij elk bericht in het geheugen laden — dat is het deel dat je doodt.

Ik heb het mijne geherstructureerd van een referentiedocument van 400 regels naar een index van 120 regels die verwijst naar gedetailleerde docs in een /docs directory. De tokenbesparing per beurt was ruwweg 3.000 tokens. Over een typische sessie van 25 berichten is dat 75.000 tokens teruggewonnen voor daadwerkelijk werk.

Wees Chirurgisch met Bestandsverwijzingen

"Bekijk mijn codebase en stel verbeteringen voor" is de duurste prompt die je kunt schrijven. Het triggert Claude om alles te scannen — elk bestand, elke directory — tokens verbrandend aan code die niets te maken heeft met wat je daadwerkelijk verbeterd wilt hebben.

In plaats daarvan: "Bekijk de foutafhandeling in src/services/payment.ts, specifiek de processRefund functie op regels 45-80." Dat is een scalpel. De eerste prompt is een voorhamer.

Ik heb er een gewoonte van gemaakt om altijd bestandspaden op te nemen en, waar mogelijk, regelnummers of functienamen in mijn prompts. Hoe preciezer je Claude's aandacht richt, hoe minder tokens het besteedt aan zoeken op de verkeerde plekken.

Compact bij 60%, Niet bij 95%

Claude Code heeft een automatische compactiefunctie die triggert wanneer het context window ongeveer 95% capaciteit bereikt. Het /compact commando vat de gespreksgeschiedenis samen en vervangt deze door een gecomprimeerde versie, waardoor ruimte vrijkomt.

Het probleem met wachten tot 95%: op dat punt is het model al een tijdje aan het degraderen. Het "loss in the middle"-effect betekent dat Claude's outputkwaliteit al daalt ruim voordat het context window technisch vol zit. En de compactie zelf is minder effectief wanneer er meer te comprimeren is — je verliest meer nuance.

Ik compact handmatig bij ongeveer 60% capaciteit. Eerder dan de meeste mensen aanbevelen, en dat is opzettelijk. De compactie behoudt meer relevant detail wanneer er minder samen te vatten is, en de resterende 40% schone context geeft me een solide startbaan voor de volgende fase van werk.

Je kunt ook aangepaste instructies toevoegen om te sturen wat bewaard wordt: /compact Focus op de authenticatie-refactoringbeslissingen en de API-endpoint-handtekeningen. Dit vertelt Claude wat belangrijk is tijdens de samenvatting in plaats van het zelf te laten beslissen.

Let op de Cache Timeout

Deze verrast mensen. Claude Code gebruikt prompt caching — het cachet regelmatig herhaalde content (systeemprompts, tooldefinities, gespreksgeschiedenis) om herverwerking vanaf nul te vermijden. Gecachete input-tokens zijn aanzienlijk goedkoper, gefactureerd tegen ruwweg 10% van het normale tarief.

Maar de cache heeft een timeout. Neem een pauze van vijf-plus minuten — pak koffie, beantwoord een Slack-bericht, word in een vergadering getrokken — en de cache verloopt. Je volgende bericht triggert een volledige herverwerking van de gehele context tegen volledige tokenkosten. Een gesprek van 200.000 tokens dat efficiënt werd gecachet, wordt plotseling een koude herlezing van 200.000 tokens.

Twee strategieën helpen hier. Ten eerste, als je weet dat je meer dan een paar minuten wegloopt, /compact voordat je vertrekt. Kleinere context betekent goedkopere herverwerking bij terugkomst. Ten tweede, als je terugkomt van een lange pauze bij een opgeblazen gesprek, overweeg dan /clear en begin opnieuw met een korte samenvatting van waar je was gebleven. Het is bijna altijd goedkoper dan betalen voor een volledige koude herlezing van een lange geschiedenis.

Beheer Command Output Bloat

Wanneer Claude shell-commando's uitvoert — npm install, git log, testsuites — komt de volledige output in het context window. Een uitgebreide testrunner die honderden regels slagende tests dumpt? Het wordt allemaal opgeslagen. Een git log die vijftig commits retourneert? Elke regel wordt context die je bij elk toekomstig bericht opnieuw leest.

Wees bewust over welke commando's Claude uitvoert. Als je testresultaten nodig hebt, vraag dan alleen om de mislukkingen: "Voer de testsuite uit en toon me alleen falende tests." Als je git-geschiedenis nodig hebt, beperk het: "Toon me de laatste 5 commits op deze branch." Als Claude voorstelt een commando uit te voeren dat massale output zal produceren, overweeg dan of je het allemaal echt nodig hebt — of gewoon een samenvatting.

Ik ben begonnen met het toevoegen van outputbeperkingen aan mijn CLAUDE.md als standaardregel: "Bij het uitvoeren van testsuites, onderdruk output van slagende tests. Bij het controleren van git-geschiedenis, beperk tot 10 items tenzij specifiek om meer wordt gevraagd." Dit voorkomt token bloat zonder dat ik er bij elk commando over hoef na te denken.

Deze structurele veranderingen kostten me een zaterdagmiddag om volledig te implementeren. De ROI is enorm geweest — ik schat 40-50% langere sessies gemiddeld, en de kwaliteit van Claude's antwoorden in de tweede helft van lange sessies is merkbaar verbeterd. De context blijft schoner, dus het model blijft scherper.

Maar voor gebruikers die Claude Code intensief inzetten — multi-agent workflows draaien, complexe systemen bouwen, of door piekuren rate limits werken — is het geavanceerde niveau waar het echte meesterschap leeft.

Niveau 3: Geavanceerde Token Engineering (Voor Power Users)

Deze vier technieken vereisen een dieper begrip van hoe Claude Code onder de motorkap werkt. Ze zijn niet voor iedereen. Maar als je het type ontwikkelaar bent dat autonome agentsystemen draait of dagelijks multi-uur sessies doorwerkt, dan schuilen hier de grootste winsten.

Kies het Juiste Model voor Elke Taak

Niet elke taak heeft het krachtigste model nodig. Claude Code geeft je toegang tot meerdere modellen, en de tokeneconomie verschilt dramatisch tussen hen.

Sonnet handelt de overgrote meerderheid van codeertaken af — componenten genereren, tests schrijven, functies refactoren, fouten debuggen. Het is snel, capabel en kost aanzienlijk minder tokens per beurt dan Opus.

Haiku is perfect voor eenvoudig, mechanisch werk: code formatteren, variabelen hernoemen, boilerplate genereren, basale tekstverwerking. Haiku gebruiken voor deze taken in plaats van Sonnet is als fietsen voor een ritje van twee blokken in plaats van de auto pakken.

Opus is het zware geschut. Diepe architectuurplanning, complexe multi-systeemredenering, genuanceerde analyse die vereist dat vele beperkingen tegelijkertijd worden vastgehouden. Ik gebruik Opus spaarzaam — misschien 15% van mijn totale Claude Code-interacties — en alleen voor taken waarbij de diepte van redenering de tokenpremium echt rechtvaardigt.

Ik heb modelselectiestrategie in detail behandeld in mijn AI-agent kostenoptimalisatiegids, maar het kernprincipe is hier direct van toepassing: stem de capaciteit van het model af op de vereisten van de taak. Opus gebruiken om een variabele te hernoemen is als een chirurg inhuren om een pleister te plakken.

Als je liever hebt dat iemand geoptimaliseerde AI-agentsystemen vanaf nul bouwt, neem ik aangepaste automatiserings- en integratieprojecten aan. Je kunt zien wat ik heb gebouwd op fiverr.com/s/EgxYmWD.

Gebruik Sub-Agents Strategisch (Niet Vrijelijk)

Sub-agents zijn krachtig omdat ze in aparte context windows draaien. Je hoofdgesprek blijft schoon terwijl de sub-agent een gerichte taak afhandelt en een samenvatting retourneert. In theorie is dit perfect voor tokenbeheer.

In de praktijk zijn sub-agents duur. Elke laadt de volledige context-overhead — systeemprompts, MCP-definities, CLAUDE.md — helemaal opnieuw. Een sub-agent sessie kan 7-10x meer tokens verbruiken dan dezelfde taak in je hoofdgesprek afhandelen, afhankelijk van de complexiteit.

De wiskunde werkt in je voordeel wanneer: de taak aanzienlijke bloat aan je hoofdcontext zou toevoegen (grote bestandsanalyse, uitgebreide codegeneratie), de taak schoon te scheiden is, en een samenvatting van het resultaat voldoende is.

De wiskunde werkt tegen je wanneer: de taak klein is, het resultaat uitgebreide discussie nodig heeft, of je meerdere sub-agents nodig zou hebben voor gerelateerde taken die context delen.

Ik gebruik sub-agents voor onderzoekstaken — "analyseer deze dependency tree en vertel me welke packages verouderd zijn" — en voor codegeneratie die ik apart zal reviewen. Ik vermijd ze voor iteratief werk waarbij ik meerdere keren met de agent heen en weer zou moeten.

Begrijp Piek- vs. Daluren Tokeneconomie

Volgens de eigen documentatie van Anthropic zijn de gemiddelde Claude Code-kosten $6 per ontwikkelaar per dag, met 90% van de gebruikers onder $12 per dag. Maar dat gemiddelde verbergt een aanzienlijke variantie op basis van wanneer je werkt.

Piekuren — ruwweg 8 uur 's ochtends tot 2 uur 's middags Eastern Time op weekdagen — vallen samen met maximale vraag op de infrastructuur van Anthropic. Tijdens deze vensters is rate limiting agressiever, kunnen contextbudgetten krapper aanvoelen, en worden zware sessies sneller beperkt.

Daluren — 's middags, 's avonds en weekenden — bieden meer speelruimte. Hetzelfde plan, dezelfde prompts, maar met minder concurrentie om bronnen.

Mijn aanpassing was eenvoudig: ik verschoof mijn zware multi-agent sessies en grote refactoringwerkzaamheden naar daluren. Snelle vragen en kleine taken gebeuren wanneer ik ze nodig heb. Maar de sessies waarin ik agressief tokens verbruik — die vinden plaats na 15:00 Eastern Time of op weekendochtenden.

Dit gaat niet om meer tokens krijgen. Het gaat om consistentere prestaties krijgen van de tokens die je hebt. Rate limiting tijdens piekuren kan flow-states onderbreken en voortijdige sessieonderbrekingen forceren die nog meer tokens verspillen aan contextheroppbouw.

Bouw een Systeemconstitutie in Je CLAUDE.md

Dit is de meest geavanceerde techniek op de lijst, en het is degene die de beste langetermijnresultaten opleverde.

Een systeemconstitutie is een sectie in je CLAUDE.md die stabiele architectuurbeslissingen, voortgangssamenvattingen en operationele regels vastlegt — niet als documentatie, maar als persistente instructies die elke interactie vormgeven.

Dit is wat erin komt:

Architectuurbeslissingen die vaststaan. "Dit project gebruikt het repository pattern voor alle databasetoegang. Stel nooit directe query builders in controllers voor." Dit voorkomt dat Claude beslissingen die je al hebt genomen opnieuw bediscussieert, wat de heen-en-weer tokens bespaart die komen van het corrigeren van suggesties.

Voortgangsmarkeringen. "Authenticatiemodule: compleet en getest. Betalingsintegratie: in uitvoering, Stripe webhook handler heeft retry-logica bij fouten nodig." Dit geeft Claude direct projectbewustzijn zonder je codebase te hoeven scannen of vragen te stellen.

Tokenbesparende regels. "Delegeer onderzoekstaken aan sub-agents. Vat bestandsanalyseresultaten samen in minder dan 100 woorden voordat je ze presenteert. Geef nooit volledige bestandsinhoud weer wanneer een diff zou volstaan." Deze regels stapelen zich op — ze besparen automatisch tokens bij elke interactie.

Het kernprincipe: bewaar beslissingen, geen gesprekken. Je constitutie moet de conclusies van eerdere discussies vastleggen, niet de discussies zelf. "We hebben besloten Redis te gebruiken voor sessie-opslag omdat PostgreSQL latentieproblemen veroorzaakte onder belasting" is nuttige context in één regel. Het volledige gesprek waarin je die beslissing hebt verkend? Dat zijn vijftig regels context die je niet hoeft mee te dragen.

Ik werk mijn systeemconstitutie bij aan het einde van elke grote ontwikkelsessie. Het kost twee minuten en bespaart me tien minuten contextopbouw aan het begin van de volgende sessie. Over weken en maanden zijn de samengestelde besparingen aanzienlijk.

De Mentaliteitsverandering Die Alles Samenbrengt

Als je tot hier hebt gelezen, denk je misschien dat deze 18 technieken voelen als veel overhead. Tokenpercentages bijhouden, je sessies timen, je CLAUDE.md herstructureren, handmatig compacteren bij 60%. Is dit allemaal echt nodig?

Hier is mijn eerlijke antwoord: niet alles. Niet alles tegelijk.

Begin met de Niveau 1-basis. /clear tussen ongerelateerde taken, inactieve MCPs loskoppelen, je prompts bundelen. Deze drie gewoontes alleen al zullen je sessies merkbaar verlengen. Zodra die natuurlijk aanvoelen — geef het een week — bouw dan de Niveau 2 structurele veranderingen op. De CLAUDE.md-herstructurering en de gewoonte van handmatige compactie zullen de volgende grote sprong opleveren.

Niveau 3 is voor wanneer je het gereedschap hard genoeg inzet dat incrementele winsten ertoe doen. De meeste ontwikkelaars hebben niet alle vier geavanceerde technieken nodig. Maar de modelselectiestrategie en de systeemconstitutie zijn het waard om te implementeren ongeacht je gebruiksniveau.

Het overkoepelende inzicht — het ding dat ik wou dat iemand me zes maanden geleden had verteld — is dat het raken van tokenlimieten geen teken is dat je plan te klein is. Het is bijna altijd een teken dat je contexthygiëne werk nodig heeft. De tokens zijn er. Je besteedt ze alleen aan de verkeerde dingen.

Anthropic erkende eind maart 2026 dat gebruikers sneller limieten bereikten dan verwacht, en ze hebben het hun hoogste technische prioriteit gemaakt. Infrastructuurverbeteringen zijn in aantocht. Maar zelfs wanneer quota's toenemen, zullen deze technieken nog steeds belangrijk zijn — want schone context bespaart niet alleen tokens. Het produceert betere output. Een model dat werkt met 50.000 tokens gerichte, relevante context zal beter presteren dan hetzelfde model dat worstelt door 200.000 tokens opgestapelde ruis.

Denk er zo over: tokenbeheer gaat niet over zuinig zijn met AI-bronnen. Het gaat over er precies mee omgaan. Op dezelfde manier als een bekwame ontwikkelaar schone, gerichte code schrijft in plaats van opgeblazen spaghetti — niet omdat ze beperkt zijn, maar omdat helderheid betere resultaten oplevert.

Je sessies zullen langer duren. Je outputs zullen scherper zijn. En je stopt met het gereedschap de schuld te geven voor een probleem dat altijd om de workflow draaide.

Wat Te Doen in de Komende Tien Minuten

Sluit dit artikel en open je actieve Claude Code-sessie. Voer /context uit. Kijk naar de uitsplitsing. Ik garandeer dat er iets in zal zitten dat je verrast — een opgeblazen CLAUDE.md, drie MCP-servers die je vergeten was dat ze verbonden waren, een gespreksgeschiedenis die voor 80% irrelevant is.

Fix de grootste overtreder. Slechts één. Pas dan twee of drie van de Niveau 1-technieken toe tijdens je volgende werksessie.

Kom over een week terug naar dit artikel en implementeer de Niveau 2-veranderingen. Op dat moment heb je genoeg ervaring uit eerste hand met de tokenmechanismen om precies te begrijpen waarom elke structurele verandering ertoe doet — omdat je de pijnpunten zelf zult hebben gevoeld.

De ontwikkelaars die Claude Code beheersen zijn niet degenen met de grootste plannen. Het zijn degenen die de minste tokens verspillen aan dingen die er niet toe doen. Dat is een vaardigheid die je kunt opbouwen, vanaf nu.

Veelgestelde Vragen

Hoe controleer ik mijn Claude Code tokengebruik?

Voer /context uit om een gedetailleerde uitsplitsing te zien van waar tokens aan worden toegewezen — systeemprompt, tools, geheugenbestanden en gespreksgeschiedenis. Voer /cost uit om het cumulatieve API-tokengebruik voor de huidige sessie te zien. Beide commando's zijn beschikbaar in Claude Code v1.0.86 en later.

Wat is het verschil tussen /clear en /compact in Claude Code?

/clear wist de gespreksgeschiedenis volledig en start opnieuw. /compact vat het bestaande gesprek samen en vervangt de volledige geschiedenis met een gecomprimeerde versie, waarbij belangrijke context bewaard blijft terwijl tokens worden vrijgemaakt. Gebruik /clear wanneer je volledig van taak wisselt; gebruik /compact wanneer je dezelfde taak voortzet maar meer ruimte nodig hebt.

Waarom wordt Claude Code slechter aan het einde van lange sessies?

Het "loss in the middle"-effect zorgt ervoor dat Claude minder aandacht besteedt aan informatie die diep in het context window is begraven. Naarmate gesprekken groeien, worden eerdere instructies en context naar deze lage-aandachtszone geduwd, waardoor de outputkwaliteit afneemt. Compacteren bij 60% capaciteit — in plaats van wachten op de automatische trigger van 95% — helpt de antwoordkwaliteit gedurende de hele sessie te behouden.

Hoeveel tokens gebruikt een typische Claude Code-sessie?

Tokenkosten stapelen zich op met de gesprekslengte. Een eerste bericht kost ruwweg 500 tokens, maar bij bericht 30 kan elke beurt 15.000+ tokens kosten door het volledig herlezen van de context. Volgens gegevens van Anthropic zijn de gemiddelde dagelijkse kosten $6 per ontwikkelaar, waarbij 90% van de gebruikers onder $12 blijft.

Beïnvloeden MCP-servers het tokengebruik van Claude Code?

Ja, aanzienlijk. Elke verbonden MCP-server laadt zijn volledige tooldefinitie-schema in het context window bij elk bericht. Het gelijktijdig draaien van meerdere MCP-servers kan duizenden tokens per beurt toevoegen. Koppel alle MCP-servers los die je niet actief gebruikt om deze overhead te verminderen.

Laten We Samenwerken

Wil je AI-systemen bouwen, workflows automatiseren of je technische infrastructuur opschalen? Ik help je graag.

• Fiverr (maatwerk builds & integraties): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise oplossingen): ramlit.com
• ColorPark (ontwerp & branding): colorpark.io
• xCyberSecurity (beveiligingsdiensten): xcybersecurity.io