Standaard is Claude Code al een capabele pair programmer: hij leest je bestanden, draait je commando’s en schrijft code. Maar een kale setup behandelt elke repository op dezelfde manier. Hij weet niet dat jij in Release bouwt, dat je solution-bestand verboden terrein is, dat “maak een PR” een heel specifieke dans met je source-control-host betekent, of dat je team een harde regel heeft om nooit naar de integratiebranch te committen.

Het verschil tussen Claude-als-autocomplete en Claude-als-collega is configuratie. En medio 2026 — het Opus 4.8-tijdperk — is het oppervlak voor die configuratie breed: gelaagd geheugen, deterministische hooks, een open Agent Skills-standaard, een plugin-marketplace, MCP-servers en first-class git worktrees.

Deze gids loopt elke laag langs in de volgorde waarin je hem zou moeten opbouwen, met generieke, kopieerbare voorbeelden plus aantekeningen over hoe wij elke laag toepasten op een grote .NET-codebase (Clean Architecture, EF Core, CQRS, Azure DevOps voor source control).

Docs verhuisd. De canonieke Claude Code-documentatie staat nu op code.claude.com/docs/en (de oude docs.claude.com/en/docs/claude-code/*-URL’s 301-redirecten daarheen). Alle links in deze post wijzen naar de nieuwe host.

Het mentale model: het harnas heeft lagen

Anthropic vat de uitbreidbaarheid van Claude Code op als een kleine set “extension points”, en de volgorde waarin je ze adopteert doet ertoe. Hun richtlijn voor grote codebases zet ze ongeveer zo neer:

  1. CLAUDE.md — altijd-aanwezige context en instructies.
  2. Hooks — deterministische automatisering die elke keer afgaat, zonder uitzondering.
  3. Skills — verpakte, herbruikbare expertise die alleen laadt wanneer relevant.
  4. Plugins — een manier om een werkende setup te bundelen en naar een team te distribueren.
  5. MCP-servers — verbindingen met je interne tools, data en API’s.
  6. Subagents — geïsoleerde context-windows voor exploratie of review.

Onder al deze lagen ligt één beperking die zo’n beetje elke best practice verklaart die je tegenkomt:

“Claude’s context window fills up fast, and performance degrades as it fills.”

— Claude Code best practices

Lees dat als de stelling van deze hele post. Elke laag hieronder is in de kern een manier om de juiste context op het juiste moment voor het model te krijgen — en al het andere eruit te houden. Een CLAUDE.md die alles probeert te zeggen, zegt uiteindelijk niets; een skill die alleen laadt wanneer hij wordt aangeroepen kost je bijna niets tot je hem nodig hebt. Houd “geef context bewust uit” in gedachten en de ontwerpkeuzes in elke laag gaan vanzelf logisch voelen.

Laag 1 — CLAUDE.md en geheugen

Begin hier, want het is het goedkoopste met de meeste hefboomwerking. Sinds 2026 zijn er eigenlijk twee geheugensystemen, en het loont om ze uit elkaar te houden.

CLAUDE.md schrijf je zelf: instructies, regels, conventies — laadt elke sessie. Auto memory schrijft Claude: leerpunten en patronen die hij over sessies heen verzamelt (sinds v2.1.59), opgeslagen onder ~/.claude/projects/<project>/memory/ met een MEMORY.md-index.

Beide laden aan het begin van een gesprek. Belangrijk: Claude behandelt ze als context, niet als afgedwongen configuratie — als je wilt dat iets gebeurt ongeacht wat het model beslist, is dat het werk van een hook (Laag 2), niet van een regel in CLAUDE.md.

Aan de slag

Draai /init in je project om een start-CLAUDE.md te genereren en snoei hem daarna. De bestanden laden in een hiërarchie, van breed naar meest specifiek:

ScopeLocatieGedeeld met
User~/.claude/CLAUDE.mdAlleen jij, alle projecten
Project./CLAUDE.md of ./.claude/CLAUDE.mdTeam, via source control
Local./CLAUDE.local.md (zet in gitignore)Alleen jij, dit project
ManagedOS-niveau policy-padHele organisatie

Claude loopt vanaf de plek waar je hem startte de directory-boom omhoog en plakt elke CLAUDE.md die hij vindt aan elkaar, dus een bestand in een submap laadt alleen wanneer Claude daadwerkelijk in die submap werkt. Dat is de sleutel om het root-bestand slank te houden: duw gespecialiseerde richtlijnen omlaag naar waar ze relevant zijn.

Je kunt andere bestanden inladen met de @-importsyntaxis (tot vier hops diep), en een nieuwere toevoeging — .claude/rules/ — laat je regels scopen op file-globs via frontmatter, zodat ze alleen in context komen wanneer Claude matchende paden aanraakt:

---
paths:
  - "src/Api/**/*.cs"
  - "src/**/*.cs"
---
# API-ontwikkelregels
- Elk endpoint valideert input met de gedeelde FluentValidation-validator.
- Log nooit request-bodies; die kunnen PII bevatten.

Eentje schrijven die werkt

De officiële lakmoesproef is de beste redactieregel die ik ken:

“Would removing this cause Claude to make mistakes? If not, cut it.”

Neem op wat Claude niet kan afleiden: build-commando’s en flags, test-runners en hoe je ze filtert, codestijl die afwijkt van de taalstandaard, branch/PR-etiquette en de echt niet-voor-de-hand-liggende valkuilen. Laat weg wat afleidbaar is uit de code, standaardconventies, lange API-docs (link ernaar) en bestand-voor-bestand-rondleidingen. Houd het onder ruwweg 200 regels; Anthropic is bot over de faalmodus:

“Bloated CLAUDE.md files cause Claude to ignore your actual instructions!”

Hoe wij het deden. Op ons .NET-platform draagt de root-CLAUDE.md de dingen die je bijten als je ze niet weet: bouw altijd met de Release-configuratie zodat je de Debug-lockbestanden van een developer niet kapotmaakt; sluit integratietests (getagd met een category-trait) altijd uit van solution-brede runs; push nooit direct naar de integratiebranch — branch en open een PR. Daarna krijgt elk groot gebied zijn eigen geneste CLAUDE.md — de data/persistentielaag documenteert de mechaniek van EF Core-migraties, het testproject documenteert conventies, het legacy webportaal documenteert zijn on-prem hosting-eigenaardigheden. Niets daarvan hoort in het root-bestand, want Claude heeft het alleen nodig wanneer hij daadwerkelijk in die gebieden werkt.

We leunen ook op auto memory voor het cross-sessie “littekenweefsel”: bevestigde oorzaken van lastige bugs, beslissingen die zijn geschrapt en waarom, het feit dat een bepaalde CLI op deze machine wel beschikbaar is ondanks de eerste indruk. De MEMORY.md-index houdt elk daarvan op één regel zodat de opstartkosten minimaal blijven.

Laag 2 — Hooks als guardrails

CLAUDE.md is advies. Hooks zijn wet. Een hook is een shell-commando (of, nieuwer, een HTTP-call, een prompt of een agent-evaluatie) dat Claude Code op een gedefinieerd punt in de levenscyclus draait — en sommige van die punten kunnen blokkeren wat er staat te gebeuren. Anthropic verwoordt het zo:

“Use hooks for actions that must happen every time with zero exceptions.”

De levenscyclus is flink gegroeid voorbij de oorspronkelijke negen events; er zijn er nu zo’n twee dozijn, waaronder PreToolUse, PostToolUse, PostToolUseFailure, UserPromptSubmit, SessionStart, Stop, SubagentStop, PreCompact en worktree/config-change-events. Voor guardrails grijp je het vaakst naar PreToolUse, die afgaat vóór een tool draait en hem kan weigeren.

Hooks configureer je in settings.json. Een blokkerende hook eindigt ofwel met code 2 (de stderr wordt als reden teruggevoerd naar Claude) ofwel print een gestructureerde beslissing op stdout. Hier is een generieke guardrail die edits aan gevoelige bestanden weigert:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": ".claude/hooks/block-protected-files.sh",
            "timeout": 5
          }
        ]
      }
    ]
  }
}

