Claude Code-functies: subagents, hooks, skills, MCP en achtergrondwerk

Het idee

Claude Code is een harnas, niet alleen een model

Wie Claude Code als slimme autocomplete gebruikt, vraagt iets, leest het antwoord en plakt het terug. Wie de functielaag gebruikt, richt zijn project een keer in en levert daarna alleen nog opdrachten aan: een subagent doet het zoekwerk, een hook draait de linter, een skill bevat de checklist die je anders elke keer opnieuw typt. Het verschil zit niet in het model, maar in alles eromheen. Anthropic verkoopt dat harnas inmiddels ook los als Agent SDK, en dat is het beste bewijs dat het de kern is.

De API-route ernaast

Wil je Claude Code op API-tarief draaien in plaats van op een abonnement, dan reken je per token en rekent Anthropic in dollars, ook vanuit Nederland. Fable 5 kost $10 per miljoen invoertokens en $50 per miljoen uitvoertokens, Opus 5 $5 en $25, Sonnet 5 $2 en $10 (introductieprijs tot en met 31 augustus 2026, daarna $3 en $15) en Haiku 4.5 $1 en $5. Batchverwerking scheelt 50%. Voor dagelijks werk in de terminal is een abonnement vrijwel altijd voordeliger. De uitzondering is geautomatiseerd werk zoals GitHub Actions, want dat draait sowieso op een API-key. De volledige rekensom staat op de pagina over de kosten van Claude Code.

Waar de officiele documentatie staat

De Claude Code-docs zijn verhuisd naar code.claude.com/docs; oude links op docs.claude.com sturen je met een 301 door. Handige gewoonte: plak .md achter een docs-URL en je krijgt de pagina als verbatim markdown terug. Dat is precies wat je aan Claude zelf wilt voeren als je iets wilt laten bouwen op basis van de actuele documentatie in plaats van op wat het model onthouden heeft.

Hoe deze pagina zich verhoudt tot de rest

Installatie en eerste opzet staan op de pagina over installatie, alle commando's en shortcuts op de pagina over commands, en sandboxing, dataretentie en telemetrie op de pagina over privacy. Werk je buiten code, dan is Cowork hetzelfde idee voor kenniswerk: dezelfde agentische aanpak, andere doelgroep.

Denkkracht

Effort, ultracode en output styles: hoe hard Claude nadenkt

Voordat je iets uitbreidt, is er een laag die niets kost om aan te zetten: de knoppen die bepalen hoe diep Claude nadenkt, hoe zelfstandig hij doorwerkt en in welke stem hij antwoordt. Ze schelen meer in resultaat en in tokenverbruik dan de meeste mensen denken, en ze staan los van welk model je draait.

Effort: het niveau waarop hij redeneert

Effort-niveaus sturen adaptief redeneren en lopen van low via medium, high en xhigh naar max. Welke je krijgt hangt af van je model; Opus 4.8 staat standaard op high. Hoger betekent dieper redeneren tegen meer tokens, dus zet het omhoog voor een architectuurbeslissing en omlaag voor opruimwerk. De precieze syntax van /effort en de vlag --effort staat op de pagina over commands.

Extended thinking en het sleutelwoord ultrathink

Extended thinking is het redeneren dat Claude laat zien voordat hij antwoordt. Op modellen met adaptief redeneren is effort de primaire knop en zet je thinking zelf aan of uit. Wil je eenmalig dieper nadenken zonder je sessie-instelling te veranderen, zet dan ultrathink in je prompt. Dat is de goedkoopste manier om een lastig probleem een keer serieus te laten aanpakken.

Ultracode is een instelling, geen effortniveau

Ultracode wordt vaak als het hoogste effortniveau beschreven, maar het is een instelling van Claude Code zelf: hij combineert xhigh-redeneren met automatische orkestratie van dynamic workflows voor substantiele taken. Met ultracode aan wacht Claude niet tot jij om een workflow vraagt, maar plant hij er zelf een per grote taak. Gebruik het voor meerstaps werk en reken op fors hoger tokenverbruik.

Fast mode: sneller, niet slimmer

Fast mode (research preview) maakt Claude Opus tot ongeveer 2,5x sneller tegen hogere kosten per token. De modelkwaliteit blijft gelijk; wat verandert is de API-configuratie eronder. Dit is de knop voor interactief werk waarbij snel itereren en live debuggen belangrijker zijn dan kostenefficientie. Hij werkt niet in de VS Code-extensie.

Doorwerken tot een doel is bereikt

Met een doel-conditie blijft Claude over meerdere beurten doorwerken zonder dat jij elke stap aanstuurt. Een klein, snel model controleert na elke beurt of de conditie gehaald is en wist het doel automatisch zodra dat zo is. Dat werkt alleen bij werk met een verifieerbare eindtoestand, zoals een migratie die klaar is als alle tests slagen. Vereist v2.1.139 of nieuwer.

Output styles: dezelfde agent, andere stem

Een output style past de system prompt aan en verandert daarmee rol, toon en formaat van de antwoorden. Er zijn vier ingebouwde stijlen: Default, Proactive, Explanatory en Learning. Gebruik ze als je telkens dezelfde opmaak wilt, of als je Claude iets anders wilt laten zijn dan een software-engineer. Het commando /output-style bestaat niet meer; je wisselt via /config.

Geheugen

CLAUDE.md, auto memory en checkpoints: wat blijft en wat je terugdraait

Claude Code werkt binnen een contextvenster met een harde grens. Wat je daarin stopt en wat er tussen sessies bewaard blijft, bepaalt of je agent de rode draad vasthoudt of zichzelf elke ochtend opnieuw moet inlezen. Goed context-engineering is hier het verschil, en het kost je een half uur eenmalig werk.

