Werken met Claude Code: Tools en Permissies

Je geeft Claude Code de opdracht om een database-migratie te draaien. Het model genereert het SQL-statement, opent een bash-sessie, en voert npx prisma migrate dev uit. Je zag de diff, klikte op accept, en twee seconden later heeft Claude je database-schema gewijzigd. In productie.

Dat is niet gebeurd — het permissiesysteem van Claude Code heeft het tegengehouden. Maar het had kunnen gebeuren als je dat systeem niet begrijpt. Tools en permissies zijn de twee mechanismen die bepalen wat Claude Code kan en wat het mag. Het verschil is belangrijk.

De gereedschapskist

Claude Code werkt met een set ingebouwde tools. Elke tool is een specifieke actie die het model kan uitvoeren. Het model kiest zelf welke tool het inzet op basis van je prompt. Jij ziet de tool-calls in de output en kunt ze goedkeuren of weigeren.

Read

Leest de inhoud van een bestand. Dit is de meest gebruikte tool — Claude leest bestanden om context te verzamelen voordat het iets doet.

Tool: Read
File: src/services/order.ts

Read is veilig. Het verandert niets. Claude gebruikt het constant en het kost je geen goedkeuring in de standaard permissie-modus.

Write

Maakt een nieuw bestand aan of overschrijft een bestaand bestand met volledige nieuwe inhoud.

Tool: Write
File: src/services/notification.ts
Content: [volledige bestandsinhoud]

Write vraagt altijd om goedkeuring in de standaard modus. Je ziet de volledige inhoud van het bestand voordat het geschreven wordt.

Edit

Past een bestaand bestand aan via gerichte tekstvervangingen. In plaats van het hele bestand te overschrijven, specificeert Edit welke regels veranderen.

Tool: Edit
File: src/services/order.ts
Replace: [oude tekst] → [nieuwe tekst]

Edit is preciezer dan Write. Het laat de rest van het bestand intact. Je ziet een diff van de wijziging. Dit is de tool die Claude het vaakst gebruikt voor bestaande code.

Bash

Voert een shell-commando uit in je terminal.

Tool: Bash
Command: npm test -- --grep "notification"

Bash is de krachtigste en de gevaarlijkste tool. Claude kan er tests mee draaien, dependencies installeren, git-commando’s uitvoeren, en — als je het toelaat — destructieve operaties draaien. Het permissiesysteem besteedt de meeste aandacht aan Bash.

Glob

Zoekt bestanden op basis van patronen. Vergelijkbaar met find of ls, maar geoptimaliseerd voor Claude Code.

Tool: Glob
Pattern: src/**/*.test.ts

Claude gebruikt Glob om te ontdekken welke bestanden er zijn voordat het ze leest. Nuttig voor het verkennen van onbekende projectstructuren.

Grep

Doorzoekt bestanden op tekstpatronen. Claude gebruikt dit om functies te vinden, imports te traceren en referenties op te sporen.

Tool: Grep
Pattern: "updateOrderStatus"
Path: src/

Grep is essentieel voor de manier waarop Claude Code werkt. Het model kan niet alles tegelijk lezen. Het zoekt gericht naar relevante code en bouwt stapsgewijs een beeld op van je project.

Agent (sub-agents)

Claude Code kan sub-agents spawnen voor parallelle taken. Een sub-agent krijgt een eigen context en werkt zelfstandig aan een deeltaak.

Tool: Agent
Task: "Zoek alle plekken waar OrderStatus wordt gebruikt en maak een overzicht"

Sub-agents zijn nuttig voor verkennende taken: “zoek alle TODO-comments in het project”, “maak een overzicht van alle API-endpoints”, “controleer welke dependencies verouderd zijn.” Ze draaien parallel en rapporteren terug.

Het permissiesysteem

Claude Code heeft drie permissie-niveaus. Ze bepalen hoeveel vrijheid het model krijgt bij het uitvoeren van tools.

Standaard: interactieve goedkeuring

In de standaard modus vraagt Claude Code toestemming voor elke schrijfactie. Read, Glob en Grep draaien zonder goedkeuring. Write, Edit en Bash stoppen en tonen wat ze willen doen. Je beoordeelt en accepteert of weigert.

Dit is het veiligste niveau. Je ziet elke wijziging voordat die doorgevoerd wordt. Het nadeel: bij grote refactorings met tientallen bestandswijzigingen klik je veel op “accept”.

–permission-mode acceptEdits

claude --permission-mode acceptEdits

In deze modus accepteert Claude Code automatisch alle Write- en Edit-operaties. Bash-commando’s vragen nog steeds om goedkeuring. Dit is het middenniveau: Claude kan vrij bestanden aanpassen, maar draait geen commando’s zonder jouw toestemming.

Gebruik dit wanneer je een refactoring doet waarbij je weet dat de bestandswijzigingen veilig zijn, maar je controle wilt houden over wat er in de terminal gebeurt.

–permission-mode bypassPermissions

claude --permission-mode bypassPermissions

