Zum Inhalt springen
SONOYA.com
KI

Claude Code Berechtigungen: Modi, Regeln, settings.json

So steuerst Du in Claude Code, was ohne Rückfrage laufen darf: Rechtemodi, allow-, ask- und deny-Regeln in der settings.json, /permissions und Sandbox.

Von

Schild mit Schlüsselloch auf dunkelrotem Verlauf als Symbol für die Berechtigungen, mit denen Claude Code Befehle und Dateizugriffe freigibt oder sperrt

Claude Code fragt Dich bei jedem npm test erneut um Erlaubnis, oder Du willst umgekehrt sicher sein, dass es Deine .env nie zu Gesicht bekommt und kein git push ohne Dein Okay abschickt. Beides regeln die Berechtigungen (permissions): ein Rechtemodus für die Grundhaltung und Regeln mit allow, ask und deny für die Einzelfälle.

Hier erfährst Du, welche Modi es gibt, wie die Regeln aufgebaut sind, in welche settings.json sie gehören und welche Datei gewinnt, wenn sich zwei widersprechen. Am Ende steht eine fertige Konfiguration für ein typisches Webprojekt samt den Fallstricken bei den Mustern. Stand ist Claude Code 2.1.330 vom November 2026, geprüft gegen die offiziellen Seiten Configure permissions, Permission modes und Settings files and precedence. Läuft Claude Code bei Dir noch nicht, hilft Dir zuerst die Anleitung: Claude Code auf dem Mac installieren & nutzen.

Wie Claude Code Freigaben entscheidet

Jede Aktion läuft über ein Werkzeug, und im Manual-Modus fragt Claude Code je nach Werkzeug unterschiedlich nach. Dateien lesen und durchsuchen darf es innerhalb Deines Projektordners ohne Rückfrage. Shell-Befehle brauchen eine Freigabe, außer bei einer fest eingebauten Liste harmloser Befehle wie ls, cat, grep oder git status. Auch Dateiänderungen, Webabrufe und Websuchen fragen nach.

Antwortest Du auf eine Abfrage mit „Yes, and don’t ask again”, merkt sich Claude Code das unterschiedlich lange. Bei Shell-Befehlen und Webdomains schreibt es eine Regel in .claude/settings.local.json im Wurzelordner des Repositorys, die dauerhaft gilt. Bei Dateiänderungen gilt die Zusage dagegen nur bis zum Ende der Sitzung. Deshalb fragt Claude Code am nächsten Tag wieder, ob es in src/ schreiben darf, obwohl Du gestern schon zugestimmt hast.

Wichtig für das Verständnis: Diese Regeln setzt Claude Code selbst durch, nicht das Modell. Ein Satz in der CLAUDE.md wie „Lies niemals die .env” ist nur eine Bitte, eine deny-Regel ist eine Sperre.

Die Rechtemodi und Shift + Tab

Der Modus legt fest, was ohne Abfrage durchgeht. Im Terminal wechselst Du ihn mit Shift + Tab, die Statuszeile unten zeigt den aktuellen Modus an.

ModusWas ohne Rückfrage läuftWofür
default (Manual)Lesen im Projekt, harmlose Befehlefremder oder heikler Code
acceptEditszusätzlich Dateiänderungen und mkdir, touch, rm, mv, cp, sed im ProjektArbeit, die Du ohnehin im Diff prüfst
plannur Lesen und Erkunden, Änderungen erst nach Freigabe des Plansgrößere Aufgaben planen
autofast alles, ein Klassifikator prüft jede Aktion im Hintergrundlange Aufgaben ohne Dauerklicken
dontAsknur ausdrücklich Erlaubtes, alles andere wird abgelehntSkripte und CI
bypassPermissionsallesnur isolierte Container und VMs

Seit Version 2.1.283 startet Claude Code im Terminal und in VS Code standardmäßig im Auto-Modus, sofern Dein Modell ihn unterstützt. Ein zweites Modell prüft dort jede Aktion und blockiert laut Doku zum Beispiel curl | bash, Force-Pushes, git reset --hard und Produktions-Deployments. Blockiert es dreimal hintereinander oder zwanzigmal insgesamt, fällt Claude Code auf normale Abfragen zurück. Ein Sicherheitsversprechen ist das ausdrücklich nicht.