CLAUDE.md: de instructies die jij schrijft

CLAUDE.md zijn markdownbestanden die Claude aan het begin van elke sessie inleest: codeerstandaarden, build-commando's, architectuurkeuzes, alles wat je anders elke keer opnieuw uitlegt. Er zijn vier scopes: managed policy van je organisatie, user in ~/.claude/CLAUDE.md, project in ./CLAUDE.md en lokaal in CLAUDE.local.md voor wat je niet commit. Houd het kort en verplaats procedures naar skills.

Auto memory: de notities die Claude zelf maakt

Auto memory laat Claude tussen sessies zelf dingen vasthouden: build-commando's die werkten, debug-inzichten, jouw voorkeuren. Het staat in ~/.claude/projects/ met een MEMORY.md als index, en daarvan worden de eerste 200 regels of 25KB elke sessie geladen. Het staat standaard aan vanaf v2.1.59. Verwar het niet met het memory-veld van een subagent: dat is een aparte geheugenmap per subagent, die je bewust inricht.

Compaction: ruimte maken zonder de draad kwijt te raken

Compaction comprimeert het gesprek tot een samenvatting om ruimte vrij te maken. Je doet het handmatig of Claude doet het zelf wanneer het nodig is, en de contextweergave laat zien waar je venster naartoe gaat. Een detail dat je gerust mag stellen tegenover collega's: de project-root CLAUDE.md overleeft compaction, want Claude leest die opnieuw in.

Checkpointing en rewind: het vangnet dat geen git is

Checkpointing legt automatisch de staat van je code vast voor elke bewerking. Via het rewind-menu zet je code terug, alleen het gesprek, of allebei, of je vat samen vanaf een gekozen punt. De beperking die je moet kennen: wijzigingen die via bash-commando's zijn gemaakt worden niet getrackt. Checkpoints zijn dus een vangnet binnen je sessie en geen vervanging van versiebeheer.

Subagents

Subagents: zijwerk dat je hoofdgesprek niet vervuilt

Een subagent is een aparte assistent met een eigen contextvenster, een eigen system prompt, eigen toolrechten en eigen permissies. Claude besluit zelf wanneer hij er een inzet, op basis van het description-veld dat jij schrijft. Het resultaat: het zoekwerk, het logs uitpluizen en het researchen gebeurt ergens anders, en in jouw gesprek belandt alleen de samenvatting. Dat is de reden om ze te gebruiken. Niet omdat het slimmer is, maar omdat je context schoon blijft en je dus langer productief door kunt werken zonder te compacten.

Zo maak je er een

Een subagent is gewoon een markdownbestand met YAML-frontmatter in .claude/agents/ (alleen dit project) of ~/.claude/agents/ (al je projecten). Sinds v2.1.198 opent /agents geen interactieve wizard meer: je vraagt Claude het bestand te schrijven of je tikt het zelf. Alleen name en description zijn verplicht.

---
name: release-notes
description: Schrijft Nederlandstalige release notes uit de git log. Gebruik na een merge naar main, niet tijdens ontwikkelwerk.
tools: Read, Grep, Glob, Bash
model: haiku
memory: project
---

Je leest de commits sinds de vorige tag, groepeert ze naar nieuw, verbeterd en opgelost, en schrijft per punt een regel in gewone taal. Geen commit-hashes, geen jargon.

Schrijf de description voor de router, niet voor jezelf

Claude leest alleen de naam en de description als hij besluit of hij delegeert. Zet daar dus in wanneer de subagent wel moet draaien en wanneer niet. "Schrijft release notes" is te vaag; "Gebruik na een merge naar main, niet tijdens ontwikkelwerk" stuurt de keuze. Werkt een subagent niet zoals je hoopt, dan is de description bijna altijd de plek waar je moet zijn.

De ingebouwde subagents

Je hebt er drie zonder iets te installeren. Explore doorzoekt read-only en snel je codebase en slaat daarbij CLAUDE.md over, wat hem goedkoop maakt voor vragen als "waar wordt dit aangeroepen". Plan doet het onderzoek tijdens plan mode, ook read-only. general-purpose krijgt alle subagent-tools en is de standaardkeuze voor werk dat niet in een van de andere twee past. Daarnaast zijn er twee helpers: statusline-setup (op Sonnet) en claude-code-guide (op Haiku).

Achtergrond en geheugen

Subagents op de achtergrond, met geheugen en een eigen werkmap

Drie eigenschappen maken het verschil tussen een subagent die je een keer probeert en een subagent die je elke week gebruikt: hij draait door terwijl jij verder werkt, hij onthoudt wat hij eerder leerde, en hij kan in een eigen kopie van je repo werken zodat hij niets van jou omgooit.

Achtergrond is sinds v2.1.198 het standaardgedrag

Claude zet subagents nu standaard op de achtergrond; met background: true in de frontmatter dwing je het altijd af. Let op een detail dat mensen verrast: een achtergrondsubagent houdt al zijn MCP-tools, maar krijgt van de ingebouwde tools een vaste subset (onder meer Read, Grep, Glob, Bash, Edit, Write, WebFetch en WebSearch). Heeft je subagent iets nodig dat daar niet in zit, dan hoort hij op de voorgrond.

Persistent geheugen: MEMORY.md per subagent

