Claude im "Safe YOLO Mode": Ein vollständiger Leitfaden zu `--dangerously-skip-permissions`

Das Flag --dangerously-skip-permissions aktiviert einen Modus, den Anthropic als "Safe YOLO Mode" bezeichnet. Es ermöglicht eine vollständig autonome Ausführung, bei der Claude alle Berechtigungsaufforderungen umgeht und ununterbrochen bis zur Fertigstellung der Aufgabe arbeitet.

Syntax und Verwendung

Grundlegende Verwendung

claude --dangerously-skip-permissions "Auszuführende Aufgabe"

Mit benannter Session (um die Arbeit fortzusetzen)

claude --dangerously-skip-permissions --resume refactor-sprint "Setze Refactoring fort"

In einem bestimmten Verzeichnis

claude --dangerously-skip-permissions --cwd ~/projects/sandbox "Implementiere Funktion"

Mit Budget-Limit

claude --dangerously-skip-permissions --max-budget-usd 5.00 "Teure Aufgabe"

Im Print-Modus (Ausgabe ohne Interaktivität)

claude -p --dangerously-skip-permissions "Generiere Bericht"

Wann `--dangerously-skip-permissions` verwenden?

Laut den offiziellen Best Practices von Anthropic funktioniert dieser Modus gut für:

Lint-Fehler beheben: repetitive Aufgaben mit geringem Risiko
Boilerplate-Generierung: Standard-Code-Scaffolding
Automatisiertes Refactoring: strukturelle Änderungen, die von Specs geleitet werden
CI/CD-Pipelines: Ausführung in kontrollierter Umgebung
Sandbox und Container: isolierte Umgebungen, in denen Schaden begrenzt ist

ACHTUNG: Der Name enthält "dangerously" aus gutem Grund. Sie geben einem KI-Agenten die vollständige Kontrolle zum Erstellen, Ändern und Löschen von Dateien, Ausführen beliebiger Befehle und potenziellen Verursachen irreversibler Schäden. Verwenden Sie diesen Modus nur, wenn Sie die Risiken verstehen.

Dokumentierte Risiken

Die Hauptrisiken bei der Verwendung von --dangerously-skip-permissions umfassen:

Datenverlust: irreversible Löschung oder Beschädigung von Dateien
Systemkompromittierung: Ausführung von Befehlen, die die Systemintegrität beschädigen
Datenexfiltration: Anfälligkeit für Prompt-Injektionen, die sensible Daten senden könnten
Credential-Exposition: Zugriff auf .env-Dateien, API-Schlüssel, Passwörter
Kaskadeneffekte: ein einzelner falsch interpretierter Befehl kann erhebliche Schäden verursachen

Best Practices für sichere Verwendung

Hier sind die empfohlenen Strategien, um den autonomen Modus sicher und produktiv zu nutzen:

1. Verwende Docker-Container

Der sicherste Weg ist, Claude in einer Sandbox-Umgebung auszuführen. Ein Docker-Container isoliert den Agenten vom Hauptsystem.

docker run -it --rm \
  -v $(pwd):/workspace \
  -w /workspace \
  --network none \
  claude-code:latest \
  --dangerously-skip-permissions "Implementiere Funktion"

Das Flag --network none verhindert externe Verbindungen und begrenzt das Risiko der Datenexfiltration.

2. Konfiguriere AllowedTools

Selbst im Bypass-Modus können Sie die für Claude verfügbaren Werkzeuge einschränken, indem Sie --allowedTools verwenden:

claude --dangerously-skip-permissions --tools "Read,Edit,Grep,Glob" "Analysiere Codebase"

claude --dangerously-skip-permissions --disallowedTools "Bash(rm:*)" "Refactoring"

Hinweis: Es gibt ein dokumentiertes Problem, bei dem --allowedTools mit bypassPermissions ignoriert werden könnte. Verwenden Sie --disallowedTools, das in allen Modi korrekt funktioniert.

3. Verwende Versionskontrolle

Git ist Ihr bester Freund, wenn Sie autonome Modi verwenden. Mit einem initialisierten Git-Repository können Sie immer zurückgehen:

git add -A && git commit -m "Checkpoint vor Claude"

git reset --hard HEAD

4. Definiere spezifische Aufgaben

Sagen Sie Claude nicht "baue eine Web-App". Geben Sie präzise und begrenzte Anweisungen:

Gut: "Behebe alle ESLint-Fehler in der Datei src/utils/helpers.js"
Gut: "Füge JSDoc zu allen exportierten Funktionen in src/api/ hinzu"
Schlecht: "Verbessere den Code" (zu vage)
Schlecht: "Mach, was nötig ist" (keine Grenzen)

