Claude Code in de terminal: alle modi en mods die je kunt aanzetten (november 2026)
Auto mode staat sinds eind september standaard aan, effort begint op medium en sinds oktober kun je Claude Code zelf verbouwen met mods. Alle schakelaars in de terminal op een rij: wat ze doen, wat ze kosten en waar ze bijten. Met een zelf geteste mod.

Start claude in een terminal en kijk naar de onderste regel. Daar staat ⏵⏵ auto mode on. Je hebt niets aangezet, toch beslist er nu een tweede model of Claude een commando mag uitvoeren. Dat is sinds eind september de standaard, op elk abonnement, zolang je model auto mode ondersteunt. Veel mensen weten het niet, omdat de melding er maar één keer staat, bovenaan je eerste sessie.
Zo gaat het met meer dingen in Claude Code. Er komen bijna elke dag nieuwe versies uit. Versie 2.1.328 verscheen in de nacht van 18 op 19 november, en de changelog telt inmiddels ruim elfduizend regels. Daartussen zitten schakelaars die je werkdag merkbaar veranderen: hoe diep Claude nadenkt, hoe snel het antwoordt, of het zelf doorwerkt tot een test groen is, en sinds oktober zelfs mods, stukjes code waarmee je Claude Code zelf verbouwt. Dit artikel loopt ze allemaal langs: wat elke schakelaar doet, wanneer je hem aanzet, wat hij kost en waar hij je kan bijten.
Gecontroleerd op 19 november 2026 tegen de officiële documentatie op code.claude.com, de changelog van Claude Code en de releasedata op npm. Ik werk zelf met Claude Code 2.1.328 op Windows 11. De voorbeeldmod verderop heb ik geschreven, gevalideerd en uitgevoerd. De overige beschrijvingen komen uit de documentatie en zijn niet door mij nagemeten. Dit artikel is geschreven met hulp van Claude Code.
Kort antwoord. Laat auto mode aan voor dagelijks werk en druk op Shift+Tab naar plan mode voordat je iets groots verandert. Laat het denkniveau (/effort) op medium staan en zet het alleen voor lastige bugs hoger. Gebruik /goal als het werk een meetbaar eindpunt heeft. Fast mode, ultracode en de advisor kosten extra, dus die zet je bewust aan. Code Mode is sinds 12 november experimenteel beschikbaar. Mods voegen echte functies toe aan Claude Code, maar ze draaien met jouw rechten en zonder sandbox. Op een persoonlijk abonnement kunnen ze ook een deel van je permissieregels omzeilen. Lees een mod dus voordat je hem installeert.
Modus, mod of instelling: wat is wat?
De woorden lopen in Claude Code door elkaar, en dat maakt het lastig. "Auto mode", "fast mode", "Code Mode" en "plan mode" klinken als vier standen van één knop. Dat zijn ze niet. Ze werken op verschillende plekken, en de meeste kun je tegelijk aanzetten.
| Wat | Waar het over gaat | Hoe je het aanzet |
|---|---|---|
| Permissiemodus (manual, acceptEdits, plan, auto, dontAsk, bypassPermissions) | Wat Claude mag doen zonder het jou te vragen | Shift+Tab of --permission-mode |
| Effort (low tot max) | Hoeveel het model nadenkt per stap | /effort of --effort |
| Ultracode | Of Claude grote taken met een script over tientallen subagents verdeelt | /effort ultracode |
| Fast mode | Hetzelfde model, sneller en duurder | /fast |
| Advisor | Een tweede, sterker model dat op belangrijke momenten meekijkt | /advisor |
/goal | Doorwerken over meerdere beurten tot een voorwaarde klopt | /goal <voorwaarde> |
| Code Mode | Claude schrijft JavaScript dat zijn tools aanroept | Omgevingsvariabele, experimenteel |
| Fullscreen en output styles | Hoe het scherm en de antwoorden eruitzien | /tui, /output-style |
| Mods | Plugins die Claude Code zelf veranderen: panelen, commando's, regels voor tools | /plugin |
Ik behandel ze in deze volgorde. De eerste twee kom je elke dag tegen, de laatste is het nieuwst.
Permissiemodi: wie keurt goed wat Claude doet?
Een permissiemodus bepaalt welke acties Claude zonder jouw toestemming mag uitvoeren. Met Shift+Tab wissel je tijdens een sessie. Vanuit auto mode gaat de eerste druk naar manual, daarna volgen acceptEdits en plan, en dan ben je terug bij auto. De statusregel laat zien waar je staat.