Zet je memory: project, dan krijgt de subagent een map onder .claude/agent-memory/<naam>/ die je via git kunt delen met je team. Dat is de aanbevolen standaard. Met user gaat het naar ~/.claude/agent-memory/<naam>/ en blijft het van jou alleen; local houdt het lokaal en ongedeeld. Bij de start worden de eerste 200 regels of 25KB van MEMORY.md in de system prompt geladen. Praktisch betekent dit: je code-review-subagent onthoudt de afspraken die jullie eerder maakten, in plaats van dat je ze elke keer opnieuw uitlegt.

Isolatie in een eigen worktree

Met isolation: worktree krijgt een subagent zijn eigen git worktree, of je vraagt Claude simpelweg om worktrees voor zijn agents te gebruiken. Maakt de subagent geen wijzigingen, dan wordt de tijdelijke worktree automatisch opgeruimd; een periodieke sweep haalt oudere subagent-worktrees weg. Worktrees die jij zelf met --worktree hebt gemaakt blijven altijd staan.

Een voorbeeld dat blijft plakken

Een reviewer-subagent met memory: project, isolation: worktree en background: true doet dit: je merget een branch, hij draait op de achtergrond in zijn eigen kopie, hij toetst tegen de afspraken in zijn MEMORY.md, en jij ziet een samenvatting zonder dat je gesprek volloopt met bestandsinhoud. Het kost je een bestand van dertig regels.

Hooks

Hooks: afdwingen wat je niet aan het model wilt overlaten

Een instructie in CLAUDE.md is een verzoek. Een hook is een regel. Hooks vuren op vaste momenten in de sessie en draaien code die jij bepaalt, ongeacht wat het model op dat moment van plan is. Claude Code kent er inmiddels ruim dertig, van voor een tool draait tot als een worktree wordt opgeruimd.

Vijf soorten handlers

Een hook kan meer dan een script starten. command draait een shellscript en krijgt JSON op stdin. http doet een POST naar een URL. mcp_tool roept een bestaande MCP-tool aan. prompt laat een model een ja-of-nee-beslissing nemen. agent spawnt een subagent die condities verifieert. De standaardtimeouts verschillen: 600 seconden voor command, http en mcp_tool, 30 seconden voor prompt en 60 seconden voor agent.

Waar je ze zet

In ~/.claude/settings.json voor jezelf, in .claude/settings.json als het hele team hem hoort te hebben (dat bestand commit je), in .claude/settings.local.json voor lokale uitzonderingen die gitignored zijn, in managed policy settings als de organisatie het afdwingt, of in hooks/hooks.json van een plugin. Skills en subagents kunnen daarnaast hooks in hun eigen frontmatter meenemen. De structuur is steeds hetzelfde: event, dan een matcher, dan een array met handlers.

Voorbeeld: rm -rf blokkeren

Het voorbeeld uit de documentatie zelf is een PreToolUse-hook op Bash die commando's met rm -rf weigert. In settings.json ziet dat er zo uit:

"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"handlers": [
{ "type": "command", "command": ".claude/hooks/blokkeer-rm.sh" }
]
}
]
}

Het script leest de tool-input van stdin en geeft via hookSpecificOutput.permissionDecision een van vier antwoorden terug: allow, deny, ask of defer.

Exitcodes: het enige stukje dat je uit je hoofd moet kennen

Exitcode 0 betekent succes, en JSON die je op stdout zet wordt verwerkt. Exitcode 2 is een blocking error: de actie gaat niet door en wat je op stderr schrijft gaat naar Claude, zodat hij weet waarom. Elke andere exitcode is een non-blocking error: er gaat een melding uit, maar het werk loopt door. Vergeet je dat en gebruik je exit 1 om te blokkeren, dan gebeurt er dus niets.

Wat een beheerder kan afdwingen

Met allowManagedHooksOnly blokkeert een organisatie alle user-, project- en pluginhooks, zodat alleen de centraal uitgerolde regels draaien. disableAllHooks zet hooks tijdelijk uit, maar kan managed hooks niet uitschakelen. Handig om te weten als je in een strak beheerde omgeving werkt en je eigen hook niet lijkt te vuren.

Skills

Skills: je eigen werkwijze vastleggen in een map

Een skill is een map met een SKILL.md erin: YAML-frontmatter plus instructies in markdown. Claude laadt hem automatisch als hij relevant is, of jij roept hem aan met /naam. De vuistregel uit de documentatie is prettig concreet: maak een skill zodra je dezelfde instructies of checklist blijft plakken, of zodra een stuk van je CLAUDE.md eigenlijk een procedure is geworden.

Slash commands zijn opgegaan in skills

Dit verwart mensen die oudere gidsen lezen: .claude/commands/deploy.md en .claude/skills/deploy/SKILL.md maken allebei /deploy en werken hetzelfde. Bestaande commands-bestanden blijven dus werken, maar nieuwe dingen bouw je als skill. Skills volgen bovendien de open Agent Skills-standaard (agentskills.io), waardoor dezelfde map ook in andere AI-tools bruikbaar is. Je legt je werkwijze dus niet vast in een productformaat.

Voorbeeld: een release-skill met live context

Skills kunnen shellcommando's uitvoeren voordat ze geladen worden en de uitvoer invoegen. Een regel die begint met een uitroepteken en backticks wordt vervangen door het resultaat. Zo ziet .claude/skills/release/SKILL.md eruit:

---
name: release
description: Zet een release klaar: changelog bijwerken, versie bumpen, tag voorstellen.
disable-model-invocation: true
allowed-tools: Read, Edit, Bash
---

Huidige wijzigingen:
!`git diff HEAD --stat`

Werk CHANGELOG.md bij voor versie $1 in het Nederlands, bump de versie in package.json en stel een tag voor. Commit niets zonder mijn akkoord.