…waarbij het script de tool-input inspecteert en non-zero eindigt voor paden die je wilt beschermen. De nieuwere JSON-vorm is expressiever — je kunt permissionDecision: "deny" met een reden teruggeven, of zelfs "ask" om een prompt af te dwingen:

{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "deny",
    "permissionDecisionReason": "Solution- en lockbestanden worden alleen met de hand bewerkt."
  }
}

Een mooi detail: je hoeft deze niet met de hand te schrijven. Je kunt het Claude laten doen — “schrijf een hook die dotnet format draait na elke file-edit”, of “blokkeer schrijfacties naar de Migrations-map” — en hij genereert en bedraadt de config. Bekijk wat actief is met /hooks.

Nieuw in 2026. Naast command ondersteunen hooks nu http (roep een service aan), prompt (laat een model een voorwaarde evalueren en een beslissing teruggeven) en agent (delegeer de check aan een subagent). Een Stop-hook met een prompt-evaluator is een populaire manier om “beëindig de beurt niet tot de tests slagen” af te dwingen.

Hoe wij het deden. Onze meest waardevolle hook is een PreToolUse-guard op Write|Edit die edits blokkeert aan het solution-bestand, het centrale package-management-bestand (Directory.Packages.props) en lockbestanden. Die worden geregenereerd of zijn bewust met de hand gecureerd, en een te gretige edit daar veroorzaakt verwarrende build-breakage. Met de hook op zijn plek kán het simpelweg niet per ongeluk gebeuren — en omdat hij deterministisch is, hoeven we de regel niet in proza te herhalen en te hopen dat hij blijft hangen. Dat is het hele punt van de laag: de dingen die nooit mogen gebeuren worden afgedwongen door code, niet door reminders.