| Modus | Wat zonder vragen mag | Gebruik het voor |
|---|---|---|
Manual (default) | Alleen lezen | Gevoelig werk, code die je niet kent |
acceptEdits | Lezen, bestanden bewerken, mkdir, mv, cp en dergelijke | Code die je meteen zelf naleest |
plan | Lezen en verkennen; bewerken pas na jouw akkoord | Eerst begrijpen, dan bouwen |
auto | Alles, maar een tweede model controleert elke riskante actie | Lange taken, minder klikwerk |
dontAsk | Alleen wat je vooraf toestaat; de rest wordt geweigerd | Scripts en CI |
bypassPermissions | Alles | Alleen in een container of VM |
Wat auto mode echt doet
In auto mode keur jij niet meer elk commando goed. Een classifier doet dat: een apart model, standaard Claude Sonnet 5, dat elke actie naast jouw opdracht legt. Lezen en bewerken binnen je projectmap gaan meestal zonder controle door. De rest gaat langs de classifier. Volgens de documentatie houdt die standaard onder meer tegen: curl | bash, een force-push, git reset --hard en andere commando's die niet-gecommit werk weggooien, productie-deploys en -migraties, het versturen van gevoelige data naar buiten, terraform destroy en het mergen van een pull request die geen mens heeft goedgekeurd.
Twee details staan niet op de eerste pagina van de documentatie, maar zijn in de praktijk belangrijk.
Ten eerste luistert de classifier naar wat je in het gesprek zegt. Schrijf je "niet pushen voordat ik heb gekeken", dan blokkeert hij een push, ook als die volgens de standaardregels was toegestaan. Maar zo'n grens is geen regel. De classifier leest hem bij elke controle opnieuw uit het gesprek. Ruimt Claude Code dat deel van het gesprek op bij het comprimeren, dan is de grens weg. Wil je zekerheid, zet het dan als deny-regel in je instellingen.
Ten tweede valt auto mode terug op vragen als de classifier drie keer achter elkaar of twintig keer in totaal iets blokkeert. Dat is vaak geen fout van Claude. Meestal kent de classifier je infrastructuur niet. Wat er geblokkeerd is, zie je in /permissions onder Recently blocked. Daar kun je een actie alsnog goedkeuren.
Er is ook een valkuil in de instellingen. "defaultMode" met de waarde auto of bypassPermissions werkt niet vanuit de projectbestanden .claude/settings.json en .claude/settings.local.json. Dat is met opzet: anders zou een repository die je kloont zichzelf ruimere rechten kunnen geven. Je krijgt geen foutmelding. Bij bypassPermissions start de sessie in manual. Bij auto geldt de ingebouwde standaard, en ook een defaultMode uit je eigen ~/.claude/settings.json wordt dan genegeerd. Wie in zijn gebruikersinstellingen manual heeft vastgelegd en in een project auto zet, start dus in auto.
De documentatie zegt het zelf: auto mode "reduces permission prompts but does not guarantee safety". Op Windows komt er nog iets bij. De sandbox voor shell-commando's werkt op macOS, Linux en WSL2, maar niet op native Windows. Daar draaien commando's zonder sandbox, en is de classifier je enige vangnet.
Plan mode: eerst denken, dan pas bouwen
In plan mode leest en verkent Claude, en schrijft het een plan. Je broncode blijft onaangeroerd tot jij het plan goedkeurt. Je komt erin met Shift+Tab, of je zet /plan voor één prompt. Als het plan klaar is, kies je: goedkeuren en in auto mode verder, goedkeuren en elke bewerking zelf bekijken, of verder plannen.
Met Ctrl+G open je het plan in je eigen editor, zodat je het kunt aanpassen voordat Claude begint. Daar zit ook de klassieke vergissing. Op het goedkeuringsscherm keurt Shift+Tab het plan goed. Wie uit gewoonte op Shift+Tab drukt om van modus te wisselen, start dus de uitvoering. Druk eerst op Esc.
Plan mode bespaart het meeste werk als je een codebase niet kent of als een wijziging veel bestanden raakt. Voor een kleine fix is het overbodig: het plan is dan langer dan de wijziging.
Effort: hoeveel denkt Claude na?
Effort bepaalt hoeveel het model per stap redeneert. De niveaus zijn low, medium, high, xhigh en max. Hoger betekent grondiger, maar ook trager en meer tokens. Opus 5.5, het standaardmodel op alle abonnementen, begint op medium. Bij de meeste oudere modellen was high de standaard. Dat is minder erg dan het klinkt. Een niveau betekent per model iets anders, en volgens Anthropic presteert Opus 5.5 op medium minstens zo goed als Opus 5 op high.
| Niveau | Wanneer (volgens de documentatie) |
|---|---|
low | Korte vragen, een eerste schets, een hernoeming |
medium | Standaard. Dagelijks werk met een duidelijke afbakening, zoals een nieuwe functie bouwen |
high | Werk waarbij controle telt, zoals een bug in bestaande code |
xhigh | Dieper redeneren tegen meer tokens |
max | Het diepste niveau; geldt alleen voor de huidige sessie |
Een paar handigheden. Typ /effort zonder argument voor een schuifregelaar. Met Enter bewaar je het niveau als standaard voor dat model, met s geldt het alleen voor deze sessie. Wil je één keer dieper laten nadenken zonder je instelling te veranderen, zet dan het woord ultrathink in je prompt. Woorden als "think hard" herkent Claude Code niet als sleutelwoord; die gaan als gewone tekst mee. Met /effort auto wis je je bewaarde niveau.
Mijn advies: begin op medium en ga pas omhoog als Claude iets mist dat je had verwacht. Een hoger niveau lost geen onduidelijke opdracht op. Het model denkt dan alleen langer na over de verkeerde vraag.
Ultracode: tientallen agents met één schakelaar
Ultracode is geen denkniveau, al zit hij in hetzelfde menu. Staat ultracode aan, dan verdeelt Claude een grote klus over een dynamic workflow: een JavaScript-script dat Claude zelf schrijft en dat op de achtergrond tientallen tot honderden subagents aanstuurt. De tussenresultaten staan in variabelen van het script, niet in het geheugen van je gesprek. Daardoor raakt je contextvenster niet vol, en kun je het script later opnieuw draaien.
Aanzetten gaat met /effort ultracode, of in de schuifregelaar met Tab. Met claude --effort ultracode start je meteen op xhigh met ultracode aan. Wil je eerst zien hoe zo'n workflow werkt, probeer dan de ingebouwde /deep-research met een vraag. Die zoekt vanuit meerdere invalshoeken naar bronnen, controleert ze tegen elkaar en levert een rapport met bronvermelding. Met /workflows volg je de voortgang.
Een workflow voor een audit van de hele codebase of een migratie van vijfhonderd bestanden is precies waar dit voor bedoeld is. Voor een bugfix in één bestand is het te veel: elke agent verbruikt tokens, en je betaalt voor het overleg tussen agents. Ik zet ultracode dus per taak aan en daarna weer uit.
Fast mode: sneller, hetzelfde model, duurder
Fast mode is hetzelfde model met een andere API-configuratie. Volgens Anthropic is het tot 2,5 keer zo snel, en de kwaliteit blijft gelijk. Je zet het aan met /fast. Er verschijnt dan een ↯ naast de prompt. Op de Anthropic API werkt het op Fable 5.2 en Opus 5.5, en als research preview op Opus 5 en Opus 4.8, niet op Sonnet of Haiku. Fast mode voor Opus 4.8 verdwijnt op 30 november 2026. Sta je op een model zonder fast mode, dan schakelt /fast je over naar Opus.
Het kost wel meer. Fast mode met Opus 5.5 kost $8 per miljoen invoertokens en $40 per miljoen uitvoertokens, met Fable 5.2 is dat $16 en $80. Op een Pro-, Max-, Ultra-, Team- of Enterprise-abonnement gaat fast mode altijd van je usage credits af, niet van de limieten in je abonnement. Die usage credits moeten aanstaan, en bij Team en Enterprise moet een beheerder fast mode eerst inschakelen.
Zet fast mode aan het begin van een gesprek aan, niet halverwege. Fast mode en de normale snelheid hebben elk hun eigen promptcache. De eerste keer dat je overschakelt, betaal je daarom het volle fast-tarief voor alle context die er al is. Hoe langer het gesprek, hoe duurder die overstap. Fast mode is handig voor live debuggen en snel itereren, als je zit te wachten op elk antwoord. Voor een taak die een uur op de achtergrond loopt, heb je er niets aan.
De advisor: een tweede mening op het goede moment
Met /advisor opus of /advisor fable krijgt Claude een adviseur. Dat is een tweede model dat Claude zelf raadpleegt op momenten die ertoe doen: voordat het voor een aanpak kiest, als dezelfde fout steeds terugkomt, of voordat het zegt dat iets klaar is. De adviseur leest het hele gesprek en geeft advies, en Claude past dat toe. De adviseur moet minstens zo sterk zijn als je hoofdmodel. Bij Opus 5 of 5.5 als hoofdmodel komen alleen Fable en Opus 5 of nieuwer in aanmerking. Claude Code meldt Advisor Tool (experimental) en waarschuwt dat het meer tokens kan kosten.
Het werkt vooral goed bij lange taken waarin de meeste stappen routine zijn, maar waarin het plan de uitkomst bepaalt. Een grote refactor, of een bug die na drie pogingen nog steeds terugkomt. Bij korte taken voegt het weinig toe.
/goal: doorwerken tot het klopt
Claude stopt als het denkt dat het klaar is, en dat is niet altijd het moment dat jij bedoelt. Met /goal geef je een eindvoorwaarde op. Na elke beurt controleert een apart model of die voorwaarde klopt. Zo niet, dan begint Claude zelf aan een nieuwe beurt.
/goal alle tests in tests/Feature/Auth slagen, "composer lint" geeft exitcode 0, en er is geen ander testbestand aangepast Een goede voorwaarde heeft één meetbaar eindpunt, zegt hoe Claude dat bewijst en noemt wat niet mag veranderen. Het controlerende model voert zelf geen commando's uit. Het leest alleen wat Claude in het gesprek laat zien. "De code is netjes" werkt dus niet; "npm test geeft exitcode 0" wel. Wil je een grens, voeg dan toe: "of stop na 20 beurten". Met /goal zonder argument zie je de status, met /goal clear stop je.
Belangrijk: /goal verandert je permissiemodus niet. In manual blijft Claude om toestemming vragen, en dan sta je alsnog elke paar minuten op een knop te drukken. De twee vullen elkaar aan. Auto mode haalt de vragen per tool weg, /goal de vragen per beurt. Voor een onbeheerde run heb je dus allebei nodig. In Claude Code autonoom laten werken staat hoe je zo'n run opzet en waar hij misgaat.
Code Mode: Claude schrijft code om zijn tools aan te roepen
Code Mode is het nieuwste experiment. Het kwam op 12 november uit, in versie 2.1.323. Normaal vraagt Claude één tool aan, wacht het op het resultaat en beslist dan wat het volgende wordt. In Code Mode schrijft Claude een stuk JavaScript dat meerdere tools aanroept, commando's parallel kan draaien en alleen het deel van de uitvoer teruggeeft dat Claude nodig heeft. Het voorbeeld uit de documentatie:
const files = await $`rg -l "function retryPolicy" src`.text();
const target = files.trim().split("\n")[0];
await edit(target, "maxAttempts: 3", "maxAttempts: 5");
({ edited: target, tests: $`npm test -- retryPolicy`.nothrow() }); In het gesprek zie je gewoon de bewerkingen. De code zelf zie je met Ctrl+O. Aanzetten gaat met de omgevingsvariabele CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1. Bij de eerste keer vraagt Claude Code om bevestiging en start het opnieuw op.
De voorwaarden zijn streng. Je hebt de native build nodig, versie 2.1.323 of hoger, Opus 5.5, Sonnet 5.5, Haiku 5.5 of Fable 5.2, en een interactieve terminalsessie. Het werkt onder meer niet met -p, de Agent SDK, VS Code, de Desktop-app of cloudsessies, en niet via Bedrock, een gateway of met DISABLE_TELEMETRY. Op Windows heb je Git for Windows nodig, want de shell-commando's in de scripts draaien in Git Bash. Remote Control, Claude in Chrome en computer use werken niet in Code Mode, en zo'n sessie kun je alleen hervatten met Code Mode aan.
Dit is het belangrijkste compromis. In auto mode beoordeelt de classifier in Code Mode het script één keer als geheel. De losse toolaanroepen erin worden niet apart gecontroleerd. deny- en ask-regels blijven werken, maar de documentatie waarschuwt dat Claude Bash-commando's dan kan schrijven in vormen die je regels niet herkennen. Dat laatste geldt eigenlijk altijd: Bash-regels kijken naar de tekst van een commando, met of zonder Code Mode. Het echte verschil zit in de classifier. Die ziet geen waarden die pas tijdens het draaien ontstaan, zoals een pad dat uit een zoekresultaat komt. Wat je echt wilt tegenhouden, regel je daarom met de sandbox of een hook, niet met een tekstregel.
Mijn advies: probeer Code Mode op een repository waar niets kapot kan, voor taken met veel kleine stappen. Denk aan dezelfde wijziging in veertig bestanden, of zoekresultaten die eerst gefilterd moeten worden. Daar is het voordeel het grootst. Voor werk waarbij je elke stap wilt zien, wacht je beter tot het experiment volwassen is.
Het scherm en de toon
Fullscreen: geen flikkering meer
Springt je terminal naar boven terwijl Claude werkt, of flitst het scherm bij lange uitvoer? Typ /tui fullscreen. Wie Claude Code voor het eerst op of na 6 mei 2026 gebruikte, start er vaak al standaard in. Claude Code tekent dan op het alternatieve scherm van de terminal, zoals vim en htop. Het tekent alleen wat zichtbaar is, het geheugengebruik blijft vlak in lange gesprekken, en je kunt de muis gebruiken. Het verschil is het grootst in de terminal van VS Code, in tmux en in iTerm2. Met /tui default ga je terug. Fullscreen is nog een research preview.
Output styles: hoe Claude tegen je praat
Met /output-style kies je een van de vier ingebouwde stijlen naast de standaard. Proactive begint meteen en neemt routinebeslissingen zelf. Concise begint met het resultaat en laat de inleiding en de samenvatting weg. Explanatory voegt korte uitlegblokken toe over de gemaakte keuzes. Learning laat kleine stukjes code voor jou over om zelf te schrijven. Die laatste is handig als je een nieuwe taal leert en zelf ook wilt blijven programmeren. Let wel: een output style is een instructie, geen garantie. Wat altijd moet gebeuren, regel je met een hook.
Drie toetsen die je wilt kennen
EscEscbij een lege prompt opent het terugspoelmenu. Daarmee zet je de code, het gesprek of allebei terug naar een eerder punt. Claude Code bewaart bestandssnapshots van de laatste honderd checkpoints, standaard ongeveer dertig dagen. Een bestand dat alleen via shell-commando's is veranderd, zet het niet terug; daarvoor heb je Git.Ctrl+Oopent het volledige transcript, met de code van Code Mode, de redenen achter de oordelen van/goalen de details van elke toolaanroep./btwstelt een zijvraag over de sessie die niet in het gesprek terechtkomt. Zo vervuil je je context niet.
Mods: Claude Code zelf verbouwen
Sinds versie 2.1.287, uitgebracht op 1 oktober, kan een plugin een mod bevatten. Een mod is JavaScript of TypeScript dat binnen Claude Code draait. Claude Code roept je functies aan bij gebeurtenissen: Claude wil een tool gebruiken, je verstuurt een prompt, of een deel van het scherm wordt getekend. Je functie kan meekijken, de gebeurtenis aanpassen of hem helemaal overnemen.
Dat lijkt op de hooks die je al kende, maar het verschil is groot. Een gewone hook in settings.json is een los commando, HTTP-verzoek of prompt dat van buitenaf meekijkt. Een mod draait in het proces zelf. Hij kan een paneel naast het gesprek tekenen, een balk boven de prompt, knoppen en invoervelden. Hij kan een /commando toevoegen dat meteen werkt, zonder dat Claude een beurt nodig heeft. En hij kan een toolaanroep vasthouden terwijl hij jou iets vraagt.