Je roept hem aan met /release 2.4.0. Naast $ARGUMENTS en $1 kun je named arguments gebruiken en de variabelen ${CLAUDE_SKILL_DIR}, ${CLAUDE_PROJECT_DIR} en ${CLAUDE_SESSION_ID}.

De frontmatter die het gedrag bepaalt

description is het veld waar Claude op beslist of hij de skill pakt; samen met when_to_use mag die listing maximaal 1.536 tekens zijn. disable-model-invocation: true betekent dat alleen jij hem mag starten, precies wat je wilt bij deployen of committen. user-invocable: false doet het omgekeerde. Verder zijn er allowed-tools (vooraf goedgekeurd gereedschap), model, effort, context: fork om de skill in een subagent te draaien, agent, hooks en paths om hem te activeren op bestandspatronen.

Houd ze kort en gelaagd

Het advies uit de documentatie is om SKILL.md onder de 500 regels te houden en details in aparte bestanden te zetten die pas gelezen worden als ze nodig zijn. Dat heet progressive disclosure en het scheelt tokens bij elke sessie waarin de skill wel geladen maar niet volledig gebruikt wordt. Wijzig je een skill tijdens je werk, dan pikt Claude Code dat binnen dezelfde sessie op zonder herstart.

De meegeleverde skills

Claude Code brengt zelf skills mee, waaronder /doctor, /code-review, /batch, /debug, /loop, /run, /verify en /claude-api. Sinds v2.1.215 draaien /verify en /code-review alleen nog als jij ze aanroept, dus je krijgt ze niet meer ongevraagd tussendoor. Wil je ze allemaal weg, dan zet disableBundledSkills ze uit, behalve /doctor.

Plugins

Plugins en marketplaces: een uitbreiding die je kunt uitdelen

Skills, hooks en MCP-servers zet je per project neer, en dat werkt prima tot het moment dat je collega hetzelfde wil hebben. Dan wil je een verpakking. Een plugin is precies dat, en samen met de vorige drie mechanismen is het het verschil tussen gestructureerd, herhaalbaar werk en losse vibe-coding.

Wat er in een plugin past

Een plugin bundelt skills, agents, hooks, MCP-servers, LSP-servers en achtergrond-monitors in een zelfstandige map met een plugin.json-manifest. De commando's die eruit komen zijn genaamruimd, dus een plugin kan nooit een naam van jou overschrijven. Dat maakt het de aangewezen vorm voor een geversioneerde uitbreiding die een heel team gebruikt.

Waar plugins vandaan komen

Marketplaces distribueren plugins. Anthropic onderhoudt een curated officiele marketplace die automatisch beschikbaar is zodra je Claude Code start, en daarnaast een community-marketplace waar publieke inzendingen na review in terechtkomen. Je kunt ook een eigen, private marketplace hosten, wat de gebruikelijke route is voor bedrijven die interne tooling niet publiek willen zetten. Welke plugins er concreet in staan en welke de moeite waard zijn, staat op de pagina over skills.

Wanneer je iets als plugin verpakt

De vuistregel is simpel: los in .claude/ zolang het van jou is, plugin zodra iemand anders het ook moet krijgen. Let op een beperking die je pas merkt als je hem raakt: subagents uit een plugin ondersteunen om veiligheidsredenen geen hooks, mcpServers of permissionMode. Wat dat nodig heeft, hoort in het project zelf.

MCP

MCP: je eigen systemen aankoppelen

Met MCP, het Model Context Protocol, geef je Claude Code toegang tot dingen die niet in je repo staan: je issue-tracker, je foutmeldingen, je database, je documentatie. De techniek achter een MCP-server leggen we uit op de pagina over skills en MCP. Hier gaat het om het stuk dat in Claude Code anders werkt: waar een server wordt opgeslagen, wie hem ziet en wie hem moet goedkeuren.

Toevoegen en beheren

Voor een externe server is HTTP de aanbevolen route: claude mcp add --transport http <naam> <url>. De sse-variant bestaat nog maar is deprecated. Een lokale server start je als proces: claude mcp add <naam> -- <commando> [args], en let op de dubbele streepjes, want alles daarna is het commando en niet een vlag voor Claude. WebSocket kan via claude mcp add-json. Beheren doe je met claude mcp list, get en remove, en met /mcp in de sessie, waar je ook de OAuth-flow doorloopt als een server een login vraagt. De scope kies je met -s of --scope.

De goedkeuringsflow van een project-.mcp.json

Een server die in de repo staat draait niet zomaar. Claude Code vraagt je expliciet of je hem vertrouwt, want een .mcp.json uit een repo van iemand anders is code die jij laat starten. Sinds v2.1.196 is dat dichtgetimmerd: een gekloonde repo kan zijn eigen servers niet goedkeuren, dus enableAllProjectMcpServers in een gecommitte .claude/settings.json wordt genegeerd zolang de map niet vertrouwd is. Dat is de juiste standaard, en het is ook de reden dat je bij een nieuwe repo even bewust ja moet zeggen.

Limieten die je in de praktijk raakt

MCP-tooloutput is begrensd op 25.000 tokens, met een waarschuwing vanaf 10.000; verhogen kan met MAX_MCP_OUTPUT_TOKENS. Sinds v2.1.212 wordt een MCP-call in je hoofdgesprek die langer dan twee minuten duurt automatisch een achtergrondtaak, zodat je niet zit te wachten. De opstarttijd van een server regel je met MCP_TIMEOUT. Loopt een koppeling steeds vast bij het opstarten, dan is dat meestal de eerste knop die je omdraait.

De waarschuwing die je serieus moet nemen