Laag 3 — Skills, slash-commando’s en subagents

Deze laag zag de grootste verandering van het afgelopen jaar. Custom slash-commando’s en Skills zijn samengevoegd. Een bestand op .claude/commands/deploy.md en een skill op .claude/skills/deploy/SKILL.md maken allebei een /deploy-commando en gedragen zich hetzelfde. Oude commando-bestanden werken nog, maar Skills zijn nu het aanbevolen auteursmodel — en eind 2025 werd Agent Skills een open standaard (gelanceerd 16 oktober 2025; opengesteld 18 december 2025), net zoals MCP dat werd.

Anatomie van een skill

Een skill is een map met een SKILL.md-startpunt plus eventuele ondersteunende bestanden. De frontmatter bepaalt wat het is en wie het mag aanroepen:

---
name: create-pr
description: Open een pull request met ons standaardtemplate en checks.
argument-hint: "[target-branch]"
allowed-tools: Bash(git:*), Write
disable-model-invocation: false
---
Open een pull request voor de huidige branch.

## Stappen
1. Vat de diff tegen $0 samen.
2. Draai de testsuite en bevestig dat hij slaagt.
3. Maak de PR met het team-template.

Twee dingen om te benoemen voor wie oudere muscle memory heeft: argument-indexering is nu 0-based ($0 is het eerste argument, $1 het tweede), naast $ARGUMENTS voor de hele string; en je kunt live context injecteren met de !`command`-syntaxis, die een shell-commando draait en de output substitueert nog voordat Claude de prompt ziet.

Progressive disclosure — waarom dit schaalt

Bij het opstarten laden alleen de naam en beschrijving van elke skill in context (standaard een klein budget). De volledige body laadt pas wanneer de skill wordt aangeroepen, en ondersteunende bestanden (reference.md, scripts) laden pas wanneer Claude de links volgt. Zo kost een referentiedocument van 2.000 regels je bijna niets tot het moment dat het nodig is. Dit is hetzelfde “geef context bewust uit”-principe uit Laag 1, maar dan toegepast op expertise in plaats van regels.

Skills kun je op twee manieren aanroepen: expliciet door jou (/create-pr) of automatisch door Claude wanneer je description matcht met de taak. Voor workflows met bijeffecten die je zelf wilt triggeren, zet je disable-model-invocation: true zodat Claude ze niet uit zichzelf kan afvuren.

Subagents — geleende context

