# So verwenden Sie den Claude Code Auto-Modus: Vollständiges Schritt-für-Schritt-Tutorial

Erfahren Sie genau, wie Sie den Claude Code Auto-Modus für sichereres autonomes Programmieren aktivieren und nutzen. Vollständiges Tutorial mit Installation, Konfiguration, Moduswechsel und Fehlerbehebung für Team/Enterprise-Nutzer.

Canonical URL: https://a2a-mcp.org/blog/how-to-use-claude-code-auto-mode-de

Language: de

Published: 2026-03-25

Updated: 2026-03-25

## Voraussetzungen

Stellen Sie Folgendes sicher, bevor Sie den Claude Code Auto-Modus verwenden:

- **Claude-Abonnement**: Team-Plan (für die Forschungsvorschau erforderlich) oder Enterprise-Plan (wird demnächst ausgerollt). Der Auto-Modus ist für Pro-, Max- oder kostenlose Konten nicht verfügbar.
- **Claude-Modell**: Claude Sonnet 4.6 oder Opus 4.6 (für den Auto-Modus erforderlich).
- **Claude Code installiert**: Die neueste Version der CLI, der Desktop-App oder der VS Code-Erweiterung.
- **Projektverzeichnis**: Eine lokale Codebasis, an der Sie arbeiten möchten.
- **Terminalzugriff**: Für die CLI-Verwendung (für volle Kontrolle empfohlen).

**Hinweis**: Der Auto-Modus ist derzeit eine Forschungsvorschau. Administratoren können ihn organisationsweit über verwaltete Einstellungen deaktivieren.

## Schritt 1: Claude Code installieren

1. Öffnen Sie Ihr Terminal.
2. Führen Sie den entsprechenden Installationsbefehl für Ihr Betriebssystem aus:

   **macOS / Linux / WSL**
   ```bash
   curl -fsSL https://claude.ai/install.sh | bash
   ```

   **Windows (PowerShell)**
   ```powershell
   irm https://claude.ai/install.ps1 | iex
   ```

3. Überprüfen Sie die Installation:
   ```bash
   claude --version
   ```

4. (Optional) Für Homebrew auf macOS:
   ```bash
   brew install --cask claude-code
   ```

Nach der Installation aktualisiert sich Claude Code automatisch im Hintergrund.

## Schritt 2: Bei Claude Code anmelden

1. Starten Sie eine interaktive Sitzung:
   ```bash
   claude
   ```
2. Befolgen Sie die Eingabeaufforderung zur Anmeldung auf dem Bildschirm (nur bei erstmaliger Nutzung).
3. Verwenden Sie ein Team- oder Enterprise-Konto.

Sobald Sie angemeldet sind, werden die Anmeldedaten sicher gespeichert.

## Schritt 3: Auto-Modus aktivieren

Der Auto-Modus muss explizit freigeschaltet werden, bevor er im Moduszyklus erscheint.

### CLI-Methode (Empfohlen)

Starten Sie mit dem Aktivierungs-Flag:
```bash
claude --enable-auto-mode
```

Oder starten Sie direkt mit dem Auto-Modus:
```bash
claude --enable-auto-mode --permission-mode auto
```

### Einstellungsdatei-Methode

Erstellen oder bearbeiten Sie `~/.claude/settings.json` (benutzerebene) oder `.claude/settings.local.json` (projektebene):
```json
{
  "defaultMode": "auto"
}
```

**Wichtig**: Das Flag `--enable-auto-mode` ist beim Start noch erforderlich, damit der Modus im Shift+Tab-Zyklus erscheint.

### Desktop- / VS Code-Erweiterung

- Öffnen Sie die Claude Code-Einstellungen.
- Schalten Sie **Auto-Modus** ein (erscheint erst nach Aktivierung über CLI-Flag oder Administrator-Einstellungen).

## Schritt 4: Konfigurieren des Auto-Modus-Klassifizierers (Empfohlen)

Der Auto-Modus nutzt einen Hintergrund-Klassifizierer, um sichere Aktionen zu genehmigen. Passen Sie ihn an Ihre Umgebung an.

1. Eingebaute Regeln inspizieren:
   ```bash
   claude auto-mode defaults
   ```

2. Kopieren Sie die Ausgabe und erstellen/bearbeiten Sie Ihre Einstellungsdatei mit vertrauenswürdiger Infrastruktur:
   ```json
   {
     "autoMode": {
       "environment": [
         "Organisation: Acme Corp. Hauptzweck: Softwareentwicklung",
         "Quellcodeverwaltung: github.com/acme-corp und alle Repos",
         "Cloud-Speicher: s3://acme-build-artifacts"
       ],
       "allow": [
         "Bereitstellung auf Staging ist erlaubt: isolierte Umgebung"
       ],
       "soft_deny": [
         "Datenbank-Migrationen niemals außerhalb der offiziellen CLI ausführen"
       ]
     }
   }
   ```