De documentatie is er expliciet over: verifieer dat je een MCP-server vertrouwt voordat je verbindt, want servers die externe content ophalen zijn een route voor prompt injection. Anthropic controleert connectors in de Directory tegen listing-criteria, maar voert geen security-audit uit op MCP-servers. In beheerde omgevingen kan een organisatie dit dichtzetten met allowedMcpServers en deniedMcpServers.

Achtergrondwerk

Achtergrondsessies: opdrachten wegzetten en verder werken

Het duurste aan werken met een agent is wachten. Achtergrondsessies halen dat weg: je zet een opdracht weg, je gaat door met iets anders, en je kijkt terug wanneer het uitkomt. Je hebt Claude Code v2.1.139 of nieuwer nodig.

Je bestanden blijven van jou

Elke achtergrondsessie start in je werkdirectory, maar verhuist naar een eigen git worktree onder .claude/worktrees/ zodra hij bestanden gaat bewerken. Daardoor kunnen parallelle sessies elkaars werk niet overschrijven. Wil je dat niet, dan zet je worktree.bgIsolation op "none", maar bedenk dan wel dat twee sessies in hetzelfde bestand kunnen gaan zitten.

Alleen een commando wegzetten

Voor een langlopende build of testrun hoef je geen hele sessie te starten: claude --bg --exec 'npm run test:e2e' zet het commando op de achtergrond. In de agent view doe je hetzelfde door je commando met een uitroepteken te beginnen.

De rekening: tien sessies is ongeveer tien keer quotum

Achtergrondsessies draaien lokaal en verbruiken je limieten proportioneel. Tien parallelle sessies kosten dus ongeveer tien keer zoveel als een. Ze stoppen als je je machine afsluit, maar overleven wel een slaapstand. Een supervisor-proces host de sessies en ruimt processen op die ongeveer een uur niets doen; met Ctrl+T pin je een sessie zodat hij blijft draaien.

Waar dit echt loont

De patronen die in de praktijk werken: een migratie of grote refactor wegzetten terwijl jij aan iets anders werkt, drie oplossingsrichtingen tegelijk laten uitproberen met /fork en daarna de beste houden, of aan het eind van je dag een opruimklus starten en de uitkomst morgen beoordelen. Wat niet werkt: vijf sessies openzetten en dan verbaasd zijn dat je limiet op is.

Opschalen

Agent teams, workflows, loops en routines: voorbij wat in een gesprek past

Een subagent lost zijwerk op en een achtergrondsessie lost wachten op. Daarboven zitten vier opties voor werk dat simpelweg niet in een gesprek past: een codebase-brede audit, een migratie over honderden bestanden, of iets dat elke ochtend moet draaien terwijl jij nog slaapt. Ze lopen op in schaal, in autonomie en in tokenverbruik, dus kies bewust en niet uit nieuwsgierigheid.

Agent teams: meerdere sessies die met elkaar praten

Agent teams zijn experimenteel en staan standaard uit. Een team-lead wijst taken toe en de teammates werken onafhankelijk door, met een gedeelde takenlijst en een mailbox waarmee ze elkaar direct berichten sturen. Het loont bij parallel onderzoek, reviews en werk dat meerdere lagen tegelijk raakt. De rekening ook: de kostenpagina van Anthropic rekent op ongeveer zeven keer het tokenverbruik van een gewone sessie, wat we uitrekenen op de pagina over kosten.

Dynamic workflows: Claude schrijft het orkestratiescript zelf

Een dynamic workflow (research preview, v2.1.154 of nieuwer) is een JavaScript-script dat Claude zelf schrijft om subagents op grote schaal aan te sturen. Het draait op de achtergrond terwijl je sessie vrij blijft, en het plan zit niet in het gesprek maar in code. Dit is de optie voor codebase-brede audits, grote migraties en onderzoek dat gekruisd moet worden. De meegeleverde deep-research-workflow waaiert zoekopdrachten uit, kruiscontroleert bronnen en levert een onderbouwd rapport. Zet je ultracode aan, dan start Claude zo'n workflow uit zichzelf bij elke substantiele taak.

In-sessie loops met /loop

De /loop-skill voert een prompt of slash-commando herhaaldelijk uit binnen je open sessie, op een interval dat jij kiest of in een tempo dat Claude zelf bepaalt. Het is het gereedschap voor pollen: een deploy bewaken tot hij groen is, een pull request babysitten, wachten tot een build klaar is. Twee grenzen: het is sessie-gebonden, en taken verlopen na zeven dagen.

Routines: geplande runs in de cloud

Routines (research preview) zijn opgeslagen Claude Code-configuraties, dus een prompt plus repos plus connectors, die op door Anthropic beheerde cloudinfrastructuur draaien. Ze werken door als je laptop dicht is. Triggeren gaat op een schema (cron, minimaal elk uur), via een API-endpoint of op GitHub-events. Denk aan een wekelijkse dependency-check of een dagelijkse samenvatting van openstaande issues: terugkerend werk waar jij niet bij hoeft te zijn.

Worktrees

Worktrees: parallel werken zonder dat het een puinhoop wordt

Een git worktree is een tweede werkmap van dezelfde repo, op een eigen branch. Claude Code maakt en beheert ze voor je, en dat is de basis onder bijna alles wat parallel draait: achtergrondsessies, geisoleerde subagents en drie terminals naast elkaar.

Starten in een eigen worktree

Met claude --worktree <naam> (of -w) maakt Claude Code een worktree onder .claude/worktrees/<naam>/ op een nieuwe branch worktree-<naam> en start het daar. Geef je geen naam, dan genereert hij er een. Open je drie terminals met drie namen, dan heb je drie sessies die elkaar niet raken. Tip uit de documentatie: zet .claude/worktrees/ in je .gitignore.