Een subagent draait in zijn eigen context window met zijn eigen toegestane tools en zijn eigen system prompt. Ze staan in .claude/agents/ als markdown-bestanden met frontmatter:

---
name: query-auditor
description: Reviewt data-access-code op performance- en correctheidsproblemen.
tools: Read, Glob, Grep, Bash
model: sonnet
---
Je bent een database-query-reviewer. Inspecteer de gewijzigde data-access-code
op N+1-patronen, ontbrekend async-gebruik en onjuist EF Core-tracking-gedrag.
Rapporteer bevindingen met bestand- en regelverwijzingen.

(Let op: de tool die subagents spawnt is in v2.1.63 hernoemd van Task naar Agent; Task werkt nog als alias.) Het klassieke patroon met hoge waarde is de writer/reviewer-split: laat één sessie schrijven en laat daarna een verse subagent reviewen. Een schone context is niet bevooroordeeld richting de code die hij net produceerde, dus hij vangt dingen die de auteur mist.

Hoe wij het deden. Onze skills coderen de rituelen die makkelijk subtiel fout gaan: een PR openen tegen een niet-GitHub source-control-host met de juiste CLI en template, een gestructureerde intake voor nieuw werk starten, een review-pass draaien met onze conventies ingebakken. Elk beperkt zijn tools via allowed-tools, zodat een documentatie-commando niet ineens willekeurige shell kan gaan draaien. We houden ook een speciale subagent voor het auditen van EF Core-queries — een gefocuste, vooral-lezende reviewer die we vóór de merge op een branch-diff richten. Omdat hij zijn eigen context heeft, kan hij breed lezen zonder de hoofdsessie te vervuilen.

Laag 4 — MCP-servers

Het Model Context Protocol is hoe Claude Code buiten je repository reikt — naar je cloud-provider, je docs, een browser, je ticketsysteem. Een server toevoegen is een one-liner; HTTP is het aanbevolen transport voor remote servers, en stdio voor lokale:

# Remote HTTP-server
claude mcp add --transport http notion https://mcp.notion.com/mcp

# Lokale stdio-server (flags vóór de naam, dan -- vóór het commando)
claude mcp add --transport stdio --env API_KEY=xxx mytool -- npx -y my-mcp-server

Servers hebben drie scopes: local (alleen dit project, alleen jij), project (gecommit naar .mcp.json en gedeeld met het team) en user (al je projecten). Een project-.mcp.json ondersteunt environment-variabele-expansie, zodat je de bedrading kunt delen zonder de secrets te delen:

{
  "mcpServers": {
    "api-server": {
      "type": "http",
      "url": "${API_BASE_URL:-https://api.example.com}/mcp",
      "headers": { "Authorization": "Bearer ${API_KEY}" }
    }
  }
}

Tool Search staat standaard aan. Om te voorkomen dat tientallen MCP-tools je context-budget opeten, defert Claude Code ze nu: alleen hun namen laden vooraf, en een ToolSearch-mechanisme haalt de volledige schema’s on demand op (het heeft een Claude 4-klasse model nodig). Als je tools hebt gezien die “deferred” of “still connecting” heten bij het starten van een sessie, dan is dit aan het werk. Je kunt een server uitzonderen met alwaysLoad: true als hij echt direct aanwezig moet zijn.

Een waarschuwing die Anthropic zelf opwierp bij de lancering van de officiële plugin-directory in mei 2026: elke server die je toevoegt kost context en draagt vertrouwensimplicaties. Geef de voorkeur aan gecheckte servers en draai er geen die je niet echt gebruikt. De community-versie van dit advies is bot en klopt: “the plugin you don’t add is the plugin you don’t have to debug.”

Hoe wij het deden. We zetten een kleine, bewuste set servers aan via enabledMcpjsonServers: onze lokale orchestratie-tool (zodat Claude live traces en logs van de draaiende app kan lezen), de MCP-server van onze cloud-provider (resource-lookups, diagnostiek) en de officiële documentatieserver (zodat framework-vragen geaard worden in actuele docs in plaats van de training-cutoff van het model). Drie servers, elk verdient zijn plek. We hielden de neiging in om alles te bedraden wat zou kunnen verbinden — dat is alleen maar context-belasting en meer oppervlak om te vertrouwen.