Effektive Prompts für den YOLO-Modus

Um Claude im YOLO-Modus effektiv zu steuern, können Sie eine settings.json verwenden, um Berechtigungen und Präferenzen festzulegen:

{
  "permissions": {
    "defaultMode": "acceptEdits",
    "allow": [
      "Bash(npm run:*)",
      "Bash(git status:*)",
      "Bash(git diff:*)",
      "Read",
      "Glob",
      "Grep"
    ],
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(sudo:*)"
    ]
  },
  "preferences": {
    "model": "sonnet",
    "maxBudgetUsd": 20
  }
}

VS Code-Konfiguration

Um bypassPermissions in VS Code zu verwenden, fügen Sie zu Ihrer .claude/settings.json hinzu:

{
  "permissions": {
    "defaultMode": "bypassPermissions"
  }
}

VS Code-Hinweis: Die Dropdown-Oberfläche der VS Code-Erweiterung zeigt bypassPermissions nicht unter den auswählbaren Optionen, funktioniert aber korrekt, wenn es in der settings.json konfiguriert wird.

Häufig gestellte Fragen (FAQ)

1. Was ist der Unterschied zwischen `--dangerously-skip-permissions` und `--permission-mode bypassPermissions`?

Sie sind funktional äquivalent. Das Flag --dangerously-skip-permissions ist eine Abkürzung für --permission-mode bypassPermissions. Beide aktivieren denselben "YOLO"-Modus, der alle Bestätigungs-Prompts umgeht.

2. Kann ich `--allowedTools` zusammen mit `--dangerously-skip-permissions` verwenden?

Verwenden Sie stattdessen --disallowedTools. Es gibt einen dokumentierten Bug, bei dem --allowedTools im Bypass-Modus ignoriert werden könnte. Das Flag --disallowedTools funktioniert korrekt und ermöglicht es Ihnen, bestimmte Werkzeuge auch im YOLO-Modus auszuschließen.

3. Wie kann ich Claude unterbrechen, wenn es etwas Falsches tut?

Drücken Sie Escape oder verwenden Sie /clear. Selbst im YOLO-Modus können Sie die Ausführung jederzeit unterbrechen. Wenn Sie Git verwenden (wie empfohlen), können Sie dann mit git reset --hard HEAD ein Rollback durchführen.

4. Ist es sicher, `--dangerously-skip-permissions` in der Produktion zu verwenden?

Nur in isolierten Umgebungen. Verwenden Sie diesen Modus niemals auf Produktionssystemen mit echten Daten. Die empfohlene Verwendung ist in Docker-Containern, VMs oder Entwicklungsumgebungen, in denen Schaden begrenzt und reversibel ist.

5. Kann ich den YOLO-Modus als Standard für ein Projekt konfigurieren?

Ja, über settings.json. Erstellen Sie eine Datei .claude/settings.json mit "defaultMode": "bypassPermissions". Überlegen Sie jedoch, ob dies wirklich die richtige Wahl für Ihr Team und Projekt ist.

6. Was ist der beste Modus für Spec-Driven Development?

Ein hybrider Ansatz. Verwenden Sie den Default- oder Plan-Modus für die Planungs- und Spec-Erstellungsphase, wechseln Sie dann zu --dangerously-skip-permissions nur für die Implementierungsphase bereits genehmigter Specs. Dies balanciert Aufsicht und Automatisierung.

7. Funktioniert `--dangerously-skip-permissions` mit MCP-Servern?

Ja, mit zusätzlicher Vorsicht. Im YOLO-Modus werden auch MCP-Werkzeuge ohne Bestätigung ausgeführt. Stellen Sie sicher, dass Ihre MCP-Server keine gefährlichen Operationen ohne angemessene serverseitige Schutzmaßnahmen offenlegen.

Integration mit Spec-Driven Development

Die wahre Stärke von --dangerously-skip-permissions zeigt sich, wenn Sie es mit Spec-Driven Development-Methodologien kombinieren. Wie in unserem Leitfaden zu SDD-Frameworks erklärt, bietet Spec-Driven Development die Struktur, die autonome Arbeit sicher macht.

Das bidirektionale Muster

Der optimale Ablauf kombiniert:

Planungsphase (beaufsichtigt): Sie verwenden Claude im normalen Modus, um detaillierte Specs zu erstellen
Menschliche Überprüfung: Sie verifizieren und genehmigen die Specs
Implementierungsphase (autonom): Sie verwenden --dangerously-skip-permissions, um die genehmigten Specs zu implementieren
Validierung: Automatische Tests verifizieren, dass die Implementierung die Specs erfüllt