Drückst Du im Auto-Modus Shift + Tab, landest Du zuerst in default, danach geht es reihum über acceptEdits und plan zurück zu auto. bypassPermissions taucht in diesem Kreis nur auf, wenn Du Claude Code mit --dangerously-skip-permissions oder --permission-mode bypassPermissions gestartet hast, dontAsk dagegen nie. Für eine einzelne Sitzung wählst Du den Modus beim Start:

Code
claude --permission-mode plan

Dauerhaft legst Du ihn mit defaultMode fest. auto und bypassPermissions wirken dabei nur aus Deiner Nutzerdatei ~/.claude/settings.json, in der Projektdatei ignoriert Claude Code sie, damit ein geklontes Repository Dir keinen freizügigen Modus unterschieben kann.

Regeln schreiben: allow, ask und deny

Eine Regel besteht aus dem Werkzeugnamen und optional einem Muster in Klammern, also Werkzeug oder Werkzeug(Muster). Sie landet in einer von drei Listen unter permissions:

  • allow lässt die Aktion ohne Rückfrage durch.
  • ask fragt immer nach, auch in acceptEdits, auto und bypassPermissions.
  • deny blockiert sie in jedem Modus, selbst mit --dangerously-skip-permissions.

Die Reihenfolge ist fest: zuerst deny, dann ask, dann allow. Die erste passende Regel entscheidet, egal wie genau eine andere ist. Ein breites "deny": ["Bash(aws *)"] blockiert deshalb auch aws s3 ls, selbst wenn genau dieser Befehl unter allow steht.

Shell-Befehle mit Bash(…)

Das Sternchen steht für beliebigen Text, auch mit Leerzeichen. Was davor steht, muss wörtlich passen.

Regelpasst aufpasst nicht auf
Bash(npm run build)npm run buildnpm run build --watch
Bash(npm test *)npm test, npm test -- --watchnpm install
Bash(ls *)ls, ls -lalsof
Bash(ls*)ls -la, lsof

Das Leerzeichen vor dem Sternchen gehört also zur Regel. Die Schreibweise Bash(npm test:*) mit Doppelpunkt ist gleichwertig. Claude Code zerlegt außerdem verkettete Befehle: Bash(npm test *) erlaubt nicht automatisch npm test && rm -rf build, jeder Teil braucht seine eigene Freigabe.

Dateien mit Read(…) und Edit(…)

Für Dateien gibt es nur zwei Regelarten. Read gilt für alle lesenden Werkzeuge wie Grep und Glob, Edit für alle schreibenden. Eine deny-Regel auf Read sperrt die Datei zugleich für Änderungen. Regeln wie Write(...) oder Grep(...) mit Pfad nimmt Claude Code zwar an, sie greifen aber nie.

Die Muster folgen der gitignore-Syntax, und der Anfang des Pfads entscheidet, worauf er sich bezieht:

Musterbezieht sich aufBeispiel
//pfadWurzel des DateisystemsRead(//etc/**)
~/pfadDein Home-VerzeichnisRead(~/.ssh/**)
/pfadden Ort der EinstellungsdateiEdit(/src/**)
pfad oder ./pfadden aktuellen OrdnerRead(.env)

Ein einzelner Schrägstrich bedeutet also nicht „absolut”. In der Projektdatei zeigt /src/** auf den src-Ordner Deines Projekts, in der Nutzerdatei dagegen auf ~/.claude/src/. Ein reiner Dateiname wie .env trifft in jeder Tiefe, * gilt innerhalb eines Ordners und ** über Ordner hinweg.

Webabrufe erlaubst Du pro Domain mit WebFetch(domain:example.com), Werkzeuge von MCP-Servern mit mcp__servername__*.

Die Ebenen der settings.json und wer gewinnt

Regeln können in mehreren Dateien stehen:

Dateigilt füreingecheckt
~/.claude/settings.jsonDich, in allen Projektennein
.claude/settings.jsonalle im Projektja
.claude/settings.local.jsonnur Dich, nur dieses Projektnein, Claude Code trägt sie beim ersten Schreiben in Deine globalen Git-Ausnahmen ein
Managed Settingsalle, die eine Firma verwaltetvom Admin verteilt

Bei einfachen Einstellungen gewinnt die höhere Ebene in der Reihenfolge Managed, Kommandozeile mit --settings, lokal, Projekt, Nutzer. Bei den Regellisten ist es anders: allow, ask und deny werden aus allen Dateien zusammengeführt und dann in der festen Reihenfolge geprüft. Ein deny in Deiner Nutzerdatei schlägt also ein allow im Projekt, und umgekehrt genauso.

Noch eine Eigenheit: allow-Regeln und additionalDirectories aus der eingecheckten .claude/settings.json wirken erst, nachdem Du dem Ordner im Vertrauensdialog zugestimmt hast. deny und ask gelten sofort, weil sie nur einschränken.

/permissions statt Handarbeit

Tippst Du in einer Sitzung /permissions, öffnet sich eine Übersicht aller aktiven Regeln, jeweils mit der Datei, aus der sie stammen. Dort fügst Du Regeln hinzu, entfernst sie und wählst beim Speichern die Zieldatei. Das ist auch der schnellste Weg, um herauszufinden, warum ein Befehl trotz Freigabe nachfragt. Welche Einstellungsdateien überhaupt geladen wurden, zeigt /status in der Zeile Setting sources.

Beispielkonfiguration für ein Webprojekt

Für ein Node-Projekt mit npm und Git hat sich diese Aufteilung bewährt. Die gemeinsamen Regeln stehen in .claude/settings.json und kommen mit ins Repository:

Code
{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run build)",
      "Bash(npm test *)",
      "Bash(git add *)",
      "Bash(git commit *)",
      "Edit(/src/**)",
      "WebFetch(domain:github.com)"
    ],
    "ask": [
      "Bash(git push *)",
      "Bash(npm install *)"
    ],
    "deny": [
      "Read(.env)",
      "Read(.env.*)",
      "Read(!.env.example)",
      "Read(./secrets/**)",
      "Bash(curl *)",
      "Bash(wget *)"
    ]
  }
}

Das bewirken die drei Blöcke:

  • allow: Lint, Build und Tests laufen ohne Rückfrage, ebenso Commits und Änderungen in src/. Bewusst steht dort nicht Bash(npm run *), weil damit auch ein Skript wie npm run deploy freigegeben wäre.
  • ask: Ein Push und neue Pakete fragen immer nach, auch wenn Du im Auto-Modus arbeitest.
  • deny: Jede .env und jede .env.local in beliebiger Tiefe ist gesperrt, die Vorlage .env.example holt die Zeile mit ! laut Doku ausdrücklich zurück. curl und wget sind blockiert, damit Webzugriffe über WebFetch und dessen Domainregeln laufen.

Die $schema-Zeile ist optional und sorgt in VS Code für Autovervollständigung. Achte auf sauberes JSON: Kommentare oder ein Komma nach dem letzten Eintrag führen beim Start zu einem „Settings Error”.

Persönliche Grenzen, die in jedem Projekt gelten sollen, gehören in ~/.claude/settings.json:

Code
{
  "permissions": {
    "defaultMode": "default",
    "disableBypassPermissionsMode": "disable",
    "deny": [
      "Read(~/.ssh/**)",
      "Read(~/.aws/**)"
    ]
  }
}

defaultMode holt Dich hier zurück in den Manual-Modus. Lass die Zeile weg, wenn Dir der Auto-Modus gefällt. disableBypassPermissionsMode sperrt Dich selbst aus dem Modus ohne jede Abfrage aus, und die beiden deny-Regeln halten SSH-Schlüssel und AWS-Zugangsdaten aus jeder Sitzung heraus.

So prüfst Du das Ergebnis: Starte Claude Code neu im Projekt, kontrolliere mit /permissions, dass alle Regeln mit der richtigen Datei auftauchen, und bitte Claude, den Inhalt der .env zusammenzufassen. Es muss ablehnen und auf die Sperre verweisen. Beide Beispiele habe ich als JSON validiert und ihre Schlüssel mit dem veröffentlichten Schema abgeglichen, die Regelwirkung folgt der offiziellen Doku.

Die Sandbox als harte Grenze

Regeln prüfen den Befehlstext, den Claude schreibt. Bash(curl *) stoppt curl https://example.com, aber nicht /usr/bin/curl oder sh -c 'curl …', und eine Read-Sperre greift nicht, wenn ein Python-Skript die Datei selbst öffnet. Für eine Grenze, die unabhängig vom Text hält, gibt es die Sandbox. Sie lässt das Betriebssystem Schreibzugriffe und Netzwerkverbindungen aller Shell-Befehle beschränken, auf dem Mac über Seatbelt, unter Linux und WSL2 über bubblewrap. Unter Linux installierst Du dafür zuerst die beiden Pakete:

Code
sudo apt-get install bubblewrap socat

Einschalten kannst Du sie in der Sitzung mit /sandbox oder in der Einstellungsdatei:

Code
{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "allowUnsandboxedCommands": false,
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}

Mit autoAllowBashIfSandboxed laufen Befehle in der Sandbox ohne Rückfrage, weil die Sandbox die Grenze zieht. deny-Regeln und gezielte ask-Regeln wie Bash(git push *) gelten weiterhin. allowUnsandboxedCommands: false verhindert, dass Claude einen blockierten Befehl einfach außerhalb der Sandbox wiederholt. Schreiben dürfen Befehle dann nur im Projektordner und im Temp-Verzeichnis, ins Netz ohne Rückfrage nur zu den Domains in allowedDomains. Lesen dürfen sie dagegen fast überall, auch ~/.ssh. Deine Read-Sperren aus permissions.deny übernimmt die Sandbox allerdings als Lesesperre, weitere Pfade sperrst Du unter sandbox.filesystem.denyRead. Tools wie docker vertragen sich nicht mit der Sandbox und kommen bei Bedarf unter excludedCommands.

Ob die Sandbox greift, testest Du, indem Du Claude den Befehl touch ~/sandbox-probe ausführen lässt. Auf dem Mac muss er mit Operation not permitted scheitern.

Typische Fehler

  • Trotz „don’t ask again” kommt die Abfrage wieder: Eine ask-Regel aus einer anderen Datei schlägt Dein lokales allow. Prüf in /permissions, woher sie stammt.
  • Projektregeln wirken nicht: Der Ordner ist noch nicht als vertrauenswürdig bestätigt, oder defaultMode steht auf auto in der Projektdatei, wo Claude Code das ignoriert.
  • Sperre in der Nutzerdatei greift nicht: Dort bezieht sich /secrets/** auf ~/.claude/secrets/. Nimm ~/ oder // für feste Pfade.
  • Regel zu breit: Bash(git *) erlaubt jeden Git-Befehl inklusive Push. Setz das Sternchen erst hinter den Unterbefehl, etwa Bash(git log *).
  • Datei ignoriert: Läuft /status ohne Deine Datei unter Setting sources, ist das JSON kaputt. Die Details liefert claude doctor im Terminal.

Fazit: Regeln für den Alltag, Sandbox für den Ernstfall

Mit einer Handvoll allow-Regeln für Tests und Builds fragt Claude Code nur noch dort nach, wo es wirklich zählt, und deny hält Geheimnisse zuverlässig von den eingebauten Werkzeugen fern. Weil Regeln am Befehlstext hängen, gehört für harte Grenzen die Sandbox dazu. Brauchst Du Logik, die über Muster hinausgeht, etwa eine Sperre für Force-Pushes in jeder Schreibweise, hilft Dir Claude Code Hooks: Anleitung mit fünf Beispielen weiter. Was Claude wissen sollte, statt es zu müssen, steht besser in der Projektdatei, die CLAUDE.md für Claude Code: was rein gehört, was nicht erklärt. Und wer Claude Code unbeaufsichtigt im Modus dontAsk laufen lässt, findet das Vorgehen in Claude Code automatisch ausführen: Headless mit launchd.

Weiterlesen.