Laag 5 — Worktrees en parallel werken

Zodra Claude echt werk doet, wil je meer dan één taak tegelijk hebben lopen zonder dat ze op elkaar trappen. Git worktrees zijn nu first-class. De kop is een enkele flag:

claude --worktree feature-auth     # of: claude -w feature-auth
claude --worktree                  # genereert automatisch een naam
claude --worktree "#1234"          # branch vanaf een PR

Standaard landen deze in .claude/worktrees/<naam>/ op een dedicated branch, en schone worktrees worden automatisch opgeruimd als je klaar bent. Twee configuratiepunten zijn het kennen waard. .worktreeinclude is een bestand in de project-root (gitignore-syntaxis) dat anderszins niet-getrackte bestanden opsomt om naar elke nieuwe worktree te kopiëren — zo krijg je je appsettings.Development.json of lokale secrets in een geïsoleerde workspace zonder ze te committen. En worktree.baseRef in settings laat je kiezen of worktrees aftakken van een verse origin/HEAD of je huidige lokale HEAD.

Je kunt Claude ook midden in een sessie vragen om “in een worktree te werken” (hij gebruikt dan een EnterWorktree-tool), en subagents kun je isolation: worktree meegeven zodat een vloot van hen parallel bestanden kan bewerken zonder conflict. De desktop-app gaat hierin verder en spint voor elke nieuwe sessie automatisch een worktree op.

Hoe wij het deden. We standaardiseerden de worktree-bovenmap in een kleine project-config zodat elke geïsoleerde taak op dezelfde voorspelbare plek landt, en we houden een worktree per lopende PR. De praktische winst: een langlopende refactor kan in de ene worktree zitten terwijl een snelle bug-fix in een andere gebeurt, en geen van beide raakt de hoofd-checkout. Voor grotere features verslaat dit het jongleren met branches in één working copy — er is geen “wacht, waar was ik mee bezig” als je van taak wisselt.

Wat is nieuw medio 2026 (en waar dit heen gaat)

Als je Claude Code een paar maanden opzij hebt gelegd, dit is wat er veranderde — en waarom het uitmaakt voor hoe je hem configureert.

Modellen: Opus 4.8, fast mode en effort control

Claude Opus 4.8 kwam uit op 28 mei 2026 als het vlaggenschip, met een score van 69,2% op SWE-Bench Pro tegen dezelfde standaardprijs als zijn voorganger. Daarnaast werd fast mode ruwweg 2,5× sneller en zo’n drie keer goedkoper dan op eerdere modellen, en effort control (geïntroduceerd als API-parameter bij Opus 4.5 in november 2025) is nu blootgesteld over de consumenten-oppervlakken — jij kiest hoeveel denkwerk je per taak uitgeeft. De configuratie-conclusie: model en effort zijn nu dingen die je per sessie afstemt (--model, --effort, het /model-commando en de model-setting), niet één globale keuze.

Agents op schaal: agent teams en dynamische workflows

Opus 4.6 (5 februari 2026) introduceerde agent teams — meerdere agents die een taak opdelen, elk met een eigen stuk en directe coördinatie — en een 1M-token context window (beta). Daarna voegde Opus 4.8 dynamische workflows toe (research preview): Claude plant het werk, waaiert uit naar honderden parallelle subagents in één sessie en verifieert hun output voordat hij terugrapporteert. Het is gericht op zaken als migraties over honderdduizenden regels code. Het trigger-keyword voor die modus is nu /ultracode (het woord “workflow” trapt er niet langer vanzelf eentje af).

Oppervlakken: desktop-redesign en Routines

Op 14 april 2026 werd de Mac/Windows desktop-app herbouwd rondom multi-sessie-werk — een sessie-zijbalk, drag-and-drop-panes, een geïntegreerde terminal en file-editor, een side-chat voor snelle vragen die je hoofdcontext nooit vervuilen. Tegelijk gelanceerd: Routines (research preview), automatiseringen die op Anthropic’s web-infrastructuur draaien zodat geplande taken afgaan, zelfs met je laptop dicht. En Claude Code op het web (sinds oktober 2025) draait async agents in geïsoleerde cloud-sandboxen rechtstreeks vanuit de browser.