Beispiel mit GSD Framework

Das GSD (Get Shit Done) Framework ist genau für dieses Muster konzipiert:

# 1. Planungsphase (interaktiv)
claude "Analysiere das Projekt und erstelle Specs für Feature X"

# 2. Überprüfe generierte Specs in .gsd/specs/

# 3. Build-Phase (autonom)
claude --dangerously-skip-permissions "/gsd build"

# 4. GSD führt Aufgabe für Aufgabe, Commit für Commit aus

Beispiel mit BMAD-Methode

Mit BMAD eignet sich der Multi-Agenten-Workflow perfekt:

# Phase 1-4: Planung mit Aufsicht
claude "/pm"    # Product Manager erstellt PRD
claude "/arch"  # Architect erstellt Design
claude "/sm"    # Scrum Master erstellt Stories

# Überprüfe Dokumente in bmad-docs/

# Phase 5: Autonome Implementierung
claude --dangerously-skip-permissions "/dev story-1"
claude --dangerously-skip-permissions "/dev story-2"

# Phase 6: QA
claude "/qa"

Warum es funktioniert

Die Kombination von SDD mit autonomem Modus funktioniert, weil:

Die Specs sind der Vertrag: Claude weiß genau, was zu tun ist
Begrenzter Umfang: jede Aufgabe ist abgegrenzt und überprüfbar
Nachverfolgbarkeit: jeder Commit entspricht einer Spec-Aufgabe
Einfaches Rollback: wenn eine Aufgabe fehlschlägt, Revert des einzelnen Commits

Weitere nützliche CLI-Befehle

Neben --dangerously-skip-permissions bietet Claude Code viele weitere nützliche Flags zur Verhaltenssteuerung:

Session-Flags

Flag	Beschreibung	Beispiel
`-c`	Setzt die neueste Konversation fort	`claude -c`
`-r "Name"`	Setzt Session nach Name oder ID fort	`claude -r "auth-refactor"`
`--cwd`	Setzt Arbeitsverzeichnis	`claude --cwd ~/project`

Ausgabe-Flags

Flag	Beschreibung	Beispiel
`-p`	Print-Modus (nicht interaktiv)	`claude -p "Anfrage"`
`--output-format`	Ausgabeformat: text, json, stream-json	`claude -p --output-format json`
`--json-schema`	JSON-Ausgabe gegen Schema validiert	`claude -p --json-schema '{...}'`

Steuerungs-Flags

Flag	Beschreibung	Beispiel
`--max-turns`	Begrenzt Anzahl der agentischen Runden	`claude -p --max-turns 5`
`--max-budget-usd`	Maximales Budget in Dollar	`claude --max-budget-usd 10`
`--model`	Gibt Modell an: sonnet, opus, haiku	`claude --model haiku`
`--fallback-model`	Automatisches Fallback-Modell	`claude --fallback-model sonnet`

System-Prompt-Flags

Flag	Verhalten	Beispiel
`--system-prompt`	Ersetzt gesamten Prompt	`claude --system-prompt "Du bist ein React-Experte"`
`--append-system-prompt`	Fügt zum Standard-Prompt hinzu	`claude --append-system-prompt "Verwende TypeScript"`
`--system-prompt-file`	Lädt Prompt aus Datei	`claude -p --system-prompt-file ./prompt.txt`

Persistente Konfiguration

Anstatt Flags jedes Mal zu übergeben, können Sie Standardverhalten in den Settings-Dateien konfigurieren:

Settings-Hierarchie

Die Settings werden in Prioritätsreihenfolge angewendet (von niedrig nach hoch):

~/.claude/settings.json - Globale Benutzer-Settings
.claude/settings.json - Projekt-Settings (committed)
.claude/settings.local.json - Lokale Projekt-Settings (nicht committed)
Enterprise-Settings (von der Organisation verwaltet)

Fazit

Das Flag --dangerously-skip-permissions ist ein mächtiges Werkzeug, das bei korrekter Verwendung die Produktivität erheblich steigern kann, wenn Sie mit Claude Code arbeiten. Der Schlüssel ist, es zu kombinieren mit:

Isolierte Umgebungen: Docker-Container oder VMs
Rigorose Versionskontrolle: häufige Commits, einfaches Rollback
Spezifische und begrenzte Aufgaben: keine vagen Prompts
Spec-Driven Development: genehmigte Specs vor der autonomen Implementierung

Claude im "Safe YOLO Mode": Ein vollständiger Leitfaden zu --dangerously-skip-permissions