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

> Entdecken Sie den 'Safe YOLO Mode' von Claude: Eine ausführliche Anleitung zur autonomen Ausführung mit `--dangerously-skip-permissions`, Risiken und Best Pract

- URL: https://thevibe-coding.de/guides/claude-dangerously-skip-permissions-guide
- Typ: guides | Veroeffentlicht: 2026-03-18 | Aktualisiert: 2026-07-13
- Autor: Vita Legne | Site: VIBE CODING — thevibe-coding.de

---

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
```bash
claude --dangerously-skip-permissions "Auszuführende Aufgabe"
```

### Mit benannter Session (um die Arbeit fortzusetzen)
```bash
claude --dangerously-skip-permissions --resume refactor-sprint "Setze Refactoring fort"
```

### In einem bestimmten Verzeichnis
```bash
claude --dangerously-skip-permissions --cwd ~/projects/sandbox "Implementiere Funktion"
```

### Mit Budget-Limit
```bash
claude --dangerously-skip-permissions --max-budget-usd 5.00 "Teure Aufgabe"
```

### Im Print-Modus (Ausgabe ohne Interaktivität)
```bash
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](/guides/ki-agenten-von-grund-auf-dein-umfassender-guide) 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.

```bash
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:

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

```bash
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:

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

```bash
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:

```json
{
  "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:

```json
{
  "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](/glossar/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:

```bash
# 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:

```bash
# 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](/tools/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):

1.  `~/.claude/settings.json` - Globale Benutzer-Settings
2.  `.claude/settings.json` - Projekt-Settings (committed)
3.  `.claude/settings.local.json` - Lokale Projekt-Settings (nicht committed)
4.  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

## FAQ

### Was ist der "Safe YOLO Mode" von Claude?

Der "Safe YOLO Mode" ist ein von Anthropic bezeichneter Modus, der durch das Flag `--dangerously-skip-permissions` aktiviert wird. Er ermöglicht Claude eine vollständig autonome Ausführung, indem alle Berechtigungsaufforderungen umgangen werden. Claude arbeitet dabei ununterbrochen bis zur Fertigstellung der Aufgabe.

### Wann sollte man `--dangerously-skip-permissions` verwenden?

Dieses Flag eignet sich gut für repetitive Aufgaben mit geringem Risiko wie das Beheben von Lint-Fehlern, Boilerplate-Generierung oder automatisiertes Refactoring. Es ist auch nützlich in kontrollierten Umgebungen wie CI/CD-Pipelines oder isolierten Sandbox- und Container-Umgebungen, wo potenzielle Schäden begrenzt sind.

### Welche Risiken sind mit der Nutzung von `--dangerously-skip-permissions` verbunden?

Die Hauptrisiken umfassen Datenverlust durch irreversible Löschung oder Beschädigung von Dateien und Systemkompromittierung durch die Ausführung schädlicher Befehle. Es besteht auch die Gefahr der Datenexfiltration durch Prompt-Injektionen und die Exposition sensibler Anmeldeinformationen.

### Wie kann man den autonomen Modus von Claude sicher nutzen?

Für eine sichere Nutzung empfiehlt es sich, Claude in Docker-Containern mit eingeschränkten Netzwerkzugriffen auszuführen. Zudem sollte man die verfügbaren Werkzeuge mit `--disallowedTools` einschränken und stets Versionskontrolle wie Git verwenden, um bei Fehlern zu einem früheren Zustand zurückkehren zu können.

## Quellen

- [Choose a permission mode](https://code.claude.com/docs/en/permission-modes) — Anthropic
- [How we built Claude Code auto mode: a safer way to skip permissions](https://www.anthropic.com/engineering/claude-code-auto-mode) — Anthropic
- [Claude Code --dangerously-skip-permissions: Safe Usage Guide + Configs](https://www.ksred.com/claude-code-dangerously-skip-permissions-when-to-use-it-and-when-you-absolutely-shouldnt/) — ksred.com