Volledige vrijheid. Claude Code leest, schrijft, bewerkt en draait commando’s zonder toestemming te vragen. Dit is de modus voor geautomatiseerde workflows — CI/CD pipelines, batch-operaties, of wanneer je Claude Code aanstuurt vanuit een ander systeem.

Gebruik dit alleen wanneer je weet wat je doet. In deze modus kan Claude Code rm -rf draaien, commits pushen, of packages installeren — allemaal zonder jou om toestemming te vragen. De risico’s zijn reëel. De modus bestaat voor automatisering, niet voor gemak.

De juiste modus kiezen

De vuistregel: begin met standaard. Schakel pas op wanneer de herhaalde goedkeuringen je workflow vertragen en je voldoende vertrouwen hebt in wat Claude doet.

Hooks: automatische acties bij tool-calls

Hooks zijn scripts die automatisch draaien wanneer Claude Code een bepaalde tool gebruikt. Ze ziten in je .claude/ configuratie en voegen een laag automatisering toe aan het permissiesysteem.

Wat hooks doen

Een hook reageert op een tool-call. Je kunt hooks instellen die draaien voor een tool-call (pre-hook), na een tool-call (post-hook), of als notificatie bij specifieke events.

Voorbeelden:

• Pre-hook op Bash: weiger commando’s die rm -rf bevatten.
• Post-hook op Write: draai automatisch prettier op elk nieuw bestand.
• Post-hook op Edit: draai de linter op het gewijzigde bestand.

Een linter-hook instellen

Maak een bestand .claude/settings.json (of .claude/settings.local.json voor lokale instellingen) en voeg een hook toe:

{
  "hooks": {
    "postToolExecution": [
      {
        "matcher": {
          "tool": ["write", "edit"],
          "filePattern": "**/*.ts"
        },
        "command": "npx eslint --fix $CLAUDE_FILE_PATH"
      }
    ]
  }
}

Elke keer dat Claude Code een TypeScript-bestand schrijft of bewerkt, draait ESLint er automatisch overheen. Fouten die Claude introduceert worden direct gecorrigeerd — zonder dat je het handmatig hoeft te doen.

Een pre-commit hook

Een veelgebruikt patroon: een hook die automatisch tests draait na elke wijziging.

{
  "hooks": {
    "postToolExecution": [
      {
        "matcher": {
          "tool": ["write", "edit"],
          "filePattern": "src/**/*.ts"
        },
        "command": "npm test -- --bail --findRelatedTests $CLAUDE_FILE_PATH"
      }
    ]
  }
}

--findRelatedTests draait alleen de tests die gerelateerd zijn aan het gewijzigde bestand. --bail stopt bij de eerste fout. Dit geeft je snelle feedback zonder de volledige testsuite te draaien.

Het resultaat: Claude Code schrijft code, de hook draait automatisch de relevante tests, en als een test faalt ziet Claude dat in de output en kan het direct corrigeren. De feedback-loop wordt korter zonder dat je tussenkomt.

Hooks en veiligheid

Hooks zijn krachtig, maar ze voegen complexiteit toe. Een slecht geconfigureerde hook kan elke tool-call vertragen, foutmeldingen veroorzaken die Claude verkeerd interpreteert, of onbedoelde side-effects hebben.

Drie regels voor hooks:

1. Houd ze snel. Een hook die tien seconden duurt na elke edit maakt je workflow onbruikbaar. Gebruik --bail, --findRelatedTests, en andere flags die de scope beperken.

2. Houd ze idempotent. Een hook die twee keer draait moet hetzelfde resultaat geven als een hook die één keer draait.

3. Test ze apart. Draai het hook-commando handmatig voordat je het in de configuratie zet. Controleer dat het werkt met de variabelen die Claude Code doorgeeft ($CLAUDE_FILE_PATH, $CLAUDE_TOOL_NAME).

De balans tussen vrijheid en controle

Het permissiesysteem van Claude Code is een ontwerp-beslissing over vertrouwen. Standaard vertrouwt het systeem het model weinig: elke schrijfactie vereist goedkeuring. Naarmate je vertrouwen groeit — in het model, in je project-setup, in je hooks — kun je meer vrijheid geven.

Die progressie is bewust. Een developer die net begint met Claude Code wil elke wijziging zien. Een developer die al drie maanden met Claude Code werkt, een robuuste testsuite heeft, en hooks heeft ingesteld die automatisch linting en testing doen, kan acceptEdits gebruiken zonder significant risico.

Het punt is niet om zo snel mogelijk naar bypassPermissions te gaan. Het punt is om de laag van automatische checks zo goed te maken dat het permissieniveau minder uitmaakt. Een goede testsuite vangt fouten op die je in een diff zou missen. Een goede linter vangt stijlfouten op die je niet wilt reviewen. Hooks automatiseren wat je toch elke keer handmatig zou doen.

Bouw de vangnetten eerst. Verruim de permissies daarna.

In deel 4 kijken we naar MCP — het Model Context Protocol dat Claude Code verbindt met externe tools en databronnen.

Dit is deel 3 van de serie “Werken met Claude Code”. Lees deel 1 en 2 voor installatie en aansturing.