Waar de nieuwe branch vandaan komt

Standaard vertakken nieuwe worktrees van de default branch op de remote, de instelling worktree.baseRef met waarde "fresh". Wil je juist verder op waar je nu staat, dan zet je hem op "head". Met claude --worktree "#1234" check je een pull request uit in een eigen worktree, wat het reviewen van andermans werk een stuk minder omslachtig maakt.

Je .env meenemen

Het probleem met een verse worktree is dat gitignored bestanden er niet in staan, en dat is precies waar je .env of je lokale configuratie zit. Daar is een .worktreeinclude-bestand voor: dezelfde syntaxis als .gitignore, en wat je erin zet wordt automatisch gekopieerd naar elke nieuwe worktree. Zonder dat bestand loop je bij elke nieuwe worktree tegen dezelfde vijf minuten opstartwerk aan.

Opruimen gaat vanzelf, behalve die van jou

Worktrees die Claude aanmaakt voor een subagent worden verwijderd als de subagent niets wijzigde, en een periodieke sweep haalt oudere subagent-worktrees weg. Worktrees die jij met --worktree hebt gemaakt worden nooit automatisch opgeruimd, dus die verwijder je zelf als je klaar bent.

Claude Code op het web

Claude Code in de browser: cloudsessies die doorlopen zonder jouw laptop

Op claude.ai/code draait Claude Code als cloud-agent op door Anthropic beheerde VM's. Het staat als research preview open voor Pro, Max en Team, en voor Enterprise met premium seats of met Chat plus Claude Code-seats. Sluit je je browser, dan loopt de sessie door, en via de Claude-app op je telefoon kijk je mee.

Van je terminal naar de cloud en terug

Met claude --cloud "los de falende tests op deze branch op" start je vanaf je terminal een cloudsessie; die kloont je GitHub-remote op je huidige branch. Andersom haal je met claude --teleport of /teleport een cloudsessie naar je terminal, inclusief branch en gesprekshistorie. Let op: die CLI-overdracht gaat een kant op (van web naar terminal). De desktop-app kan wel een lokale sessie naar het web sturen. Een werkbare gewoonte is dan ook plan locally, execute remotely: je maakt het plan in plan mode op je eigen machine en zet de uitvoering in de cloud.

Wat er in de sandbox wel en niet kan

Elke cloudsessie draait in een eigen geisoleerde VM. Netwerktoegang is standaard beperkt en kan helemaal uit. Je git-credentials en signing keys komen nooit in de sandbox: authenticatie loopt via een secure proxy met scoped credentials, en pushen kan alleen naar de werkbranch. Alle operaties worden gelogd voor audit en VM's die niets doen worden opgeruimd.

Auto-fix op een pull request

Auto-fix laat Claude een PR bewaken en zelf reageren op CI-failures en review comments. Je hebt de Claude GitHub App nodig, en je zet het aan via de CI-statusbalk op web, met /autofix-pr in de terminal of vanuit de mobiele app. Een waarschuwing die de documentatie zelf geeft en die je makkelijk over het hoofd ziet: de reacties van Claude verschijnen onder jouw GitHub-account (gelabeld als Claude Code) en kunnen dus automatisering activeren die op comments reageert, zoals Atlantis.

De randvoorwaarden op een rij

Cloudsessies delen je limieten met al je andere Claude-gebruik en parallelle taken verbruiken dus meer; er is geen aparte compute-kost voor de VM. GitHub is vereist voor klonen en pull requests. GitLab en Bitbucket kunnen alleen als lokale bundel van maximaal 100 MB en dan zonder terugpushen. Organisaties met Zero Data Retention kunnen geen cloudsessies gebruiken.

Twee open punten voor Nederlandse gebruikers

We noemen ze liever dan dat we ze invullen. Ten eerste: de documentatie noemt geen regiobeperkingen voor de research preview, maar expliciete beschikbaarheid in de EER is nergens officieel bevestigd. Ten tweede: in welke regio de cloud-VM's draaien staat niet in de documentatie. Heb je harde eisen aan dataresidentie, kijk dan naar trust.anthropic.com of draai via Amazon Bedrock of Google Cloud in een EU-regio. Ook concrete getallen (hoeveel cloudsessies tegelijk, welke VM-specificaties, hoe lang een sessie blijft staan) geeft Anthropic niet.

Buiten de terminal

Editor, desktop, Slack, browser en scherm: waar Claude Code nog meer draait

De terminal is de thuisbasis, niet de grens. Dezelfde agent draait in je editor, in een desktop-app, vanuit een Slack-thread, in je browser, op je scherm en op je telefoon. Dat is geen verzameling losse producten: het is steeds dezelfde sessie-architectuur, met per omgeving een andere manier om erbij te komen.

Editor en desktop

De VS Code-extensie geeft je inline diffs, @-mentions van bestanden met regelbereik, plan-review met inline commentaar, gespreksgeschiedenis en meerdere sessies in tabs (VS Code 1.98.0 of nieuwer); de extensie bevat de CLI. De JetBrains-plugin werkt in IntelliJ, PyCharm, WebStorm, GoLand en meer, met een sneltoets om te starten, diffs in de IDE-viewer, automatisch delen van je selectie en diagnostics. De Desktop-app (macOS en Windows, niet Linux) heeft een Code-tab naast Chat en Cowork: parallelle sessies met git-isolatie via worktrees, panes voor chat, diff, preview, terminal en editor, visuele review met inline commentaar, app-previews in een ingebouwde browser, PR-monitoring door CI en optioneel computer use. Via Dispatch start je vanaf je telefoon een sessie die daar verschijnt.