Distributie: een open standaard en een officiële marketplace

Dat Agent Skills een open standaard werd (december 2025) en de lancering van de officiële plugin-directory (claude-plugins-official, mei 2026) betekenen dat de lagen in deze post steeds vaker dingen zijn die je kunt installeren in plaats van zelf in elkaar te zetten — officiële integraties voor veelgebruikte SaaS-tools, language-server-plugins voor symbool-niveau-navigatie, een security-guidance-plugin die diffs in realtime bewaakt. Plugins bundelen skills, commando’s, agents, hooks en MCP-servers in één installeerbare eenheid, en zo distribueren teams nu een werkende setup in plaats van stamkennis door te geven.

De rode draad: het harnas dat je vandaag bouwt schaalt netjes op. Een goed gestructureerde CLAUDE.md, een paar scherpe hooks en een handvol skills zijn precies waar een enkele snelle sessie, een 1M-context agent team en een nachtelijke Routine allemaal uit putten. Anthropic’s eigen advies op org-niveau is om je configuratie elke drie tot zes maanden te herzien, want instructies die afgestemd zijn op de modellen van nu kunnen nieuwere modellen stilletjes beperken.

Je start-checklist

Wil je deze week van kaal naar afgestemd gaan, doe het dan in deze volgorde — elke stap is op zichzelf nuttig, en latere stappen bouwen voort op eerdere:

  1. Draai /init en snoei de gegenereerde CLAUDE.md daarna meedogenloos terug tot dingen die Claude niet kan afleiden. Houd hem onder ~200 regels. Duw gebiedsspecifieke richtlijnen naar geneste CLAUDE.md-bestanden.
  2. Voeg één PreToolUse-hook toe voor het ding dat nooit mag gebeuren in je repo (beschermde bestanden, verboden commando’s). Laat Claude hem voor je schrijven.
  3. Maak van je twee meest-herhaalde rituelen skills onder .claude/skills/, elk met een strakke description en een restrictieve allowed-tools.
  4. Voeg een read-only review-subagent toe in .claude/agents/ en gebruik de writer/reviewer-split vóór het mergen.
  5. Zet alleen de MCP-servers aan die je echt gebruikt; leun op Tool Search om de context-kosten laag te houden.
  6. Adopteer --worktree voor elke taak die langer loopt dan een koffiepauze, en voeg een .worktreeinclude toe voor je lokale-alleen-bestanden.
  7. Zet een reminder in je agenda: over drie tot zes maanden, herlees je CLAUDE.md en hooks tegen het huidige model en schrap wat niet meer nodig is.

Niets hiervan is exotisch. Het is dezelfde beweging die je zou maken bij het inwerken van een scherpe nieuwe collega: schrijf de niet-voor-de-hand-liggende regels op, automatiseer de dingen die nooit fout mogen gaan, geef ze de playbooks voor je veelvoorkomende taken en geef ze toegang tot de systemen die ze nodig hebben. Doe dat, en Claude Code houdt op autocomplete te zijn en wordt een collega die al weet hoe het er bij jou aan toe gaat.

Bronnen

Officiële documentatie — Best practices, Memory & CLAUDE.md, Hooks reference, Skills, Subagents, MCP, Worktrees, Settings, Plugins.

Anthropic-aankondigingen — Opus 4.8 (28 mei 2026), Opus 4.6 & agent teams (5 feb 2026), Opus 4.5 & effort (24 nov 2025), Agent Skills, Desktop-redesign & Routines (14 apr 2026), Claude Code op het web (20 okt 2025), Sonnet 4.5, checkpoints & de Agent SDK (29 sep 2025).

Levende referenties — How Claude Code works in large codebases (14 mei 2026); de officiële changelog voor exacte versienummers.

Controleer versie-specifieke details tegen de actuele changelog voordat je erop vertrouwt — de CLI ship’t vaak en feature-naar-versie-mappings schuiven.