3. Validieren Sie Ihre Konfiguration:
   ```bash
   claude auto-mode config
   ```

4. KI-Feedback zu benutzerdefinierten Regeln erhalten:
   ```bash
   claude auto-mode critique
   ```

## Schritt or: Eine Sitzung starten und in den Auto-Modus wechseln

1. Navigieren Sie zu Ihrem Projekt:
   ```bash
   cd /pfad/zu/ihrem-projekt
   ```

2. Claude Code mit aktiviertem Auto-Modus starten:
   ```bash
   claude --enable-auto-mode
   ```

3. **Während der Sitzung zwischen Modi wechseln**:
   - Drücken Sie wiederholt **Shift + Tab** (oder Alt + M) zum Durchschalten: `default` → `acceptEdits` → `plan` → `auto`.
   - Der aktuelle Modus wird in der Statusleiste angezeigt.

4. Geben Sie Claude eine Aufgabe. Beispiel:
   ```text
   Refaktorieren Sie das Authentifizierungsmodul, fügen Sie Unit-Tests hinzu und führen Sie die gesamte Testsuite aus.
   ```

Der Auto-Modus genehmigt nun automatisch risikoarme Tool-Aufrufe (Datei-Lesevorgänge, gezielte Bearbeitungen, Standard-Builds/Tests), während der Klassifizierer alles Risikobehaftete blockiert.

## Schritt 6: Best Practices für effektive Nutzung

- **Zuerst im Plan-Modus beginnen**: Wechseln Sie zu `plan` (zweimal Shift+Tab), prüfen Sie Claudes Plan und wechseln Sie dann in den Auto-Modus.
-b**Projektkontext hinzufügen**: Erstellen Sie eine `CLAUDE.md`-Datei im Root-Verzeichnis mit Codierungsstandards, Build-Befehlen und verbotenen Aktionen.
- **Checkpoints nutzen**: Claude speichert automatisch Zustände vor Änderungen. Zurückspulen mit zweimal `Esc` oder `/rewind`.
- **Mit Hooks kombinieren**: Konfigurieren Sie `.claude/settings.json` für automatisches Linting oder Tests nach Bearbeitungen.
. **Fortschritt überwachen**: Verwenden Sie den ausführlichen Modus (`Ctrl + R`), um die vollständige Begründung zu sehen.

## Häufige Probleme & Fehlerbehebung

- **Auto-Modus erscheint nicht im Zyklus**:
  - Stellen Sie sicher, dass Sie mit `--enable-auto-mode` gestartet haben.
  - Bestätigen Sie, dass Sie auf Team/Enterprise mit Sonnet 4.6 oder Opus 4.6 sind.
  - Überprüfen Sie bei einer Organisation die Administrator-Einstellungen.

- **Klassifikator blockiert legitime Aktionen**:
  - Fügen Sie explizite Regeln zu `autoMode.allow` oder `environment` hinzu.
  - Verwenden Sie `claude auto-mode critique` für Vorschläge.
  - Geben Sie klarere Aufgabenanweisungen oder wechseln Sie vorübergehend zu `acceptEdits`.

- **Höhere Latenz oder Token-Verbrauch**:
  - Erwartet aufgrund des Hintergrund-Klassifikators. Nur für längere Sitzungen verwenden.

- **Berechtigungsfehler auf geschützten Pfaden**:
  - `.git`, `.claude`, etc., fordern in den meisten Modi weiterhin Eingaben. Verwenden Sie isolierte Umgebungen (Docker/VM) für volle Autonomie.

- **Sitzung wird unerwartet beendet**:
  - Führen Sie `claude -c` aus, um das letzte Gespräch fortzusetzen.

## Nächste Schritte

- Erkunden Sie den **Plan-Modus** für komplexe Refactorings, bevor Sie zum Auto-Modus wechseln.
-- Richten Sie **benutzerdefinierte Befehle** und **Hooks** für wiederholbare Workflows ein.
- Probieren Sie **Sub-Agenten** für parallele Aufgaben aus (z.B. Frontend + Backend).
/ Integrieren Sie mit CI/CD über GitHub Actions für vollautomatisierte Pipelines.
- Experimentieren Sie in einem verworfenen Git-Branch oder Docker-Container zur Sicherheit.

Wenn der Auto-Modus aktiviert und korrekt konfiguriert ist, können Sie stundenlange autonome Codierungs-Sitzungen mit deutlich weniger Unterbrechungen durchführen, während starke Sicherheitsvorkehrungen erhalten bleiben. Beginnen Sie heute mit einer einfachen Aufgabe und erweitern Sie nach und nach Ihre vertrauenswürdigen Umgebungsregeln, während Sie an Vertrauen gewinnen.