Slack, Channels en Remote Control: werk aansturen zonder terminal

Claude in Slack is stabiel: noem @Claude met een coding-verzoek in een channel of thread, dan start hij een Claude Code on the web-sessie, haalt context uit de thread, post voortgang terug in Slack en maakt desgewenst een pull request aan. Het vereist een Pro-, Max-, Team- of Enterprise-plan met toegang tot Claude Code op het web en een gekoppeld GitHub-account met minstens een geauthenticeerde repository. Channels (research preview, v2.1.80 of nieuwer) draait het om: een MCP-server pusht externe events je draaiende sessie in, zodat Claude reageert terwijl jij weg bent. Meegeleverd zijn Telegram, Discord en iMessage, en je kunt webhook-ontvangers bouwen voor CI, error-tracking of deploys. Je installeert een channel als plugin en zet hem per sessie aan met --channels; niet beschikbaar op Bedrock, Vertex AI of Foundry, en Team- en Enterprise-organisaties moeten het expliciet inschakelen. Met Remote Control (research preview, v2.1.51 of nieuwer) verbind je claude.ai of de Claude-app met een sessie op jouw machine, zodat je vanaf je telefoon verder werkt terwijl je lokale bestanden en MCP-servers beschikbaar blijven.

Claude in Chrome tegenover computer use

Deze twee worden constant door elkaar gehaald. Claude in Chrome (beta) koppelt Claude Code aan de browserextensie en geeft browser-automatisering vanuit de CLI (--chrome of /chrome) of de VS Code-extensie: console-errors en DOM-staat lezen om live te debuggen, formulieren invullen, data extraheren, geauthenticeerde web-apps als Gmail, Notion of Google Docs bedienen via je gedeelde login-state, en een interactie opnemen als demo-GIF. Het werkt in Google Chrome en Microsoft Edge en niet via Bedrock, Vertex AI of Foundry. Computer use (research preview op macOS, Pro en Max, v2.1.85 of nieuwer, alleen in een interactieve sessie) bestuurt juist je echte scherm: native apps openen, klikken, typen en screenshots maken, bijvoorbeeld om een Swift- of Electron-app te bouwen en door te klikken of de iOS Simulator aan te sturen. Je zet het aan via de ingebouwde computer-use MCP-server met per-app-goedkeuring en een Esc-noodstop, en het valt buiten de bash-sandbox. Niet beschikbaar op Team of Enterprise, en niet via third-party providers. Kort: browserwerk is Chrome, alles wat alleen op je desktop kan is computer use.

Ultraplan, Ultrareview en managed Code Review

Drie functies die cloudcapaciteit gebruiken voor werk dat je normaal lokaal doet. Ultraplan (research preview, v2.1.91 of nieuwer) geeft een planningstaak vanuit je lokale CLI door aan een web-sessie in plan mode: Claude plant in de cloud terwijl je terminal vrij blijft, je geeft inline commentaar in je browser en kiest daarna uitvoeren op het web of teleporten naar je terminal. Ultrareview (research preview, v2.1.86 of nieuwer) is een diepe multi-agent review waarbij elke bevinding onafhankelijk wordt gereproduceerd en geverifieerd; je roept hem aan als /code-review ultra (alias /ultrareview) en Pro- en Max-gebruikers krijgen drie gratis runs, daarna betaal je per review met usage credits. Code Review (research preview, Team en Enterprise) is de beheerde variant die GitHub pull requests automatisch reviewt met een fleet agents op Anthropic-infrastructuur en bevindingen als inline comments plaatst, getagd op severity (Important, Nit, Pre-existing) zonder de PR te blokkeren. Het triggert bij het openen van een PR, bij elke push of via @claude review, je stuurt het met CLAUDE.md of REVIEW.md, en het kost gemiddeld ongeveer 15 tot 25 dollar per review via usage credits. Niet beschikbaar bij Zero Data Retention.

GitLab en headless: dezelfde agent zonder mens erbij

Naast GitHub Actions is er een GitLab CI/CD-integratie (beta, onderhouden door GitLab en gebouwd op de CLI en de Agent SDK): je voegt een job toe aan .gitlab-ci.yml plus een gemaskeerde ANTHROPIC_API_KEY-variabele, waarna Claude merge requests maakt uit issues of comments, bugs fixt en features bouwt in geisoleerde runners, met providerkeuze tussen de Claude API, Bedrock en Vertex AI. Wil je zelf scripten, dan draait headless mode Claude Code niet-interactief met de print-vlag: een prompt erin, het antwoord eruit, met keuze uit outputformaten, gevalideerde JSON-output via een schema, een toolallowlist en een minimale modus die auto-discovery overslaat voor snelheid.

GitHub Actions

GitHub Actions: Claude als teamlid in je pull requests

Noem @claude in een issue of pull request en Claude analyseert de code, implementeert een feature, fixt een bug of maakt een PR aan. Dit is het stuk van Claude Code dat draait zonder dat er iemand achter een terminal zit, en daarmee ook het stuk waar je het scherpst moet nadenken over rechten en kosten.

Wat het kost

Twee posten: de GitHub Actions-minuten van de runner en de API-tokens per interactie. Anthropics eigen optimalisatietips zijn de moeite waard omdat ze allebei raken: geef specifieke @claude-opdrachten in plaats van vage, begrens het aantal beurten met --max-turns in claude_args, zet workflow-timeouts en gebruik concurrency-limieten zodat tien comments niet tien parallelle runs starten.