Ingebouwde mods
Een deel van Claude Code is zelf al als mod gebouwd. In /plugin, op het tabblad Installed, staan ze onder Built-in. Een paar voorbeelden uit de documentatie:
Naam in /plugin | Wat het doet | Standaard |
|---|---|---|
cc-plugin-diff | Tekent het paneel van /diff | Aan in interactieve terminalsessies |
cc-plugin-agents-md | Laadt AGENTS.md als projectinstructies | Aan |
cc-plugin-sec-default | Beschermt wat je organisatie beheert tegen mods die je zelf installeert | Alleen met managed settings of een Team- of Enterprise-login; niet uit te zetten |
cc-plugin-you-should-know | Een zij-agent die meeleest en een korte waarschuwing boven de prompt zet als hij iets ziet wat je misschien mist | Uit |
Die laatste is de mod die de meeste mensen zelf zullen aanzetten:
/plugin enable cc-plugin-you-should-know@builtin Tijdens een langere taak leest een zij-agent af en toe het gesprek terug. Ziet hij iets wat je moet weten, bijvoorbeeld een afweging die Claude stilzwijgend maakte of een resultaat dat niet lijkt te kloppen, dan verschijnt er een regel met ✦ Heads up. Die zij-agent heeft geen tools. Hij kan dus niets lezen, uitvoeren of veranderen. Gratis is hij niet. Elke controle is een aanvraag aan hetzelfde model en telt mee voor je limieten. Het gesprek komt grotendeels uit de promptcache, maar de instructies van de mod (enkele duizenden tokens) en het antwoord betaal je bij elke controle volledig. Je ziet hem alleen als je rechtstreeks met de Claude API verbonden bent en telemetrie aan staat. Achter een gateway of met DISABLE_TELEMETRY staat hij niet in de lijst. Op mijn machine laat claude plugin details cc-plugin-you-should-know@builtin hem zien. Daar staat "~0 tok" aan vaste kosten, maar dat getal gaat alleen over wat altijd in je context staat, niet over de controles zelf.
Een eigen mod, getest
Om te zien of het echt zo eenvoudig is als de documentatie belooft, schreef ik een kleine mod: push-guard. Hij weigert elke force-push. Bij een push naar main of master vraagt hij eerst om bevestiging. En hij telt Claudes toolaanroepen, die je met /tally opvraagt. Er is geen Node.js, bundler of build-stap nodig; Claude Code laadt het .js-bestand rechtstreeks. Een mod bestaat uit drie bestanden:
push-guard/
├── .claude-plugin/
│ └── plugin.json
└── hooks/
├── hooks.json
└── register.js .claude-plugin/plugin.json is het manifest van de plugin:
{
"name": "push-guard",
"version": "0.1.0",
"author": { "name": "Erik van de Blaak" },
"license": "MIT",
"description": "Weigert force-pushes, vraagt eerst bij een push naar main of master, en telt Claudes toolaanroepen (/tally)"
} hooks/hooks.json wijst naar de code. Juist de sleutel modules maakt van een plugin een mod:
{
"description": "push-guard hooks module",
"modules": ["./register.js"]
} En hooks/register.js bevat de mod zelf:
// Gedeeld door alle hooks hieronder
let calls = 0
// Force-push: --force, --force-with-lease, -f, of een refspec met + (git push origin +main)
const FORCE = /\bgit\s+push\b.*(\s--force\b|\s--force-with-lease\b|\s-f\b|\s\+\S)/
// Een push die main of master noemt
const MAIN = /\bgit\s+push\b.*\b(main|master)\b/
export function register(on) {
on('session.start', async ($, e, next) => {
await $.command.register({
name: 'tally',
description: 'Laat zien hoeveel tools Claude deze sessie heeft aangeroepen',
})
return next(e)
})
// Elke toolaanroep tellen, en de teller naast de spinner zetten
on('tool.call', async ($, e, next) => {
calls += 1
$.ui.invalidate('ui.render')
return next(e)
})
// Alleen Bash: force-push weigeren, push naar main eerst voorleggen
on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
if (FORCE.test(e.command)) {
return { deny: 'Force-push is hier uitgeschakeld. Push naar een nieuwe branch en open een pull request.' }
}
if (MAIN.test(e.command)) {
let answer = 'Weigeren'
try {
answer = await $.ui.ask('Claude wil pushen naar main/master: ' + e.command, ['Pushen', 'Weigeren'])
} catch {
// Vraag weggeklikt, of claude -p zonder iemand om te vragen
}
if (answer !== 'Pushen') {
return { deny: 'De gebruiker wil niet direct naar main/master pushen. Gebruik een feature-branch.' }
}
}
return next(e)
}).catch(() => ({ deny: 'push-guard kon dit commando niet controleren en weigert het daarom.' }))
on('command.run', { command: 'tally' }, async () => {
return { text: 'Claude heeft ' + calls + ' tools aangeroepen sinds deze mod laadde' }
})
on('ui.render', { component: 'Spinner' }, async ($, e, next) => {
return next({ ...e, props: { ...e.props, suffix: ' · tools: ' + calls + '…' } })
})
} Elke hook krijgt drie dingen mee. $ is de mods-API: alles wat een mod buiten zijn eigen code kan doen, zoals tekenen, een commando registreren of iets vragen. e is de gebeurtenis, bijvoorbeeld de toolnaam en e.command bij Bash. next geeft de gebeurtenis door aan de volgende mod en uiteindelijk aan Claude Code zelf. Een hook die next aanroept, laat de actie doorgaan. Een hook die iets teruggeeft zonder next, neemt de actie over. In dat geval verschijnt er geen permissievraag en draait de tool niet.
Let op de .catch op de Bash-hook. Als een hook een fout gooit of te lang duurt, slaat Claude Code hem over en gaat het commando gewoon door. Bij een bewaker is dat precies verkeerd. Met .catch weigert de mod het commando als hij het zelf niet kan controleren. De validator wijst je hierop: bij mijn tellende hook meldt hij gating hook without .catch. Bij een hook die alleen meetelt is dat geen probleem.
Zo heb ik hem gecontroleerd op Windows 11 met Claude Code 2.1.328. Eerst de statische controle, die niets uitvoert:
claude plugin validate ./push-guard ❯ ./register.js hooks: session.start, tool.call, tool.call{tool=Bash}, command.run{command=tally}, ui.render{component=Spinner}
❯ ./register.js answers its own command: command.run{command=tally}
❯ ./register.js gating hook without .catch: tool.call
❯ ./register.js gating hook with .catch: tool.call{tool=Bash}
❯ ./register.js calls: $.command.register, $.ui.ask, $.ui.invalidate
✔ Validation passed Daarna het commando, in een wegwerp-repository, zonder dat Claude een beurt nodig had:
PS> claude -p "/tally" --plugin-dir .\push-guard
push-guard: Claude heeft 0 tools aangeroepen sinds deze mod laadde Daarna gaf ik de wegwerp-repository een lokale remote en liet ik Claude pushen, met een allow-regel voor Bash(git push *), zodat alleen de mod het nog kon tegenhouden. Dit is wat er gebeurde:
| Commando | Resultaat |
|---|---|
git push --force origin main | Geweigerd: Force-push is hier uitgeschakeld. Push naar een nieuwe branch en open een pull request. |
git push origin +HEAD:refs/heads/test-plus | Geweigerd, met dezelfde melding (een + in de refspec is ook een force-push) |
git push origin main | Geweigerd: in claude -p is er niemand om de vraag te beantwoorden, dus $.ui.ask faalt en de mod valt terug op "Weigeren" |
git push origin HEAD:refs/heads/feat-test | Uitgevoerd; de branch feat-test stond daarna op de remote |
Drie dingen vielen me op. Ten eerste: Git Bash op Windows maakt van /tally stilletjes het pad C:/Program Files/Git/tally. Claude kreeg dus een pad in plaats van een commando. In PowerShell gaat het goed, en in Git Bash helpt MSYS_NO_PATHCONV=1.
Ten tweede is de regex maar zo goed als je hem maakt. Het voorbeeld uit de documentatie mist git push -f, en mijn eerste versie miste +main. Ook nu nog gaat er iets mis. git push origin main:feat-test pusht naar een feature-branch, maar wordt als push naar main gezien. git -C ../ander push --force en git push origin HEAD vanaf main glippen er juist doorheen. Een mod die commando's als tekst leest, is een extra laag. Een harde grens is branch protection op de server.
Ten derde: toen ik Claude in één opdracht een force-push én +main liet proberen, voerde het die tweede niet eens uit. Het zag het als een manier om de eerste weigering te omzeilen. Dat is prettig gedrag, maar het is gedrag van het model, en daar bouw je geen beveiliging op.
Je hoeft een mod niet zelf te schrijven. Vraag in een sessie bijvoorbeeld "maak een mod die de huidige git-branch boven de prompt toont". Claude gebruikt dan de ingebouwde skill plugin-authoring, schrijft de mod in ~/.claude/dev-mods/ en vraagt of hij hem meteen mag laden. Die vraag krijg je alleen in manual en acceptEdits. In auto mode laadt Claude Code een mod die Claude zelf schreef zonder te vragen. Als een mod je permissieregels deels kan omzeilen, is dat een reden om voor dit werk even naar manual te gaan. Anthropic deelt ook voorbeeldmods in de repository claude-code-playground, zoals blast-radius. Die houdt riskante commando's vast en laat eerst zien wat ze zouden veranderen.
Lees een mod voordat je hem installeert
Dit is het deel dat in enthousiaste berichten over mods ontbreekt. Een mod draait met jouw rechten en heeft geen sandbox. Hij kan je bestanden lezen en schrijven, programma's starten, het netwerk op en je omgevingsvariabelen lezen, dus ook API-sleutels. Hij ziet elke prompt en elke toolaanroep. En de sandbox van Bash geldt niet voor processen die een mod zelf start.
Dan de vraag wie het laatste woord heeft: je deny-regels of een mod. Dat hangt af van de ingebouwde bewaker cc-plugin-sec-default, en die laadt niet altijd. Volgens de documentatie laadt hij alleen als er managed settings of een managed-mcp.json op de machine staan, of als je sessie draait op een Team- of Enterprise-login. Werk je zelfstandig met Pro of Max, of met een API-sleutel, dan is er geen bewaker. Dat geldt ook voor een sessie met een langlopend CLAUDE_CODE_OAUTH_TOKEN. Een mod kan dan een aanroep goedkeuren die een PreToolUse-hook blokkeerde, en zelfs sommige aanroepen die een deny-regel weigert. Ook met de bewaker blijft er een gat. Een mod die zelf $.fs.read aanroept, leest je .env ook als Read(.env) geweigerd is. Je permissieregels gelden voor Claude, niet voor de mod.
Gelukkig kun je vooraf zien wat een mod doet zonder hem te draaien: claude plugin validate ./een-mod toont dezelfde regels hooks: en calls: als hierboven. Zie je daar $.http.fetch, $.fs.read of $.process.spawn in een mod die alleen je spinner een kleurtje zou geven? Dan installeer je hem niet. Gaat er iets mis, dan start claude --safe-mode een sessie zonder je eigen aanpassingen. Met "disableAllHooks": true in ~/.claude/settings.json zet je al je geïnstalleerde mods en hooks overal uit. Dan stoppen ook je eigen statusregel en /goal, want die laatste draait op hetzelfde hooksysteem. Ingebouwde mods blijven aan.
Welke schakelaars ik per situatie zou kiezen
Dit is mijn advies, geen meting. Het past bij een ontwikkelaar die alleen of in een klein team in een eigen repository werkt.
| Situatie | Zo zet ik het neer |
|---|---|
| Een codebase die ik niet ken | Plan mode, effort medium, eerst laten uitleggen en pas dan iets laten veranderen |
| Dagelijks bouwen | Auto mode, effort medium, /clear tussen losse taken |
| Een hardnekkige bug | Effort high of ultrathink in de prompt; bij herhaalde mislukking /advisor |
| Een klus met een meetbaar einde | Auto mode plus /goal met een test als bewijs en een beurtenlimiet |
| Een audit of grote migratie | Ultracode, en vooraf vastleggen wat niet mag veranderen |
| Live debuggen terwijl ik zit te wachten | Fast mode, aan het begin van het gesprek aangezet |
| Een repository met productiegevolgen | Manual of auto met deny-regels voor deploy en push, plus een guard-mod als extra laag |
| CI | claude -p met --permission-mode dontAsk en een exacte --allowedTools-lijst |
Fouten die je wilt vermijden
- Denken dat je in manual werkt. Sinds eind september start een interactieve sessie in auto. Kijk naar de statusregel.
- Een grens alleen in het gesprek zetten. "Push niet" werkt tot het gesprek gecomprimeerd wordt. Een
deny-regel blijft staan. defaultModein de projectinstellingen.autoenbypassPermissionsworden daar zonder melding genegeerd. Bijautogeldt dan de ingebouwde standaard, en ook je eigen keuze in~/.claude/settings.jsonvervalt.Shift+Tabop het goedkeuringsscherm van plan mode. Daarmee keur je het plan goed. EerstEsc.- Effort op
maxlaten staan.maxgeldt alleen voor de sessie, maarxhighbewaar je metEnterals standaard. Daarna loopt elke kleine vraag op het dure niveau. - Fast mode halverwege een lang gesprek aanzetten. Je betaalt de hele context opnieuw tegen het fast-tarief.
- Een mod installeren zonder
validate. Het kost tien seconden en laat zien wat de mod aanraakt. - Denken dat je
deny-regels ook voor mods gelden. Ze gelden voor Claude. Zonder Team- of Enterprise-login of managed settings kan een mod er deels omheen. - Op Windows op de sandbox rekenen. Die bestaat daar alleen in WSL2.
Veelgestelde vragen
Welke versie van Claude Code heb ik nodig voor dit alles?
Voor mods 2.1.287 of hoger, voor Code Mode 2.1.323 of hoger. De nieuwste versie op 19 november 2026 is 2.1.328. Controleer met claude --version en werk bij met claude update. Op het stable-kanaal (2.1.311 op dit moment) loop je een paar weken achter.
Is auto mode veilig?
Veiliger dan zonder controle werken, maar niet waterdicht. Een tweede model blokkeert standaard destructieve en riskante acties, zoals force-pushes, git reset --hard, productie-deploys en het versturen van geheimen. Anthropic zegt zelf dat het "does not guarantee safety". Voor wat echt nooit mag, gebruik je deny-regels.
Wat is het verschil tussen een mod en een hook?
Een hook in settings.json is een los shell-commando, HTTP-verzoek of prompt die bij een gebeurtenis draait. Hij kan ja of nee zeggen, argumenten aanpassen of context toevoegen. Een mod is JavaScript of TypeScript dat binnen Claude Code draait. Een mod kan ook tekenen, commando's toevoegen, toolaanroepen herschrijven of vasthouden, en zelf een model aanroepen.
Kan een mod mijn permissieregels omzeilen?
Deels wel. Zonder managed settings of een Team- of Enterprise-login laadt de ingebouwde bewaker niet. Een mod kan dan aanroepen goedkeuren die een PreToolUse-hook blokkeerde, en sommige aanroepen die een deny-regel weigert. Ook met de bewaker kan een mod via zijn eigen API bestanden lezen en programma's starten, buiten je regels om. Installeer alleen mods die je hebt gelezen of waarvan je de maker vertrouwt.
Kost fast mode extra op een Max-abonnement?
Ja. Op Pro, Max, Ultra, Team en Enterprise gaat fast mode altijd van je usage credits af, niet van de limieten in je abonnement, en die credits moeten aanstaan. Met Opus 5.5 kost het $8 per miljoen invoertokens en $40 per miljoen uitvoertokens.
Werkt Code Mode op Windows?
Ja, met de native build en Git for Windows, want de shell-commando's in Claudes scripts draaien in Git Bash. Het werkt onder meer niet in de VS Code-extensie, niet met claude -p en niet via Bedrock of een gateway.
Verder lezen op deze site
- Starten met Claude Code: installatie, abonnement en de eerste sessie
- Claude Code autonoom laten werken: auto mode,
/goalen een nacht zonder toezicht - Claude Code effectief gebruiken: context, CLAUDE.md, subagents en worktrees
- Claude Code voor Windows-onderhoud: hoe de rechten in PowerShell echt werken, met zestien tests
- Herdr, Caprock en ccdeck vergeleken: hulpmiddelen om meerdere Claude-sessies te volgen
- Graphify getest: wat de kennisgraaf van je code ziet en wat niet (november 2026)
Bronnen
Officiële documentatie (Anthropic, geraadpleegd 19 november 2026)
- Choose a permission mode en Configure auto mode
- Model configuration (effort, ultracode, ultrathink)
- Orchestrate subagents at scale with dynamic workflows
- Speed up responses with fast mode
- Escalate hard decisions with the advisor tool
- Keep Claude working toward a goal
- Run tool calls from code with Code Mode
- Fullscreen rendering, Output styles en Checkpointing
- Mods overview, Create a mod en React to events with a mod
- Configure the sandboxed Bash tool
Releases
- Changelog van Claude Code (mods in 2.1.287, Code Mode in 2.1.323,
/goalin 2.1.139, ultracode in 2.1.160) - @anthropic-ai/claude-code op npm (releasedata;
latest2.1.328,stable2.1.311 op 19 november 2026) - Broncode van de ingebouwde mods en voorbeeldmods in claude-code-playground
Eigen test
- De mod
push-guardis geschreven en getest op 19 november 2026 met Claude Code 2.1.328 op Windows 11.claude plugin validateslaagde en/tallyis viaclaude -pgedraaid. In een wegwerp-repository met een lokale bare remote zijn vier pushes uitgevoerd: drie werden geweigerd, één kwam aan. Daarnaast zijn elf commandovarianten tegen de regexen getest. - Manage mods for your organization en Permissions (wanneer de bewaker laadt en wat een mod kan omzeilen)