Op je eigen infrastructuur

Voor organisaties die geen statische API-keys in GitHub willen: de action kan draaien via Amazon Bedrock of Google Cloud met OIDC en Workload Identity, dus met kortlevende credentials in plaats van een sleutel in je repository secrets. Dat is meestal ook het antwoord op de vraag van je security-collega over waar de data langskomt.

Waar de grens ligt

Auto-fix (op de webversie) en de GitHub Action lijken op elkaar maar zijn niet hetzelfde: auto-fix hoort bij Claude Code op het web en draait op je abonnement, de Action draait in jouw CI op een API-key. Wil je alleen dat falende CI wordt opgepakt, begin dan met auto-fix. Wil je Claude als reviewer of implementeerder in je repo, dan is de Action de route.

Agent SDK

De Agent SDK: hetzelfde harnas, nu als library

De Claude Agent SDK geeft je precies wat Claude Code zelf gebruikt: dezelfde tools, dezelfde agent loop en hetzelfde contextbeheer, maar dan als library die je in je eigen software zet. Er is een Python- en een TypeScript-versie.

Wat je meekrijgt

Alles wat je uit de CLI kent is beschikbaar: de ingebouwde tools, hooks, subagents, MCP, het permissiesysteem, sessies, skills, commands, memory en plugins. Je bouwt er dus geen agent van nul, je hangt je eigen logica aan een agent die al werkt. Werk je in een andere taal dan Python of TypeScript, dan is de aangeraden route de CLI als subprocess draaien met -p en --output-format json.

Voorbeeld: een agent die zelf tickets oppakt

Een concreet patroon dat bedrijven bouwen: een dienst die bij een nieuw supportticket de SDK aanroept met een subagent voor onderzoek in de codebase, een MCP-koppeling naar de ticketsoftware en een hook die alles logt in je eigen systeem. De agent stelt een oplossing voor, een mens keurt goed. De SDK is hier de bedrading; het denkwerk zit in de skill die je meegeeft.

De voorwaarden waar je op moet letten

Twee regels waar bedrijven overheen lezen. Ten eerste mag je zonder voorafgaande goedkeuring geen claude.ai-login of claude.ai-limieten aanbieden in een product op de SDK: je gebruikers authenticeren via een API-key. Ten tweede is er een brandingregel: Claude Agent of Powered by Claude mag, maar je mag je product niet Claude Code noemen. Gebruik valt onder de Commercial Terms van Anthropic.

Permissies

Permissiemodi: hoeveel vrijheid geef je de agent?

De permissiemodus is ook een functie, want hij bepaalt hoe snel je werkt en hoe vaak je wordt onderbroken. Er zijn er zes. Je wisselt tijdens je werk met Shift+Tab of je start met --permission-mode. De bash-sandbox, dataretentie en telemetrie behandelen we uitgebreid op de pagina over privacy.

Plan mode is de modus die je het vaakst zou moeten gebruiken

In plan mode leest Claude je bestanden en verkent hij commando's, maar hij raakt je source niet aan. Als het plan er ligt kies je onder meer voor "Yes, and use auto mode", voor "Yes, manually approve edits", of je laat hem doorplannen. Activeren doe je met Shift+Tab, met een /plan-prefix of met claude --permission-mode plan. Het scheelt je meer herstelwerk dan welke andere instelling ook.

Wat auto mode wel en niet tegenhoudt

Auto mode laat Claude doorwerken zonder routineprompts, maar zet er een tweede model naast: een classifier (standaard Claude Sonnet 5) beoordeelt elke actie en blokkeert onder meer curl-naar-bash, force push, deploys naar productie, het naar buiten sturen van secrets, terraform destroy en het mergen van pull requests die geen mens heeft goedgekeurd. Na drie blokkades achter elkaar of twintig in totaal pauzeert auto mode en komen de prompts terug. Die classifier-calls tellen mee in je tokenverbruik, dus auto mode is niet gratis.

Paden die nooit automatisch worden goedgekeurd

Schrijfacties naar beschermde paden worden buiten bypassPermissions nooit automatisch goedgekeurd: onder meer .git, .claude (behalve .claude/worktrees), .vscode, .idea, .husky en .devcontainer, plus bestanden als .bashrc, .zshrc, .npmrc, .mcp.json en .pre-commit-config.yaml. Een allow-rule in je settings kan die bescherming niet omzeilen. Dat is precies waarom je een hook nodig hebt als je nog verder wilt gaan.

Over --dangerously-skip-permissions

De modus bypassPermissions slaat prompts en veiligheidschecks over. De officiele lijn is duidelijk: gebruik hem alleen in een geisoleerde container of VM zonder internettoegang, want hij beschermt je niet tegen prompt injection. Claude Code weigert de modus als je als root of via sudo draait op Linux en macOS, en rm -rf op / of ~ vraagt altijd om bevestiging als laatste noodrem. Beheerders zetten hem uit met disableBypassPermissionsMode.

Keuzehulp

Welke functie los welk probleem op?

Het risico van een pagina als deze is dat je alles tegelijk wilt gaan gebruiken. Doe dat niet. Kies de functie die bij je huidige ergernis past, en voeg pas iets toe als de vorige stap gewoonte is geworden.

Wat wij teams zien doen

In onze trainingen zien we hetzelfde patroon: de winst zit zelden in de exotische functies, maar in twee of drie skills die de manier van werken van het team vastleggen en in een handvol hooks die voorkomen dat er rommel in de repo komt. Wil je dat met je eigen team opzetten in plaats van het zelf uit te zoeken, dan is dat precies wat we doen in de Claude Code-training.