Documentation — Spybara

admin-setup.md +1 −0

Details

74| [MCP-Server-Kontrolle](/de/mcp#managed-mcp-configuration) | Einschränken, welche MCP-Server Benutzer hinzufügen oder verbinden können | `allowedMcpServers`, `deniedMcpServers`, `allowManagedMcpServersOnly` |74| [MCP-Server-Kontrolle](/de/mcp#managed-mcp-configuration) | Einschränken, welche MCP-Server Benutzer hinzufügen oder verbinden können | `allowedMcpServers`, `deniedMcpServers`, `allowManagedMcpServersOnly` |

75| [Plugin-Marketplace-Kontrolle](/de/plugin-marketplaces#managed-marketplace-restrictions) | Einschränken, von welchen Marketplace-Quellen Benutzer hinzufügen und installieren können | `strictKnownMarketplaces`, `blockedMarketplaces` |75| [Plugin-Marketplace-Kontrolle](/de/plugin-marketplaces#managed-marketplace-restrictions) | Einschränken, von welchen Marketplace-Quellen Benutzer hinzufügen und installieren können | `strictKnownMarketplaces`, `blockedMarketplaces` |

76| [Hook-Einschränkungen](/de/settings#hook-configuration) | Nur verwaltete Hooks werden geladen; HTTP-Hook-URLs einschränken | `allowManagedHooksOnly`, `allowedHttpHookUrls` |76| [Hook-Einschränkungen](/de/settings#hook-configuration) | Nur verwaltete Hooks werden geladen; HTTP-Hook-URLs einschränken | `allowManagedHooksOnly`, `allowedHttpHookUrls` |

77| [Agent-Ansicht deaktivieren](/de/agent-view#how-background-sessions-are-hosted) | Schalten Sie `claude agents`, `--bg`, `/background` und den On-Demand-Supervisor aus | `disableAgentView` |

78 79

79Berechtigungsregeln und Sandboxing decken verschiedene Ebenen ab. Das Ablehnen von WebFetch blockiert Claudes Fetch-Tool, aber wenn Bash zulässig ist, können `curl` und `wget` immer noch jede URL erreichen. Sandboxing schließt diese Lücke mit einer auf Betriebssystemebene durchgesetzten Netzwerk-Domain-Allowlist.80Berechtigungsregeln und Sandboxing decken verschiedene Ebenen ab. Das Ablehnen von WebFetch blockiert Claudes Fetch-Tool, aber wenn Bash zulässig ist, können `curl` und `wget` immer noch jede URL erreichen. Sandboxing schließt diese Lücke mit einer auf Betriebssystemebene durchgesetzten Netzwerk-Domain-Allowlist.

agent-sdk/overview.md +2 −1

Details

90 Das SDK unterstützt auch Authentifizierung über Drittanbieter-API-Anbieter:90 Das SDK unterstützt auch Authentifizierung über Drittanbieter-API-Anbieter:

91 91

92 * **Amazon Bedrock**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_BEDROCK=1` und konfigurieren Sie AWS-Anmeldedaten92 * **Amazon Bedrock**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_BEDROCK=1` und konfigurieren Sie AWS-Anmeldedaten

93 * **Claude Platform on AWS**: Setzen Sie `CLAUDE_CODE_USE_ANTHROPIC_AWS=1` und `ANTHROPIC_AWS_WORKSPACE_ID` und konfigurieren Sie AWS-Anmeldedaten

93 * **Google Vertex AI**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_VERTEX=1` und konfigurieren Sie Google Cloud-Anmeldedaten94 * **Google Vertex AI**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_VERTEX=1` und konfigurieren Sie Google Cloud-Anmeldedaten

94 * **Microsoft Azure**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_FOUNDRY=1` und konfigurieren Sie Azure-Anmeldedaten95 * **Microsoft Azure**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_FOUNDRY=1` und konfigurieren Sie Azure-Anmeldedaten

95 96

~~96 Weitere Informationen finden Sie in den Einrichtungsleitfäden für [Bedrock](/de/amazon-bedrock), [Vertex AI](/de/google-vertex-ai) oder [Azure AI Foundry](/de/microsoft-foundry).~~97 Weitere Informationen finden Sie in den Einrichtungsleitfäden für [Bedrock](/de/amazon-bedrock), [Claude Platform on AWS](/de/claude-platform-on-aws), [Vertex AI](/de/google-vertex-ai) oder [Azure AI Foundry](/de/microsoft-foundry).

97 98

98 <Note>99 <Note>

99 Sofern nicht zuvor genehmigt, erlaubt Anthropic Drittentwicklern nicht, claude.ai-Anmeldungen oder Ratenlimits für ihre Produkte anzubieten, einschließlich Agenten, die auf dem Claude Agent SDK basieren. Verwenden Sie stattdessen die in diesem Dokument beschriebenen API-Schlüssel-Authentifizierungsmethoden.100 Sofern nicht zuvor genehmigt, erlaubt Anthropic Drittentwicklern nicht, claude.ai-Anmeldungen oder Ratenlimits für ihre Produkte anzubieten, einschließlich Agenten, die auf dem Claude Agent SDK basieren. Verwenden Sie stattdessen die in diesem Dokument beschriebenen API-Schlüssel-Authentifizierungsmethoden.

agent-sdk/python.md +8 −6

Details

2608 2608

2609```python theme={null}2609```python theme={null}

2610{2610{

2611 "response": str, # Antwort des KI-Modells auf den Prompt2611 "bytes": int, # Größe des abgerufenen Inhalts in Bytes

2612 "code": int, # HTTP-Antwortcode

2613 "codeText": str, # HTTP-Antwortcodetext

2614 "result": str, # Verarbeitetes Ergebnis aus der Anwendung des Prompts auf den Inhalt

2615 "durationMs": int, # Zeit zum Abrufen und Verarbeiten des Inhalts in Millisekunden

2612 "url": str, # URL, die abgerufen wurde2616 "url": str, # URL, die abgerufen wurde

2613 "final_url": str | None, # Endgültige URL nach Umleitungen

2614 "status_code": int | None, # HTTP-Statuscode

2615}2617}

2616```2618```

2617 2619

2633 2635

2634```python theme={null}2636```python theme={null}

2635{2637{

2636 "results": [{"title": str, "url": str, "snippet": str, "metadata": dict | None}],2638 "query": str, # Die Suchanfrage

2637 "total_results": int,2639 "results": list[str | {"tool_use_id": str, "content": list[{"title": str, "url": str}]}],

2638 "query": str,2640 "durationSeconds": float, # Suchdauer in Sekunden

2639}2641}

2640```2642```

2641 2643

agent-sdk/quickstart.md +3 −2

Details

75 Das SDK unterstützt auch Authentifizierung über Drittanbieter-API-Anbieter:75 Das SDK unterstützt auch Authentifizierung über Drittanbieter-API-Anbieter:

76 76

77 * **Amazon Bedrock**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_BEDROCK=1` und konfigurieren Sie AWS-Anmeldedaten77 * **Amazon Bedrock**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_BEDROCK=1` und konfigurieren Sie AWS-Anmeldedaten

78 * **Claude Platform on AWS**: Setzen Sie `CLAUDE_CODE_USE_ANTHROPIC_AWS=1` und `ANTHROPIC_AWS_WORKSPACE_ID` und konfigurieren Sie AWS-Anmeldedaten

78 * **Google Vertex AI**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_VERTEX=1` und konfigurieren Sie Google Cloud-Anmeldedaten79 * **Google Vertex AI**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_VERTEX=1` und konfigurieren Sie Google Cloud-Anmeldedaten

79 * **Microsoft Azure**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_FOUNDRY=1` und konfigurieren Sie Azure-Anmeldedaten80 * **Microsoft Azure**: Setzen Sie die Umgebungsvariable `CLAUDE_CODE_USE_FOUNDRY=1` und konfigurieren Sie Azure-Anmeldedaten

80 81

~~81 Weitere Informationen finden Sie in den Einrichtungsleitfäden für [Bedrock](/de/amazon-bedrock), [Vertex AI](/de/google-vertex-ai) oder [Azure AI Foundry](/de/microsoft-foundry).~~82 Weitere Informationen finden Sie in den Einrichtungsleitfäden für [Bedrock](/de/amazon-bedrock), [Claude Platform on AWS](/de/claude-platform-on-aws), [Vertex AI](/de/google-vertex-ai) oder [Azure AI Foundry](/de/microsoft-foundry).

82 83

83 <Note>84 <Note>

84 Sofern nicht zuvor genehmigt, erlaubt Anthropic Drittentwicklern nicht, claude.ai-Anmeldungen oder Ratenlimits für ihre Produkte anzubieten, einschließlich Agenten, die auf dem Claude Agent SDK basieren. Verwenden Sie stattdessen die in diesem Dokument beschriebenen API-Schlüssel-Authentifizierungsmethoden.85 Sofern nicht zuvor genehmigt, erlaubt Anthropic Drittentwicklern nicht, claude.ai-Anmeldungen oder Ratenlimits für ihre Produkte anzubieten, einschließlich Agenten, die auf dem Claude Agent SDK basieren. Verwenden Sie stattdessen die in diesem Dokument beschriebenen API-Schlüssel-Authentifizierungsmethoden.

173 174

1742. **`prompt`**: was Sie Claude tun möchten. Claude ermittelt basierend auf der Aufgabe, welche Tools verwendet werden sollen.1752. **`prompt`**: was Sie Claude tun möchten. Claude ermittelt basierend auf der Aufgabe, welche Tools verwendet werden sollen.

175 176

1763. **`options`**: Konfiguration für den Agenten. Dieses Beispiel verwendet `allowedTools`, um `Read`, `Edit` und `Glob` vorab zu genehmigen, und `permissionMode: "acceptEdits"`, um Dateiänderungen automatisch zu genehmigen. Weitere Optionen sind `systemPrompt`, `mcpServers` und mehr. Siehe alle Optionen für [Python](/de/agent-sdk/python#claude-agent-options) oder [TypeScript](/de/agent-sdk/typescript#options).1773. **`options`**: Konfiguration für den Agenten. Dieses Beispiel verwendet `allowedTools`, um `Read`, `Edit` und `Glob` vorab zu genehmigen, und `permissionMode: "acceptEdits"`, um Dateiänderungen automatisch zu genehmigen. Weitere Optionen sind `systemPrompt`, `mcpServers` und mehr. Siehe alle Optionen für [Python](/de/agent-sdk/python#claudeagentoptions) oder [TypeScript](/de/agent-sdk/typescript#options).

177 178

178Die `async for`-Schleife läuft weiter, während Claude denkt, Tools aufruft, Ergebnisse beobachtet und entscheidet, was als nächstes zu tun ist. Jede Iteration ergibt eine Nachricht: Claudes Überlegung, ein Tool-Aufruf, ein Tool-Ergebnis oder das endgültige Ergebnis. Das SDK verwaltet die Orchestrierung (Tool-Ausführung, Kontextverwaltung, Wiederholungen), sodass Sie einfach den Stream verbrauchen. Die Schleife endet, wenn Claude die Aufgabe abschließt oder auf einen Fehler stößt.179Die `async for`-Schleife läuft weiter, während Claude denkt, Tools aufruft, Ergebnisse beobachtet und entscheidet, was als nächstes zu tun ist. Jede Iteration ergibt eine Nachricht: Claudes Überlegung, ein Tool-Aufruf, ein Tool-Ergebnis oder das endgültige Ergebnis. Das SDK verwaltet die Orchestrierung (Tool-Ausführung, Kontextverwaltung, Wiederholungen), sodass Sie einfach den Stream verbrauchen. Die Schleife endet, wenn Claude die Aufgabe abschließt oder auf einen Fehler stößt.

179 180

agent-view.md +295 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Mehrere Agenten mit der Agenten-Ansicht verwalten

7> Versenden und verwalten Sie viele Claude Code-Sitzungen von einem Bildschirm aus. Die Agenten-Ansicht zeigt, was jede Sitzung tut und welche Ihre Eingabe benötigen.

9Die Agenten-Ansicht, die mit `claude agents` geöffnet wird, ist ein Bildschirm für alle Ihre Hintergrund-Sitzungen: was läuft, was Ihre Eingabe benötigt und was erledigt ist. Versenden Sie neue Sitzungen, beobachten Sie ihren Status auf einen Blick, anstatt durch Transkripte zu scrollen, und greifen Sie nur ein, wenn eine Sitzung Sie benötigt. Sitzungen laufen im Hintergrund weiter, ohne dass ein Terminal angeschlossen ist.

11Verwenden Sie die Agenten-Ansicht, wenn Sie mehrere unabhängige Aufgaben haben, an denen Claude gleichzeitig arbeiten kann, z. B. das Beheben eines Fehlers, das Überprüfen eines Pull Requests oder das Untersuchen eines Protokolls. Wenn Sie ein Problem zusammen durcharbeiten möchten, hängen Sie sich an eine Sitzung an und verwenden Sie Claude Code interaktiv wie gewohnt.

13Sitzungen in der Agenten-Ansicht laufen unabhängig und berichten nur an Sie. Um mit Subagenten, Agent-Teams und Worktrees zu vergleichen, siehe [Agenten parallel ausführen](/de/agents).

15<Note>

16 Die Agenten-Ansicht ist eine Forschungsvorschau und erfordert Claude Code v2.1.139 oder später. Überprüfen Sie Ihre Version mit `claude --version`. Die Benutzeroberfläche und Tastaturkürzel können sich ändern, wenn sich die Funktion weiterentwickelt, und Administratoren können die Agenten-Ansicht für eine Organisation mit der verwalteten Einstellung [`disableAgentView`](#how-background-sessions-are-hosted) deaktivieren.

17</Note>

19Diese Seite behandelt:

21* [Schnellstart](#quick-start)

22* [Sitzungen mit der Agenten-Ansicht überwachen](#monitor-sessions-with-agent-view), einschließlich Statussymbole, Vorschau und Antwort, Anhängen, Organisieren und Tastaturkürzel

23* [Neue Agenten versenden](#dispatch-new-agents) aus der Agenten-Ansicht, aus einer Sitzung heraus oder aus der Shell

24* [Sitzungen aus der Shell verwalten](#manage-sessions-from-the-shell)

25* [Wie Hintergrund-Sitzungen gehostet werden](#how-background-sessions-are-hosted) durch den Supervisor-Prozess

27## Schnellstart

29Diese Anleitung öffnet die Agenten-Ansicht, versendet eine Sitzung, antwortet aus dem Vorschau-Panel und hängt sich für das vollständige Gespräch an.

31<Steps>

32 <Step title="Agenten-Ansicht öffnen">

33 Führen Sie in Ihrer Shell aus:

35 ```bash theme={null}

36 claude agents

37 ```

39 Die Agenten-Ansicht öffnet sich mit einer Eingabe am unteren Rand und einer Tabelle, die sich füllt, wenn Sitzungen starten. Drücken Sie jederzeit `Esc`, um zu beenden. Ihre Sitzungen laufen weiter.

40 </Step>

42 <Step title="Eine Sitzung versenden">

43 Geben Sie eine Eingabeaufforderung in die Eingabe ein und drücken Sie `Enter`. Eine neue Sitzung startet und wird als Zeile angezeigt, die zeigt, ob sie funktioniert, auf Sie wartet oder erledigt ist. Wiederholen Sie dies, um so viele Sitzungen parallel auszuführen, wie Sie möchten.

44 </Step>

46 <Step title="Vorschau und Antwort">

47 Wählen Sie eine Zeile mit den Pfeiltasten aus und drücken Sie `Space`, um zu sehen, was die Sitzung tut oder was sie von Ihnen benötigt. Geben Sie eine Antwort ein und drücken Sie `Enter`, um sie zu senden, ohne die Agenten-Ansicht zu verlassen.

48 </Step>

50 <Step title="Anhängen und Abhängen">

51 Drücken Sie `Enter` oder `→` auf einer Zeile, um sich anzuhängen, wenn Sie das vollständige Gespräch möchten. Die Sitzung übernimmt das Terminal genau so, als hätten Sie `claude` ausgeführt. Drücken Sie `←` auf einer leeren Eingabeaufforderung, um sich abzuhängen und zur Tabelle zurückzukehren.

52 </Step>

53</Steps>

55Um eine vorhandene interaktive Sitzung in die Agenten-Ansicht zu bringen, führen Sie `/bg` darin aus, oder drücken Sie `←` auf einer leeren Eingabeaufforderung, um die Sitzung in den Hintergrund zu verschieben und die Agenten-Ansicht in einem Schritt zu öffnen. Die Sitzung läuft im Hintergrund weiter und wird als Zeile angezeigt. Um eine neue Hintergrund-Sitzung direkt aus der Shell zu starten, führen Sie `claude --bg "<prompt>"` aus.

57Sie können `claude agents` als Ihren primären Einstiegspunkt anstelle von `claude` verwenden: versenden Sie jede Aufgabe aus der Agenten-Ansicht, hängen Sie sich an, wenn Sie das vollständige Gespräch möchten, und drücken Sie `←`, um zur Tabelle zurückzukehren.

59## Sitzungen mit der Agenten-Ansicht überwachen

61Führen Sie `claude agents` aus, um die Agenten-Ansicht zu öffnen. Sie übernimmt das gesamte Terminal und listet jede Sitzung nach Status gruppiert auf, mit angehefteten Sitzungen und denjenigen, die Sie benötigen, oben. Jede Zeile zeigt den Namen der Sitzung, die aktuelle Aktivität und wie lange die letzte Änderung her ist.

63Die Liste ist global für Ihren Computer und umfasst jede Hintergrund-Sitzung, unabhängig davon, in welchem Projekt oder Worktree sie funktioniert. Interaktive Sitzungen, die Sie in anderen Terminals offen haben, werden nicht angezeigt, bis Sie sie [in den Hintergrund verschieben](#from-inside-a-session), und [Subagenten](/de/sub-agents), die in einer Sitzung laufen, werden nicht als separate Zeilen aufgelistet.

65```text theme={null}

66Angeheftet

67 ✽ clawd walk cycle Write assets/sprites/clawd-walk.png 3m

69Bereit zur Überprüfung

70 ∙ jump physics github.com/anthropics/example/pull/2048 2h

72Benötigt Eingabe

73 ✻ power-up design needs input: double jump or wall climb? 1m

75Funktioniert

76 ✽ collision detection Edit src/physics/CollisionSystem.ts 2m

77 ✢ playtest level 3 run 12 · all checkpoints cleared in 4m

79Abgeschlossen

80 ✻ title screen result: menu, options, and credits done 9m

81 ∙ sound effects result: 14 SFX exported to assets/audio 4h

82 … 6 more

83```

85Das Symbol zeigt den Status der Sitzung:

87| Symbol | Status | Was es bedeutet |

88| :------- | :--------------- | :-------------------------------------------------------------------------------------------- |

89| Animiert | Funktioniert | Claude führt aktiv Tools aus oder generiert eine Antwort |

90| Gelb | Benötigt Eingabe | Claude wartet auf Ihre Eingabe, normalerweise eine Genehmigungsentscheidung oder eine Antwort |

91| Gedimmt | Untätig | Die Sitzung wartet auf Eingabe, ist aber nicht an einer bestimmten Frage blockiert |

92| Grün | Abgeschlossen | Die Aufgabe wurde erfolgreich abgeschlossen |

93| Rot | Fehlgeschlagen | Die Aufgabe endete mit einem Fehler |

94| Grau | Gestoppt | Die Sitzung wurde mit `Ctrl+X` oder `claude stop` gestoppt |

96Die Form des Symbols zeigt, ob der zugrunde liegende Prozess noch läuft. Ein `✻` oder ein animiertes `✽`, während Claude funktioniert, bedeutet, dass die Sitzung aktiv ist und Sie sofort darauf antworten können. Ein `∙` bedeutet, dass der Prozess beendet wurde, aber Sie können immer noch Vorschau anzeigen, antworten oder anhängen: Claude startet die Sitzung von dort neu, wo sie aufgehört hat. Ein `✢` ist eine [`/loop`](/de/commands)-Sitzung, die zwischen Iterationen schläft, wobei die Zeile ihre Laufzahl und einen Countdown zur nächsten Iteration anzeigt.

98Hintergrund-Sitzungen benötigen kein offenes Terminal, um weiter zu funktionieren. Ein separater [Supervisor-Prozess](#how-background-sessions-are-hosted) führt sie aus, sodass Sie die Agenten-Ansicht schließen, Ihre Shell schließen oder eine neue interaktive Sitzung starten können und Ihre versendete Arbeit läuft weiter.

100Sitzungen werden auf der Festplatte beibehalten: Das Schließen Ihres Terminals oder ein automatisches Update verliert sie nicht, und das erneute Öffnen von `claude agents` zeigt sie alle. Wenn Ihr Computer in den Ruhezustand wechselt oder heruntergefahren wird, werden laufende Sitzungen gestoppt; starten Sie sie mit `claude respawn --all` neu.

101

102Die einzeilige Zusammenfassung in jeder Zeile wird von Ihrem konfigurierten [Haiku-Klasse-Modell](/de/model-config) generiert, sodass die Zeile Ihnen zeigen kann, was die Sitzung tut, was sie benötigt oder was sie produziert hat, ohne das Transkript zu öffnen. Jede Zusammenfassung ist eine kurze Haiku-Klasse-Anfrage durch Ihren normalen Anbieter, abgerechnet und behandelt unter denselben [Datennutzungsbedingungen](/de/data-usage) wie die Sitzung selbst.

103

104Wenn eine Sitzung einen Pull Request öffnet, zeigt die Zeile den PR-Link und einen Statusindikator für ihre CI-Überprüfungen. Für die meisten Aufgaben ist diese Zeile, wie Sie die Arbeit sammeln: überprüfen und führen Sie den Pull Request zusammen, wenn seine Überprüfungen bestanden sind.

105

106### Vorschau und Antwort

107

108Drücken Sie `Space` auf einer ausgewählten Zeile, um das Vorschau-Panel zu öffnen. Es zeigt, was die Sitzung von Ihnen benötigt, ihre neueste Ausgabe und alle Pull Requests, die sie geöffnet hat. Meistens reicht dies aus, und Sie müssen das vollständige Transkript nie öffnen.

109

110Geben Sie eine Antwort im Vorschau-Panel ein und drücken Sie `Enter`, um sie an diese Sitzung zu senden. Wenn die Sitzung eine Multiple-Choice-Frage stellt, zeigt das Vorschau-Panel die Optionen an und Sie können eine Zahlentaste drücken, um eine auszuwählen. Für andere blockierte Sitzungen drücken Sie `Tab`, um die Eingabe mit einer vorgeschlagenen Antwort zu füllen, die Sie vor dem Senden bearbeiten können. Präfixieren Sie eine Antwort mit `!`, um stattdessen einen Bash-Befehl zu senden.

111

112Verwenden Sie `↑` und `↓`, um benachbarte Sitzungen in der Vorschau anzuzeigen, ohne das Panel zu schließen, oder `→`, um sich anzuhängen.

113

114### An eine Sitzung anhängen

115

116Drücken Sie `Enter` oder `→` auf einer ausgewählten Zeile, um sich anzuhängen, oder drücken Sie `Alt+1` bis `Alt+9`, um sich direkt an die N-te Sitzung in der fokussierten Gruppe anzuhängen. Die Agenten-Ansicht wird durch die vollständige interaktive Sitzung ersetzt, genau so, als hätten Sie `claude` in diesem Verzeichnis ausgeführt. Wenn Sie sich anhängen, sendet Claude eine kurze Zusammenfassung dessen, was passiert ist, während Sie weg waren.

117

118Während Sie angehängt sind, verhält sich die Sitzung wie jede andere Claude Code-Sitzung: jeder [Befehl](/de/commands), Tastaturkürzel und jede Funktion funktioniert.

119

120Drücken Sie `←` auf einer leeren Eingabeaufforderung, um sich abzuhängen und zur Agenten-Ansicht zurückzukehren. Wenn ein Dialog den Fokus hat und nicht auf `←` reagiert, drücken Sie `Ctrl+Z`, um sich sofort abzuhängen.

121

122Das Abhängen stoppt niemals eine Hintergrund-Sitzung: `←`, `Ctrl+C`, `Ctrl+D`, `Ctrl+Z` und `/exit` lassen sie alle laufen. Um eine Sitzung von innen zu beenden, führen Sie `/stop` aus.

123

124Nachdem Sie die Agenten-Ansicht verwendet haben, funktioniert das Drücken von `←` auf einer leeren Eingabeaufforderung aus jeder Claude Code-Sitzung, nicht nur aus denjenigen, an denen Sie angehängt sind. Es öffnet die Agenten-Ansicht mit Ihrer aktuellen Sitzung vorausgewählt, sodass Sie zwischen Sitzungen wechseln können, ohne das Terminal zu verlassen.

125

126### Die Liste organisieren

127

128Die Agenten-Ansicht gruppiert Sitzungen nach Status, mit Sitzungen, die Eingabe benötigen, über Sitzungen, die funktionieren oder erledigt sind. Drücken Sie `Ctrl+S`, um stattdessen nach Verzeichnis zu gruppieren. Ihre Wahl wird über Läufe hinweg gespeichert. Heften Sie innerhalb einer Gruppe eine Sitzung mit `Ctrl+T` oben an, ordnen Sie mit `Shift+↑` und `Shift+↓` neu an, oder drücken Sie `Enter` auf einem Gruppenkopf, um ihn zu reduzieren. Um eine Sitzung zu entfernen, drücken Sie `Ctrl+X`, um sie zu stoppen, und `Ctrl+X` erneut innerhalb von zwei Sekunden, um sie zu löschen. Das Drücken von `Ctrl+X` auf einem Gruppenkopf löscht jede Sitzung in dieser Gruppe nach Bestätigung.

129

130Ältere abgeschlossene Sitzungen werden in eine Zeile „… N more" eingeklappt, um die Liste kurz zu halten. Fehler und Sitzungen mit einem offenen Pull Request bleiben immer sichtbar.

131

132### Die Liste filtern

133

134Geben Sie in die Versand-Eingabe ein, um zu filtern, anstatt zu versenden:

135

136| Filter | Zeigt |

137| :--------------------------- | :---------------------------------------------------------------------------------- |

138| `a:<name>` | Sitzungen, die den benannten Agenten ausführen |

139| `s:<state>` | Sitzungen im angegebenen Status, z. B. `s:blocked` für Sitzungen, die Sie benötigen |

140| `#<number>` oder eine PR-URL | Die Sitzung, die an diesem Pull Request funktioniert |

141

142### Tastaturkürzel

143

144Drücken Sie `?` in der Agenten-Ansicht, um jedes Kürzel zu sehen. Die häufigsten:

145

146| Kürzel | Aktion |

147| :-------------------- | :----------------------------------------------------------------------------------------- |

148| `↑` / `↓` | Zwischen Zeilen verschieben |

149| `Enter` | An die ausgewählte Sitzung anhängen oder versenden, wenn Text in der Eingabe vorhanden ist |

150| `Space` | Vorschau-Panel für die ausgewählte Sitzung öffnen oder schließen |

151| `Shift+Enter` | Versenden und sofort anhängen |

152| `→` | An die ausgewählte Sitzung anhängen |

153| `Alt+1`..`Alt+9` | An die N-te Sitzung in der fokussierten Gruppe anhängen |

154| `Tab` | Alle Subagenten durchsuchen oder den hervorgehobenen Vorschlag anwenden |

155| `Ctrl+S` | Gruppierung zwischen Status und Verzeichnis wechseln |

156| `Ctrl+T` | Ausgewählte Sitzung anheften oder abheften |

157| `Ctrl+R` | Ausgewählte Sitzung umbenennen |

158| `Ctrl+G` | Versand-Eingabeaufforderung in Ihrem `$EDITOR` öffnen |

159| `Ctrl+X` | Sitzung stoppen; drücken Sie erneut innerhalb von zwei Sekunden, um sie zu löschen |

160| `Shift+↑` / `Shift+↓` | Ausgewählte Sitzung neu anordnen |

161| `Esc` | Vorschau-Panel schließen, Eingabe löschen oder beenden |

162| `Ctrl+C` | Eingabe löschen; zweimal drücken, um zu beenden |

163| `?` | Alle Kürzel anzeigen |

164

165## Neue Agenten versenden

166

167Sie können neue Hintergrund-Sitzungen aus der Agenten-Ansicht versenden, eine vorhandene interaktive Sitzung in den Hintergrund verschieben oder eine direkt aus der Shell starten.

168

169### Aus der Agenten-Ansicht

170

171Geben Sie eine Eingabeaufforderung in die Eingabe am unteren Rand der Agenten-Ansicht ein und drücken Sie `Enter`, um eine neue Hintergrund-Sitzung zu starten. Die Sitzung wird automatisch aus der Eingabeaufforderung benannt. Sie können sie später mit `Ctrl+R` umbenennen. Fügen Sie ein Bild in die Eingabeaufforderung ein, um einen Screenshot oder ein Diagramm mit der Aufgabe einzubeziehen.

172

173Präfixieren oder erwähnen Sie Teile der Eingabeaufforderung, um zu steuern, wie die Sitzung startet:

174

175| Eingabe | Effekt |

176| :------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

177| `<agent-name> <prompt>` | Wenn das erste Wort einem benutzerdefinierten [Subagenten](/de/sub-agents)-Namen entspricht, wird dieser Subagent als Hauptagent der Sitzung mit der Konfiguration aus seinem Frontmatter ausgeführt |

178| `@<agent-name>` | Erwähnen Sie einen benutzerdefinierten Subagenten überall in der Eingabeaufforderung, um ihn als Hauptagent auszuführen |

179| `@<repo>` | Erwähnen Sie ein Repository unter dem Verzeichnis, in dem Sie die Agenten-Ansicht geöffnet haben, um die Sitzung dort auszuführen |

180| `/<skill>` | Schlagen Sie [Skills](/de/skills) vor, um als Eingabeaufforderung zu versenden |

181| `#<number>` oder eine Pull Request-URL | Wenn eine Sitzung bereits an diesem PR funktioniert, wählen Sie sie aus, anstatt zu versenden |

182| `Shift+Enter` | Versenden und sofort an die neue Sitzung anhängen |

183

184Geben Sie `/` ein, um einen [Skill](/de/skills) zu versenden. Das Verpacken einer wiederkehrenden Aufgabe als Skill ermöglicht es Ihnen, denselben Workflow viele Male aus der Agenten-Ansicht zu starten, ohne die Eingabeaufforderung erneut einzugeben. Drücken Sie `Tab` auf einer leeren Eingabe, um jeden versandbaren Subagenten zu durchsuchen, oder um den hervorgehobenen Vorschlag anzuwenden, wenn Vorschläge angezeigt werden.

185

186#### In ein bestimmtes Verzeichnis versenden

187

188Eine neue Sitzung läuft in dem Verzeichnis, in dem Sie die Agenten-Ansicht geöffnet haben. Um ein anderes Verzeichnis anzusteuern:

189

190* Öffnen Sie `claude agents` in diesem Verzeichnis.

191* Öffnen Sie `claude agents` in einem übergeordneten Verzeichnis, das mehrere Repositories enthält, und erwähnen Sie eines mit `@<repo>` in der Eingabeaufforderung, um die Sitzung dort auszuführen.

192* Führen Sie in der Shell `cd` in das Verzeichnis aus und führen Sie `claude --bg "<prompt>"` aus.

193

194Wenn die Agenten-Ansicht nach Verzeichnis gruppiert ist, wird das Verzeichnis der hervorgehobenen Zeile zum Versand-Ziel, sodass Sie zu einer Gruppe scrollen und darin versenden können, ohne den Pfad erneut einzugeben.

195

196#### Dateibearbeitungen in einem Worktree isolieren

197

198Sitzungen, die aus der Agenten-Ansicht versendet werden, teilen standardmäßig Ihr Arbeitsverzeichnis, sodass zwei Agenten, die dieselben Dateien bearbeiten, in Konflikt geraten können. Um dies zu verhindern, blockiert Claude Code eine Sitzung, die aus der Agenten-Ansicht versendet wird, vom Schreiben von Dateien, bis sie sich in einen isolierten [Git-Worktree](/de/worktrees) bewegt. Claude handhabt dies automatisch, wenn es Dateien bearbeiten muss. Der Worktree wird unter `.claude/worktrees/` im Projektverzeichnis erstellt und entfernt, wenn Sie die Sitzung löschen. Das Löschen einer Sitzung löscht auch ihren Worktree, daher führen Sie die Änderungen zusammen oder pushen Sie sie, die Sie behalten möchten, bevor Sie die Sitzung löschen.

199

200Um einen Subagenten immer in seinem eigenen Worktree auszuführen, unabhängig davon, wie er gestartet wurde, setzen Sie [`isolation: worktree`](/de/sub-agents#supported-frontmatter-fields) in seinem Frontmatter.

201

202### Aus einer Sitzung heraus

203

204Führen Sie `/background` oder seinen Alias `/bg` aus, um das aktuelle Gespräch zu trennen und es weiter laufen zu lassen. Übergeben Sie eine Eingabeaufforderung wie `/bg run the test suite and fix any failures`, um eine weitere Anweisung zu senden, bevor Sie sich trennen.

205

206### Aus der Shell

207

208Übergeben Sie `--bg`, um eine Sitzung zu starten, die direkt in den Hintergrund geht:

209

210```bash theme={null}

211claude --bg "investigate the flaky SettingsChangeDetector test"

212```

213

214Um einen bestimmten Subagenten als Hauptagent der Sitzung auszuführen, kombinieren Sie `--bg` mit `--agent`:

215

216```bash theme={null}

217claude --agent code-reviewer --bg "address review comments on PR 1234"

218```

219

220Nach dem Versenden druckt Claude die kurze ID der Sitzung und die Befehle zu ihrer Verwaltung:

221

222```text theme={null}

223backgrounded · 7c5dcf5d

224 claude agents list sessions

225 claude attach 7c5dcf5d open in this terminal

226 claude logs 7c5dcf5d show recent output

227 claude stop 7c5dcf5d stop this session

228```

229

230## Sitzungen aus der Shell verwalten

231

232Jede Hintergrund-Sitzung hat eine kurze ID, die Sie aus der Shell verwenden können. Diese Befehle sind nützlich zum Scripting oder wenn Sie die Agenten-Ansicht nicht öffnen möchten.

233

234| Befehl | Zweck |

235| :--------------------- | :----------------------------------------------------------- |

236| `claude agents` | Agenten-Ansicht öffnen |

237| `claude attach <id>` | An eine Sitzung in diesem Terminal anhängen |

238| `claude logs <id>` | Neueste Ausgabe der Sitzung drucken |

239| `claude stop <id>` | Eine Sitzung stoppen. Akzeptiert auch `claude kill` |

240| `claude respawn <id>` | Eine gestoppte Sitzung mit ihrem Gespräch intakt neu starten |

241| `claude respawn --all` | Jede gestoppte Sitzung neu starten |

242| `claude rm <id>` | Eine Sitzung aus der Liste entfernen |

243

244## Wie Hintergrund-Sitzungen gehostet werden

245

246Hintergrund-Sitzungen werden von einem Supervisor-Prozess pro Benutzer gehostet, getrennt von Ihrem Terminal und von der Agenten-Ansicht. Es startet automatisch, wenn Sie zum ersten Mal eine Sitzung in den Hintergrund verschieben oder die Agenten-Ansicht öffnen, und Sie verwalten es nicht direkt. Der Supervisor und seine Sitzungen authentifizieren sich mit denselben Anmeldedaten wie Ihre interaktiven Sitzungen und stellen keine zusätzlichen Netzwerkverbindungen über die Modell-API hinaus her.

247

248Jede Hintergrund-Sitzung ist ihr eigener Claude Code-Prozess, übergeordnet zum Supervisor anstelle zu Ihrem Terminal. Eine Sitzung, die aktiv funktioniert, auf Ihre Eingabe wartet oder ein Terminal angehängt hat, behält ihren Prozess am Laufen. Sobald eine Sitzung fertig ist und etwa eine Stunde lang unverbunden sitzt, stoppt der Supervisor seinen Prozess, um Ressourcen freizugeben. Das Transkript und der Status bleiben auf der Festplatte, und das nächste Mal, wenn Sie anhängen, Vorschau anzeigen oder antworten, startet der Supervisor einen frischen Prozess von dort, wo er aufgehört hat. Wenn jede Sitzung fertig ist und kein Terminal verbunden ist, beendet sich der Supervisor selbst und startet erneut, wenn Sie das nächste Mal eine Sitzung in den Hintergrund verschieben oder die Agenten-Ansicht öffnen.

249

250Der Supervisor beobachtet die installierte Claude Code-Binärdatei auf der Festplatte und startet in die neue Version neu, nachdem der reguläre [Auto-Updater](/de/setup#auto-updates) sie ersetzt. Dies ist eine lokale Dateiüberwachung, keine Netzwerkprüfung. Hintergrund-Sitzungen sind abgelöste Prozesse, daher laufen sie während des Neustarts weiter und der neue Supervisor verbindet sich wieder mit ihnen.

251

252Der Sitzungsstatus wird unter Ihrem Claude Code-Konfigurationsverzeichnis gespeichert. Wenn Sie [`CLAUDE_CONFIG_DIR`](/de/env-vars) setzen, verwendet der Supervisor stattdessen dieses Verzeichnis und läuft als separate Instanz mit ihren eigenen Sitzungen.

253

254| Pfad | Inhalt |

255| :------------------------------- | :----------------------------------------------------------------------------------------------------------- |

256| `~/.claude/daemon.log` | Supervisor-Protokoll |

257| `~/.claude/daemon/roster.json` | Liste der laufenden Hintergrund-Sitzungen, verwendet zum Wiederherstellen der Verbindung nach einem Neustart |

258| `~/.claude/jobs/<id>/state.json` | Pro-Sitzungs-Status in der Agenten-Ansicht angezeigt |

259

260Um Hintergrund-Agenten und die Agenten-Ansicht vollständig auszuschalten, setzen Sie die Einstellung `disableAgentView` [setting](/de/settings) auf `true` oder setzen Sie die Umgebungsvariable `CLAUDE_CODE_DISABLE_AGENT_VIEW`. Administratoren können dies durch [verwaltete Einstellungen](/de/permissions#managed-settings) erzwingen.

261

262## Fehlerbehebung

263

264### Agenten-Ansicht öffnet sich ohne Sitzungen

265

266Die Agenten-Ansicht ist leer, bis Sie Ihre erste Sitzung versenden. Geben Sie eine Eingabeaufforderung in die Eingabe am unteren Rand ein und drücken Sie `Enter`.

267

268### Sitzungen werden nach dem Aufwachen Ihres Computers als gestoppt angezeigt

269

270Hintergrund-Sitzungen überstehen Ruhezustand oder Herunterfahren nicht. Hängen Sie sich an, zeigen Sie Vorschau an oder antworten Sie auf eine gestoppte Sitzung und sie startet von dort neu, wo sie aufgehört hat. Um alle auf einmal neu zu starten, führen Sie `claude respawn --all` aus.

271

272### Eine Sitzung reagiert langsam nach dem Anhängen

273

274Sobald eine Sitzung fertig ist und etwa eine Stunde lang unverbunden sitzt, stoppt der Supervisor seinen Prozess, um Ressourcen freizugeben. Das Anhängen startet einen frischen Prozess von dort, wo er aufgehört hat, was einen Moment dauert. Sitzungen, die funktionieren oder auf Sie warten, werden auf diese Weise nie gestoppt.

275

276### `.claude/worktrees/` füllt sich auf

277

278Worktrees werden entfernt, wenn Sie die Sitzung löschen, die sie erstellt hat. Wenn eine Sitzung endete, ohne aufzuräumen, listen Sie verbleibende Einträge mit `git worktree list` im Projektverzeichnis auf und entfernen Sie jeden mit `git worktree remove <path>`. Siehe [Worktrees bereinigen](/de/worktrees#clean-up-worktrees).

279

280## Einschränkungen

281

282Die Agenten-Ansicht ist eine Forschungsvorschau. Aktuelle Einschränkungen, die Sie beachten sollten:

283

284* **Ratenlimits gelten**: Hintergrund-Sitzungen verbrauchen Ihre Abonnementnutzung genauso wie interaktive Sitzungen, daher verwendet das Ausführen von zehn Agenten parallel die Quote zehnmal schneller.

285* **Sitzungen sind lokal**: Hintergrund-Sitzungen laufen auf Ihrem Computer und stoppen, wenn er in den Ruhezustand wechselt oder heruntergefahren wird.

286* **Worktrees werden mit der Sitzung gelöscht**: Führen Sie Änderungen zusammen oder pushen Sie sie, bevor Sie eine Sitzung löschen, die Dateien in ihrem eigenen Worktree bearbeitet hat.

287

288## Nächste Schritte

289

290Nachdem Sie die Agenten-Ansicht verstanden haben, erkunden Sie diese verwandten Funktionen:

291

292* [Agenten parallel ausführen](/de/agents): Vergleichen Sie die Agenten-Ansicht mit Subagenten, Agenten-Teams und Worktrees

293* [Subagenten](/de/sub-agents): Definieren Sie wiederverwendbare Agentenkonfigurationen mit benutzerdefinierten Eingabeaufforderungen, Tools und Isolation

294* [Agenten-Teams](/de/agent-teams): Koordinieren Sie mehrere Sitzungen, die sich gegenseitig Nachrichten senden

295* [Claude Code im Web](/de/claude-code-on-the-web): Führen Sie Sitzungen in einer verwalteten Cloud-Umgebung aus, anstatt lokal

agents.md +52 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Agenten parallel ausführen

7> Vergleichen Sie die Möglichkeiten, wie Claude Code mehrere Aufgaben gleichzeitig bewältigen kann: Subagenten, Agent-Ansicht, Agent-Teams und isolierte Worktree-Sitzungen.

9[Subagenten](/de/sub-agents), [Agent-Ansicht](/de/agent-view), [Agent-Teams](/de/agent-teams) und [Worktrees](/de/worktrees) parallelisieren die Arbeit jeweils auf unterschiedliche Weise. Die richtige Wahl hängt davon ab, ob Sie in jeder Konversation selbst bleiben möchten, Aufgaben delegieren und später überprüfen möchten, oder ob Claude eine Gruppe von Mitarbeitern für Sie koordinieren soll.

11| Ansatz | Was Sie erhalten | Verwenden Sie es, wenn |

12| :------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------ |

13| [Subagenten](/de/sub-agents) | Delegierte Mitarbeiter in einer Sitzung, die eine Nebenaufgabe in ihrem eigenen Kontext ausführen und eine Zusammenfassung zurückgeben | Eine Nebenaufgabe würde Ihre Hauptkonversation mit Suchergebnissen, Protokollen oder Dateiinhalten überfluten, auf die Sie nicht mehr verweisen werden |

14| [Agent-Ansicht](/de/agent-view) | Ein Bildschirm zum Versenden und Überwachen von Sitzungen, die im Hintergrund ausgeführt werden, geöffnet mit `claude agents`. Forschungsvorschau | Sie haben mehrere unabhängige Aufgaben und möchten diese delegieren, den Status auf einen Blick überprüfen und nur eingreifen, wenn eine Aufgabe Sie benötigt |

15| [Agent-Teams](/de/agent-teams) | Mehrere koordinierte Sitzungen mit einer gemeinsamen Aufgabenliste und Messaging zwischen Agenten, verwaltet von einem Lead. Experimentell und standardmäßig deaktiviert | Sie möchten, dass Claude ein Projekt in Teile aufteilt, diese zuweist und die Mitarbeiter synchron hält |

16| [Worktrees](/de/worktrees) | Separate Git-Checkouts, damit parallele Sitzungen sich gegenseitig nicht in die Quere kommen | Sie führen mehrere Sitzungen selbst aus, oder Ihre Subagenten bearbeiten überlappende Dateien |

17| [`/batch`](/de/commands) | Eine geplante Aufteilung einer großen Änderung in 5 bis 30 Worktree-isolierte Subagenten, die jeweils einen Pull Request öffnen | Eine Repository-weite Migration oder mechanische Umgestaltung, die Sie in einer Anweisung beschreiben können |

19In jedem Ansatz sind die Mitarbeiter Claude-Sitzungen. Um ein anderes Tool einzubeziehen, stellen Sie es Claude als [MCP-Server](/de/mcp) zur Verfügung.

21Sie können diese Ansätze kombinieren. Die Agent-Ansicht verschiebt jede versendete Sitzung automatisch in ihren eigenen Worktree, wenn sie Dateien bearbeiten muss, und eine Sitzung, an der Sie arbeiten, kann Subagenten spawnen, die jeweils ihren eigenen Worktree erhalten.

23<Note>

24 Das gleichzeitige Ausführen mehrerer Sitzungen oder Subagenten vervielfacht die Token-Nutzung. Siehe [Kosten](/de/costs) für Details zur Nutzung und Rate-Limits.

25</Note>

27## Wählen Sie einen Ansatz

29Der richtige Ansatz hängt davon ab, wer die Arbeit koordiniert, ob die Mitarbeiter kommunizieren müssen und ob sie dieselben Dateien bearbeiten:

31* **Wer koordiniert die Arbeit?** Wenn Sie möchten, dass Claude delegiert und Ergebnisse in einer Konversation sammelt, verwenden Sie [Subagenten](/de/sub-agents). Wenn Sie unabhängige Aufgaben delegieren und später überprüfen, verwenden Sie [Agent-Ansicht](/de/agent-view). Wenn Sie möchten, dass Claude eine Gruppe von Mitarbeitern plant, zuweist und beaufsichtigt, verwenden Sie [Agent-Teams](/de/agent-teams), die experimentell und standardmäßig deaktiviert sind.

32* **Müssen die Mitarbeiter miteinander kommunizieren?** Subagenten berichten Ergebnisse an die Konversation, die sie spawned hat, und Agent-Ansicht-Sitzungen berichten nur an Sie. Teammates in einem Agent-Team teilen eine Aufgabenliste und senden sich gegenseitig direkt Nachrichten.

33* **Betreffen die Aufgaben dieselben Dateien?** Isolieren Sie die Arbeit mit [Worktrees](/de/worktrees). Subagenten und Sitzungen, die Sie selbst ausführen, können jeweils einen separaten Worktree verwenden. Agent-Teams isolieren Teammates nicht in Worktrees, daher [partitionieren Sie die Arbeit](/de/agent-teams#avoid-file-conflicts), damit jeder Teammate einen anderen Satz von Dateien besitzt.

35## Überprüfen Sie laufende Arbeiten

37Der Befehl zum Überprüfen laufender Arbeiten hängt davon ab, welchen Ansatz Sie verwendet haben:

39* Für Hintergrund-Sitzungen öffnet `claude agents` die [Agent-Ansicht](/de/agent-view): ein Bildschirm, der jede Sitzung, ihren Status und die Sitzungen anzeigt, die Ihre Eingabe benötigen.

40* Für Subagenten in der aktuellen Sitzung öffnet `/agents` ein Panel mit einer Registerkarte **Running** (Ausgeführt), die aktive Subagenten auflistet, und einer Registerkarte **Library** (Bibliothek), in der Sie [benutzerdefinierte Subagenten erstellen und bearbeiten](/de/sub-agents#use-the-%2Fagents-command). Trotz des ähnlichen Namens ist dies getrennt von `claude agents`.

41* Für alles, das im Hintergrund der aktuellen Sitzung ausgeführt wird, listet `/tasks` jedes Element auf und ermöglicht es Ihnen, es zu überprüfen, sich daran anzuhängen oder es zu stoppen.

43Für eine Desktop-Ansicht aller Ihrer Sitzungen siehe [parallele Sitzungen in der Desktop-App](/de/desktop#work-in-parallel-with-sessions).

45## Weitere Informationen

47Jeder Leitfaden unten behandelt Setup und Konfiguration für einen Ansatz:

49* [Erstellen Sie benutzerdefinierte Subagenten](/de/sub-agents): definieren Sie wiederverwendbare Spezialisten und kontrollieren Sie, welche Tools sie verwenden können.

50* [Verwalten Sie Agenten mit Agent-Ansicht](/de/agent-view): versenden Sie Sitzungen, beobachten Sie ihren Status und hängen Sie sich an, wenn eine Sitzung Sie benötigt.

51* [Orchestrieren Sie Agent-Teams](/de/agent-teams): richten Sie einen Lead und Teammates ein, weisen Sie Aufgaben zu und überprüfen Sie ihre Arbeit.

52* [Führen Sie parallele Sitzungen mit Worktrees aus](/de/worktrees): starten Sie Claude in einem isolierten Checkout, kontrollieren Sie, was kopiert wird, und bereinigen Sie danach.

claude-platform-on-aws.md +341 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Claude Code auf Claude Platform on AWS

7> Konfigurieren Sie Claude Code für die Verwendung der von Anthropic betriebenen Claude API mit AWS-Authentifizierung, IAM-Zugriffskontrolle und AWS Marketplace-Abrechnung.

9export const ContactSalesCard = ({surface}) => {

10 const utm = content => `utm_source=claude_code&utm_medium=docs&utm_content=${surface}_${content}`;

11 const iconArrowRight = (size = 13) => <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">

12 <line x1="5" y1="12" x2="19" y2="12" />

13 <polyline points="12 5 19 12 12 19" />

14 </svg>;

15 const STYLES = `

16.cc-cs {

17 --cs-slate: #141413;

18 --cs-clay: #d97757;

19 --cs-clay-deep: #c6613f;

20 --cs-gray-000: #ffffff;

21 --cs-gray-700: #3d3d3a;

22 --cs-border-default: rgba(31, 30, 29, 0.15);

23 font-family: inherit;

24}

25.dark .cc-cs {

26 --cs-slate: #f0eee6;

27 --cs-gray-000: #262624;

28 --cs-gray-700: #bfbdb4;

29 --cs-border-default: rgba(240, 238, 230, 0.14);

30}

31.cc-cs-card {

32 display: flex; align-items: center; justify-content: space-between;

33 gap: 16px; padding: 14px 16px; margin: 0;

34 background: var(--cs-gray-000); border: 0.5px solid var(--cs-border-default);

35 border-radius: 8px; flex-wrap: wrap;

36}

37.cc-cs-text { font-size: 13px; color: var(--cs-gray-700); line-height: 1.5; flex: 1; min-width: 240px; }

38.cc-cs-text strong { font-weight: 550; color: var(--cs-slate); }

39.cc-cs-actions { display: flex; align-items: center; gap: 8px; flex-shrink: 0; }

40.cc-cs-btn-clay {

41 display: inline-flex; align-items: center; gap: 8px;

42 background: var(--cs-clay-deep); color: #fff; border: none;

43 border-radius: 8px; padding: 8px 14px;

44 font-size: 13px; font-weight: 500;

45 transition: background-color 0.15s; white-space: nowrap;

46}

47.cc-cs-btn-clay:hover { background: var(--cs-clay); }

48.cc-cs-btn-ghost {

49 display: inline-flex; align-items: center; gap: 8px;

50 background: transparent; color: var(--cs-gray-700);

51 border: 0.5px solid var(--cs-border-default);

52 border-radius: 8px; padding: 8px 14px;

53 font-size: 13px; font-weight: 500;

54}

55.cc-cs-btn-ghost:hover { background: rgba(0, 0, 0, 0.04); }

56.dark .cc-cs-btn-ghost:hover { background: rgba(255, 255, 255, 0.04); }

57@media (max-width: 720px) {

58 .cc-cs-actions { width: 100%; }

59}

60`;

61 return <div className="cc-cs not-prose">

62 <style>{STYLES}</style>

63 <div className="cc-cs-card">

64 <div className="cc-cs-text">

65 <strong>Deploying Claude Code across your organization?</strong> Talk to sales about enterprise plans, SSO, and centralized billing.

66 </div>

67 <div className="cc-cs-actions">

68 <a href={`https://claude.com/pricing?${utm('view_plans')}#plans-business`} className="cc-cs-btn-ghost">

69 View plans

70 </a>

71 <a href={`https://claude.com/contact-sales?${utm('contact_sales')}`} className="cc-cs-btn-clay">

72 Contact sales {iconArrowRight()}

73 </a>

74 </div>

75 </div>

76 </div>;

77};

79export const Experiment = ({flag, treatment, children}) => {

80 const VID_KEY = 'exp_vid';

81 const CONSENT_COUNTRIES = new Set(['AT', 'BE', 'BG', 'HR', 'CY', 'CZ', 'DK', 'EE', 'FI', 'FR', 'DE', 'GR', 'HU', 'IE', 'IT', 'LV', 'LT', 'LU', 'MT', 'NL', 'PL', 'PT', 'RO', 'SK', 'SI', 'ES', 'SE', 'RE', 'GP', 'MQ', 'GF', 'YT', 'BL', 'MF', 'PM', 'WF', 'PF', 'NC', 'AW', 'CW', 'SX', 'FO', 'GL', 'AX', 'GB', 'UK', 'AI', 'BM', 'IO', 'VG', 'KY', 'FK', 'GI', 'MS', 'PN', 'SH', 'TC', 'GG', 'JE', 'IM', 'CA', 'BR', 'IN']);

82 const fnv1a = s => {

83 let h = 0x811c9dc5;

84 for (let i = 0; i < s.length; i++) {

85 h ^= s.charCodeAt(i);

86 h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);

87 }

88 return h >>> 0;

89 };

90 const bucket = (seed, vid) => fnv1a(fnv1a(seed + vid) + '') % 10000 < 5000 ? 'control' : 'treatment';

91 const [decision] = useState(() => {

92 const params = new URLSearchParams(location.search);

93 const preBucketed = document.documentElement.dataset['gb_' + flag.replace(/-/g, '_')];

94 const force = params.get('gb-force');

95 if (force) {

96 for (const p of force.split(',')) {

97 const [k, v] = p.split(':');

98 if (k === flag) return {

99 variant: v || 'treatment',

100 track: false

101 };

102 }

103 }

104 if (navigator.globalPrivacyControl) {

105 return {

106 variant: 'control',

107 track: false

108 };

109 }

110 const prefsMatch = document.cookie.match(/(?:^|; )anthropic-consent-preferences=([^;]+)/);

111 if (prefsMatch) {

112 try {

113 if (JSON.parse(decodeURIComponent(prefsMatch[1])).analytics !== true) {

114 return {

115 variant: 'control',

116 track: false

117 };

118 }

119 } catch {

120 return {

121 variant: 'control',

122 track: false

123 };

124 }

125 } else {

126 const country = params.get('country')?.toUpperCase() || (document.cookie.match(/(?:^|; )cf_geo=([A-Z]{2})/) || [])[1];

127 if (!country || CONSENT_COUNTRIES.has(country)) {

128 return {

129 variant: 'control',

130 track: false

131 };

132 }

133 }

134 let vid;

135 try {

136 const ajsMatch = document.cookie.match(/(?:^|; )ajs_anonymous_id=([^;]+)/);

137 if (ajsMatch) {

138 vid = decodeURIComponent(ajsMatch[1]).replace(/^"|"$/g, '');

139 } else {

140 vid = localStorage.getItem(VID_KEY);

141 if (!vid) {

142 vid = crypto.randomUUID();

143 }

144 document.cookie = `ajs_anonymous_id=${vid}; domain=.claude.com; path=/; Secure; SameSite=Lax; max-age=31536000`;

145 }

146 try {

147 localStorage.setItem(VID_KEY, vid);

148 } catch {}

149 } catch {

150 return {

151 variant: 'control',

152 track: false

153 };

154 }

155 const variant = preBucketed === '1' ? 'treatment' : preBucketed === '0' ? 'control' : bucket(flag, vid);

156 return {

157 variant,

158 track: true,

159 vid

160 };

161 });

162 useEffect(() => {

163 if (!decision.track) return;

164 fetch('https://api.anthropic.com/api/event_logging/v2/batch', {

165 method: 'POST',

166 headers: {

167 'Content-Type': 'application/json',

168 'x-service-name': 'claude_code_docs'

169 },

170 body: JSON.stringify({

171 events: [{

172 event_type: 'GrowthbookExperimentEvent',

173 event_data: {

174 device_id: decision.vid,

175 anonymous_id: decision.vid,

176 timestamp: new Date().toISOString(),

177 experiment_id: flag,

178 variation_id: decision.variant === 'treatment' ? 1 : 0,

179 environment: 'production'

180 }

181 }]

182 }),

183 keepalive: true

184 }).catch(() => {});

185 }, []);

186 return decision.variant === 'treatment' ? treatment : children;

187};

188

189<Experiment flag="docs-contact-sales-cta" treatment={<ContactSalesCard surface="claude_platform_on_aws" />} />

190

191Claude Platform on AWS ist die von Anthropic betriebene Claude API mit AWS-Authentifizierung, IAM-Zugriffskontrolle und AWS Marketplace-Abrechnung. Anfragen erreichen die API von Anthropic direkt, sodass Sie die gleichen Modelle und Funktionen wie die [Claude API](https://platform.claude.com/docs) nach dem gleichen Veröffentlichungsplan erhalten. Sie authentifizieren sich mit AWS-Anmeldedaten oder einem Workspace-API-Schlüssel und zahlen über AWS Marketplace.

192

193Verwenden Sie diese Anleitung, um Claude Code auf einen Workspace zu verweisen, den Sie bereits über Claude Platform on AWS bereitgestellt haben. Für das AWS-Abonnement und die Workspace-Einrichtung, die davor kommt, siehe die [Claude Platform on AWS-Dokumentation](https://platform.claude.com/docs/en/build-with-claude/claude-platform-on-aws).

194

195<Note>

196 Das Abonnement über AWS Marketplace stellt eine neue Anthropic-Organisation bereit, die mit Ihrem AWS-Konto verknüpft ist. Diese Organisation ist separat von jeder Organisation, die Sie bereits bei Anthropic haben, und Anmeldedaten werden nicht zwischen ihnen übertragen. Verwenden Sie die Workspace-ID und API-Schlüssel aus der AWS-verknüpften Organisation, nicht aus einem bereits vorhandenen Claude Console-Konto.

197</Note>

198

199## Voraussetzungen

200

201Vor der Konfiguration von Claude Code benötigen Sie:

202

203* Ein aktives Claude Platform on AWS-Abonnement über AWS Marketplace

204* Einen Workspace in Ihrer AWS-verknüpften Anthropic-Organisation mit seiner Workspace-ID

205* Einen IAM-Principal mit Berechtigung zum Aufrufen des Anthropic-Dienstes oder einen API-Schlüssel, der auf den Workspace beschränkt ist

206* AWS-Anmeldedaten in Ihrer Umgebung, in `~/.aws/credentials` oder von einer angehängten IAM-Rolle, wenn Sie SigV4-Authentifizierung möchten. Die AWS CLI ist nur für den SSO-Anmeldungsfluss erforderlich.

207

208## Einrichtung

209

210### 1. AWS-Anmeldedaten konfigurieren

211

212Claude Code unterstützt zwei Authentifizierungsmethoden für Claude Platform on AWS. Wählen Sie die Methode, die zu Ihrer Zugriffsverwaltung passt.

213

214**Option A: AWS-Anmeldedaten mit SigV4**

215

216Claude Code signiert Anfragen mit SigV4 unter Verwendung der Standard-AWS-Anmeldekette: Umgebungsvariablen, gemeinsame Anmeldedaten in `~/.aws/credentials`, IAM-Rollen, AWS SSO-Sitzungen und alle anderen Quellen, die das AWS SDK unterstützt.

217

218Für die lokale Verwendung melden Sie sich mit der AWS CLI an, bevor Sie Claude Code starten. Das folgende Beispiel verwendet ein SSO-Profil, aber jede Methode, die Anmeldedaten an den Standardorten erzeugt, funktioniert.

219

220```bash theme={null}

221aws sso login --profile my-profile

222export AWS_PROFILE=my-profile

223```

224

225Für CI und Automatisierung geben Sie dem Runner eine IAM-Rolle mit Berechtigung zum Aufrufen des Anthropic-Dienstes und setzen Sie `AWS_REGION`. Die Anmeldekette nimmt die Rolle automatisch auf.

226

227Wenn Ihre SSO-Anmeldedaten während einer Sitzung ablaufen, konfigurieren Sie [`awsAuthRefresh`](/de/amazon-bedrock#advanced-credential-configuration), damit Claude Code Ihren Anmeldungsbefehl erneut ausführt und erneut versucht, anstatt fehlzuschlagen. Fügen Sie den Befehl zu Ihrer `settings.json` hinzu:

228

229```json theme={null}

230{

231 "awsAuthRefresh": "aws sso login --profile my-profile"

232}

233```

234

235**Option B: Workspace-API-Schlüssel**

236

237Ein Workspace-API-Schlüssel ist ein langlebiges Geheimnis, das nützlich ist, wenn Sie keine verbundenen AWS-Anmeldedaten verwalten möchten. Generieren Sie einen in der AWS Console unter **Claude Platform on AWS → API keys** und setzen Sie ihn als `ANTHROPIC_AWS_API_KEY`:

238

239```bash theme={null}

240export ANTHROPIC_AWS_API_KEY=sk-ant-xxxxx

241```

242

243Der Schlüssel wird als `x-api-key` gesendet und hat Vorrang vor SigV4, sodass alle AWS-Anmeldedaten in Ihrer Umgebung ignoriert werden. API-Schlüssel aus einer separaten Claude Console-Organisation funktionieren hier nicht.

244

245Behandeln Sie Workspace-API-Schlüssel wie jede andere Produktionsanmeldedaten. Der [Benutzereinstellungsdatei](/de/settings) `env`-Block ist eine praktische Möglichkeit, den Schlüssel auf Ihrem Computer zu beschränken, ohne ihn global zu exportieren.

246

247<Note>

248 Die Befehle `/login` und `/logout` ändern die Claude Platform on AWS-Authentifizierung nicht. Die Authentifizierung erfolgt über Ihre AWS-Anmeldedaten oder Ihren Workspace-API-Schlüssel, nicht über ein Claude.ai-Abonnement.

249</Note>

250

251### 2. Claude Code konfigurieren

252

253Setzen Sie die Umgebungsvariablen, die Claude Code durch Claude Platform on AWS anstelle der Standard-Anthropic API leiten.

254

255```bash theme={null}

256export CLAUDE_CODE_USE_ANTHROPIC_AWS=1

257export ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01ABCDEFGHIJKLMN

258export AWS_REGION=us-east-1

259```

260

261`ANTHROPIC_AWS_WORKSPACE_ID` ist erforderlich und wird bei jeder Anfrage als `anthropic-workspace-id`-Header gesendet. Die Basis-URL wird aus `AWS_REGION` als `https://aws-external-anthropic.{region}.api.aws` berechnet. Um die URL direkt zu überschreiben, setzen Sie `ANTHROPIC_AWS_BASE_URL`.

262

263Claude Platform on AWS ist optional, auch wenn AWS-Anmeldedaten in Ihrer Umgebung vorhanden sind. Bedrock und Foundry haben Vorrang beim Provider-Routing, daher heben Sie `CLAUDE_CODE_USE_BEDROCK` und `CLAUDE_CODE_USE_FOUNDRY` auf, wenn sie gesetzt sind.

264

265### 3. Modellversionen anheften

266

267Claude Platform on AWS verwendet die gleichen Modell-IDs wie die direkte Claude API. Die Standard-Aliase `opus`, `sonnet` und `haiku` werden zu den neuesten Versionen aufgelöst, die in Ihrem Workspace verfügbar sind.

268

269Wenn Sie Claude Code für ein Team bereitstellen, heften Sie die Modell-IDs explizit an, damit eine neue Version nicht alle auf einmal verschiebt:

270

271```bash theme={null}

272export ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-7

273export ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-4-6

274export ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5

275```

276

277Die vollständige Liste der Modell-IDs und Aliase finden Sie unter [Modellübersicht](https://platform.claude.com/docs/en/about-claude/models/overview). Für andere modellbezogene Variablen siehe [Modellkonfiguration](/de/model-config).

278

279[Prompt Caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) ist automatisch aktiviert. 1-Stunden-Cache-Schreibvorgänge werden mit einer höheren Rate als 5-Minuten-Schreibvorgänge abgerechnet. Um statt des 5-Minuten-Standards eine 1-Stunden-Cache-TTL anzufordern, setzen Sie `ENABLE_PROMPT_CACHING_1H=1`.

280

281## Agent SDK verwenden

282

283Das [Agent SDK](/de/agent-sdk/overview) liest die gleichen Umgebungsvariablen wie die CLI, sodass jedes Programm, das den Claude Code-Unterprozess erzeugt, Claude Platform on AWS anvisieren kann, indem es `CLAUDE_CODE_USE_ANTHROPIC_AWS`, `ANTHROPIC_AWS_WORKSPACE_ID` und entweder `ANTHROPIC_AWS_API_KEY` oder AWS-Anmeldedaten vor dem Aufruf exportiert.

284

285```typescript theme={null}

286import { query } from "@anthropic-ai/claude-agent-sdk";

287

288process.env.CLAUDE_CODE_USE_ANTHROPIC_AWS = "1";

289process.env.ANTHROPIC_AWS_WORKSPACE_ID = "wrkspc_01ABCDEFGHIJKLMN";

290process.env.AWS_REGION = "us-east-1";

291

292for await (const msg of query({ prompt: "What's in this repo?" })) {

293 console.log(msg);

294}

295```

296

297Dieses Beispiel basiert auf der Umgebungs-AWS-Anmeldekette für SigV4. Um sich stattdessen mit einem Workspace-API-Schlüssel zu authentifizieren, setzen Sie `ANTHROPIC_AWS_API_KEY` auf die gleiche Weise. Für die breitere Agent SDK-Oberfläche siehe [Agent SDK-Übersicht](/de/agent-sdk/overview).

298

299## Durch einen Unternehmens-Proxy leiten

300

301Um Datenverkehr durch einen Proxy oder [LLM-Gateway](/de/llm-gateway) zu leiten, setzen Sie `ANTHROPIC_AWS_BASE_URL` auf die Adresse des Proxys. Claude Code sendet Anfragen an diese URL mit den gleichen Workspace- und Authentifizierungsheadern, sodass jedes Gateway, das sie unverändert weiterleitet, funktioniert.

302

303```bash theme={null}

304export CLAUDE_CODE_USE_ANTHROPIC_AWS=1

305export ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01ABCDEFGHIJKLMN

306export ANTHROPIC_AWS_BASE_URL=https://anthropic-proxy.example.com

307```

308

309Wenn Ihr Gateway Anfragen selbst signiert, setzen Sie `CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH=1`, damit Claude Code unsignierte Anfragen sendet und das Gateway SigV4-Header hinzufügt, bevor es an AWS weitergeleitet wird. Wenn das Gateway sein eigenes Token benötigt, setzen Sie es in `ANTHROPIC_AUTH_TOKEN`.

310

311```bash theme={null}

312export CLAUDE_CODE_USE_ANTHROPIC_AWS=1

313export CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH=1

314export ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01ABCDEFGHIJKLMN

315export ANTHROPIC_AWS_BASE_URL=https://anthropic-proxy.example.com

316```

317

318## Fehlerbehebung

319

320Führen Sie `/status` aus, um den aufgelösten Provider und alle explizit konfigurierten Workspace-ID, Region, Basis-URL-Überschreibung und Auth-Skip-Einstellung zu sehen. Dies ist der schnellste Weg, um zu bestätigen, dass Claude Code überhaupt auf Claude Platform on AWS abzielt.

321

322### `403 Forbidden` oder `AccessDenied` bei jeder Anfrage

323

324Der IAM-Principal, den Claude Code aufgelöst hat, hat wahrscheinlich keine Berechtigung zum Aufrufen des Anthropic-Dienstes in Ihrem Workspace. Überprüfen Sie die Rolle, die an Ihr AWS-Profil oder den Runner angehängt ist, der Claude Code gestartet hat, und überprüfen Sie, ob sie die `aws-external-anthropic`-Aktionen hat, die in der [IAM-Aktionsreferenz](https://platform.claude.com/docs/en/api/claude-platform-on-aws-iam-actions) dokumentiert sind.

325

326Wenn Sie `ANTHROPIC_AWS_API_KEY` setzen, hat der Schlüssel Vorrang vor SigV4 und ein veralteter Schlüssel erzeugt den gleichen Fehler. Generieren Sie den Schlüssel in der AWS Console unter **Claude Platform on AWS → API keys** neu oder heben Sie die Variable auf, um auf Ihre AWS-Anmeldedaten zurückzugreifen.

327

328### Anfragen schlagen mit einem fehlenden Workspace-Fehler fehl

329

330`ANTHROPIC_AWS_WORKSPACE_ID` ist wahrscheinlich nicht gesetzt oder leer. Jede Claude Platform on AWS-Anfrage muss die Workspace-ID enthalten. Sie wird nicht durch Ihre AWS-Anmeldedaten impliziert. Finden Sie die ID unter **Workspaces** auf der AWS Console-Serviceseite und exportieren Sie sie, bevor Sie Claude Code starten.

331

332### Anfragen gehen immer noch an `api.anthropic.com`

333

334`CLAUDE_CODE_USE_ANTHROPIC_AWS` ist wahrscheinlich nicht gesetzt oder auf einen Wert gesetzt, der nicht als wahr analysiert wird. Setzen Sie ihn auf `1` und führen Sie `/status` aus, um den aufgelösten Provider zu bestätigen. Wenn `CLAUDE_CODE_USE_BEDROCK` oder `CLAUDE_CODE_USE_FOUNDRY` auch gesetzt ist, haben diese Vorrang vor Claude Platform on AWS.

335

336## Zusätzliche Ressourcen

337

338Das Claude Platform on AWS-Abonnement, der Workspace und die IAM-Einrichtung, die vor der Konfiguration von Claude Code kommt, werden in der Plattformdokumentation behandelt:

339

340* [Claude Platform on AWS-Übersicht](https://platform.claude.com/docs/en/build-with-claude/claude-platform-on-aws): Abonnement, Workspace-Einrichtung und Produktreferenz

341* [IAM-Aktionsreferenz](https://platform.claude.com/docs/en/api/claude-platform-on-aws-iam-actions): Berechtigungen und verwaltete Richtlinien

cli-reference.md +7 −1

Details

24| `claude auth login` | Melden Sie sich bei Ihrem Anthropic-Konto an. Verwenden Sie `--email`, um Ihre E-Mail-Adresse vorauszufüllen, `--sso`, um SSO-Authentifizierung zu erzwingen, und `--console`, um sich mit der Anthropic Console für API-Nutzungsabrechnung anstelle eines Claude-Abonnements anzumelden | `claude auth login --console` |24| `claude auth login` | Melden Sie sich bei Ihrem Anthropic-Konto an. Verwenden Sie `--email`, um Ihre E-Mail-Adresse vorauszufüllen, `--sso`, um SSO-Authentifizierung zu erzwingen, und `--console`, um sich mit der Anthropic Console für API-Nutzungsabrechnung anstelle eines Claude-Abonnements anzumelden | `claude auth login --console` |

26| `claude auth status` | Authentifizierungsstatus als JSON anzeigen. Verwenden Sie `--text` für benutzerfreundliche Ausgabe. Beendet mit Code 0, wenn angemeldet, 1, wenn nicht | `claude auth status` |26| `claude auth status` | Authentifizierungsstatus als JSON anzeigen. Verwenden Sie `--text` für benutzerfreundliche Ausgabe. Beendet mit Code 0, wenn angemeldet, 1, wenn nicht | `claude auth status` |

27| `claude agents` | Alle konfigurierten [Subagenten](/de/sub-agents) auflisten, gruppiert nach Quelle | `claude agents` |27| `claude agents` | Öffnen Sie die [Agent-Ansicht](/de/agent-view), um parallele Hintergrundsitzungen zu überwachen und zu versenden. Wenn die Ausgabe weitergeleitet wird, werden stattdessen konfigurierte [Subagenten](/de/sub-agents) aufgelistet | `claude agents` |

28| `claude attach <id>` | Verbinden Sie sich mit einer [Hintergrundsitzung](/de/agent-view#manage-sessions-from-the-shell) in diesem Terminal | `claude attach 7c5dcf5d` |

28| `claude auto-mode defaults` | Drucken Sie die integrierten [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode) Klassifiziererregeln als JSON. Verwenden Sie `claude auto-mode config`, um Ihre effektive Konfiguration mit angewendeten Einstellungen anzuzeigen | `claude auto-mode defaults > rules.json` |29| `claude auto-mode defaults` | Drucken Sie die integrierten [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode) Klassifiziererregeln als JSON. Verwenden Sie `claude auto-mode config`, um Ihre effektive Konfiguration mit angewendeten Einstellungen anzuzeigen | `claude auto-mode defaults > rules.json` |

30| `claude logs <id>` | Drucken Sie die aktuelle Ausgabe aus einer [Hintergrundsitzung](/de/agent-view#manage-sessions-from-the-shell) | `claude logs 7c5dcf5d` |

30| `claude plugin` | Verwalten Sie Claude Code [Plugins](/de/plugins). Alias: `claude plugins`. Siehe [Plugin-Referenz](/de/plugins-reference#cli-commands-reference) für Unterbefehle | `claude plugin install code-review@claude-plugins-official` |32| `claude plugin` | Verwalten Sie Claude Code [Plugins](/de/plugins). Alias: `claude plugins`. Siehe [Plugin-Referenz](/de/plugins-reference#cli-commands-reference) für Unterbefehle | `claude plugin install code-review@claude-plugins-official` |

31| `claude project purge [path]` | Löschen Sie alle lokalen Claude Code-Status für ein Projekt: Transkripte, Aufgabenlisten, Debug-Protokolle, Datei-Bearbeitungsverlauf, Prompt-Verlaufszeilen und den Projekteintrag in `~/.claude.json`. Lassen Sie `[path]` weg, um aus einer interaktiven Liste auszuwählen. Flags: `--dry-run` zum Vorschau, `-y`/`--yes` zum Überspringen der Bestätigung, `-i`/`--interactive` zum Bestätigen jedes Elements, `--all` für jedes Projekt. Siehe [Lokale Daten löschen](/de/claude-directory#clear-local-data) | `claude project purge ~/work/repo --dry-run` |33| `claude project purge [path]` | Löschen Sie alle lokalen Claude Code-Status für ein Projekt: Transkripte, Aufgabenlisten, Debug-Protokolle, Datei-Bearbeitungsverlauf, Prompt-Verlaufszeilen und den Projekteintrag in `~/.claude.json`. Lassen Sie `[path]` weg, um aus einer interaktiven Liste auszuwählen. Flags: `--dry-run` zum Vorschau, `-y`/`--yes` zum Überspringen der Bestätigung, `-i`/`--interactive` zum Bestätigen jedes Elements, `--all` für jedes Projekt. Siehe [Lokale Daten löschen](/de/claude-directory#clear-local-data) | `claude project purge ~/work/repo --dry-run` |

32| `claude remote-control` | Starten Sie einen [Remote Control](/de/remote-control) Server, um Claude Code von Claude.ai oder der Claude App zu steuern. Läuft im Server-Modus (keine lokale interaktive Sitzung). Siehe [Server-Modus-Flags](/de/remote-control#start-a-remote-control-session) | `claude remote-control --name "My Project"` |34| `claude remote-control` | Starten Sie einen [Remote Control](/de/remote-control) Server, um Claude Code von Claude.ai oder der Claude App zu steuern. Läuft im Server-Modus (keine lokale interaktive Sitzung). Siehe [Server-Modus-Flags](/de/remote-control#start-a-remote-control-session) | `claude remote-control --name "My Project"` |

35| `claude respawn <id>` | Starten Sie eine gestoppte [Hintergrundsitzung](/de/agent-view#manage-sessions-from-the-shell) mit ihrer Konversation neu. Verwenden Sie `--all`, um jede gestoppte Sitzung neu zu starten | `claude respawn 7c5dcf5d` |

36| `claude rm <id>` | Entfernen Sie eine [Hintergrundsitzung](/de/agent-view#manage-sessions-from-the-shell) aus der Liste | `claude rm 7c5dcf5d` |

33| `claude setup-token` | Generieren Sie ein langlebiges OAuth-Token für CI und Skripte. Gibt das Token auf dem Terminal aus, ohne es zu speichern. Erfordert ein Claude-Abonnement. Siehe [Generieren Sie ein langlebiges Token](/de/authentication#generate-a-long-lived-token) | `claude setup-token` |37| `claude setup-token` | Generieren Sie ein langlebiges OAuth-Token für CI und Skripte. Gibt das Token auf dem Terminal aus, ohne es zu speichern. Erfordert ein Claude-Abonnement. Siehe [Generieren Sie ein langlebiges Token](/de/authentication#generate-a-long-lived-token) | `claude setup-token` |

38| `claude stop <id>` | Stoppen Sie eine [Hintergrundsitzung](/de/agent-view#manage-sessions-from-the-shell). Akzeptiert auch `claude kill` | `claude stop 7c5dcf5d` |

34| `claude ultrareview [target]` | Führen Sie [ultrareview](/de/ultrareview#run-ultrareview-non-interactively) nicht interaktiv aus. Gibt Ergebnisse auf stdout aus und beendet sich mit 0 bei Erfolg oder 1 bei Fehler. Verwenden Sie `--json` für die rohe Nutzlast und `--timeout <minutes>`, um das 30-Minuten-Standard zu überschreiben | `claude ultrareview 1234 --json` |39| `claude ultrareview [target]` | Führen Sie [ultrareview](/de/ultrareview#run-ultrareview-non-interactively) nicht interaktiv aus. Gibt Ergebnisse auf stdout aus und beendet sich mit 0 bei Erfolg oder 1 bei Fehler. Verwenden Sie `--json` für die rohe Nutzlast und `--timeout <minutes>`, um das 30-Minuten-Standard zu überschreiben | `claude ultrareview 1234 --json` |

35 40

36Wenn Sie einen Unterbefehl falsch eingeben, schlägt Claude Code die nächste Übereinstimmung vor und beendet sich, ohne eine Sitzung zu starten. Zum Beispiel gibt `claude udpate` `Did you mean claude update?` aus.41Wenn Sie einen Unterbefehl falsch eingeben, schlägt Claude Code die nächste Übereinstimmung vor und beendet sich, ohne eine Sitzung zu starten. Zum Beispiel gibt `claude udpate` `Did you mean claude update?` aus.

50| `--append-system-prompt-file` | Laden Sie zusätzlichen Systemprompt-Text aus einer Datei und fügen Sie ihn zum Standard-Prompt an | `claude --append-system-prompt-file ./extra-rules.txt` |55| `--append-system-prompt-file` | Laden Sie zusätzlichen Systemprompt-Text aus einer Datei und fügen Sie ihn zum Standard-Prompt an | `claude --append-system-prompt-file ./extra-rules.txt` |

51| `--bare` | Minimaler Modus: Überspringen Sie die automatische Erkennung von Hooks, Skills, Plugins, MCP-Servern, automatischem Speicher und CLAUDE.md, damit Skriptaufrufe schneller starten. Claude hat Zugriff auf Bash-, Dateilesungs- und Dateibearbeitungstools. Setzt [`CLAUDE_CODE_SIMPLE`](/de/env-vars). Siehe [Bare-Modus](/de/headless#start-faster-with-bare-mode) | `claude --bare -p "query"` |56| `--bare` | Minimaler Modus: Überspringen Sie die automatische Erkennung von Hooks, Skills, Plugins, MCP-Servern, automatischem Speicher und CLAUDE.md, damit Skriptaufrufe schneller starten. Claude hat Zugriff auf Bash-, Dateilesungs- und Dateibearbeitungstools. Setzt [`CLAUDE_CODE_SIMPLE`](/de/env-vars). Siehe [Bare-Modus](/de/headless#start-faster-with-bare-mode) | `claude --bare -p "query"` |

58| `--bg` | Starten Sie die Sitzung als [Hintergrund-Agent](/de/agent-view) und kehren Sie sofort zurück. Gibt die Sitzungs-ID und Verwaltungsbefehle aus. Kombinieren Sie mit `--agent`, um einen bestimmten Subagenten auszuführen | `claude --bg "investigate the flaky test"` |

53| `--channels` | (Forschungsvorschau) MCP-Server, deren [Kanal](/de/channels) Benachrichtigungen Claude in dieser Sitzung abhören sollte. Durch Leerzeichen getrennte Liste von `plugin:<name>@<marketplace>` Einträgen. Erfordert Claude.ai-Authentifizierung | `claude --channels plugin:my-notifier@my-marketplace` |59| `--channels` | (Forschungsvorschau) MCP-Server, deren [Kanal](/de/channels) Benachrichtigungen Claude in dieser Sitzung abhören sollte. Durch Leerzeichen getrennte Liste von `plugin:<name>@<marketplace>` Einträgen. Erfordert Claude.ai-Authentifizierung | `claude --channels plugin:my-notifier@my-marketplace` |

55| `--continue`, `-c` | Laden Sie die letzte Konversation im aktuellen Verzeichnis. Schließt Sitzungen ein, die dieses Verzeichnis mit `/add-dir` hinzugefügt haben | `claude --continue` |61| `--continue`, `-c` | Laden Sie die letzte Konversation im aktuellen Verzeichnis. Schließt Sitzungen ein, die dieses Verzeichnis mit `/add-dir` hinzugefügt haben | `claude --continue` |

commands.md +6 −1

Details

20 20

21**Während einer Aufgabe.** `/plan` wechselt vor einer großen Änderung in den Plan-Modus. `/model` und `/effort` passen an, wie viel Reasoning Sie ausgeben. Wenn das Gespräch lang wird, zeigt `/context`, wohin das Fenster geht, und `/compact` fasst es zusammen; verwenden Sie `/btw` für eine schnelle Nebenbemerkung, die die Historie nicht aufblähen sollte.21**Während einer Aufgabe.** `/plan` wechselt vor einer großen Änderung in den Plan-Modus. `/model` und `/effort` passen an, wie viel Reasoning Sie ausgeben. Wenn das Gespräch lang wird, zeigt `/context`, wohin das Fenster geht, und `/compact` fasst es zusammen; verwenden Sie `/btw` für eine schnelle Nebenbemerkung, die die Historie nicht aufblähen sollte.

22 22

23**Parallele Arbeit ausführen.** `/agents` öffnet den Manager für die [Subagenten](/de/sub-agents), an die Claude Nebenaufgaben delegieren kann, und `/tasks` listet auf, was im Hintergrund der aktuellen Sitzung läuft. `/background` trennt die gesamte Sitzung ab, um als [Hintergrund-Agent](/de/agent-view) weiter zu laufen, und gibt Ihr Terminal frei. Für eine große Änderung, die sich über die Codebasis erstreckt, zerlegt `/batch` sie in unabhängige Einheiten und führt jede in ihrem eigenen [Worktree](/de/worktrees) aus. Siehe [Agenten parallel ausführen](/de/agents), um zu verstehen, wie diese Ansätze zusammenhängen.

23**Bevor Sie versenden.** `/diff` zeigt, was sich geändert hat, `/simplify` überprüft kürzlich geänderte Dateien und wendet Qualitäts- und Effizienzfixes an, und `/review` oder `/security-review` geben einen tieferen schreibgeschützten Durchgang.25**Bevor Sie versenden.** `/diff` zeigt, was sich geändert hat, `/simplify` überprüft kürzlich geänderte Dateien und wendet Qualitäts- und Effizienzfixes an, und `/review` oder `/security-review` geben einen tieferen schreibgeschützten Durchgang.

24 26

25**Zwischen Sitzungen.** `/clear` startet frisch bei einer neuen Aufgabe, während die Projektmemory erhalten bleibt. `/resume` und `/branch` ermöglichen es Ihnen, zu einem früheren Gespräch zurückzukehren oder es zu verzweigen. `/teleport` zieht eine Web-Sitzung in dieses Terminal, und `/remote-control` ermöglicht es Ihnen, diese lokale Sitzung von einem anderen Gerät fortzusetzen.27**Zwischen Sitzungen.** `/clear` startet frisch bei einer neuen Aufgabe, während die Projektmemory erhalten bleibt. `/resume` und `/branch` ermöglichen es Ihnen, zu einem früheren Gespräch zurückzukehren oder es zu verzweigen. `/teleport` zieht eine Web-Sitzung in dieses Terminal, und `/remote-control` ermöglicht es Ihnen, diese lokale Sitzung von einem anderen Gerät fortzusetzen.

41| `/add-dir <path>` | Fügen Sie ein Arbeitsverzeichnis für den Dateizugriff während der aktuellen Sitzung hinzu. Die meisten `.claude/`-Konfigurationen werden [nicht erkannt](/de/permissions#additional-directories-grant-file-access-not-configuration) aus dem hinzugefügten Verzeichnis. Sie können die Sitzung später aus dem hinzugefügten Verzeichnis mit `--continue` oder `--resume` fortsetzen |43| `/add-dir <path>` | Fügen Sie ein Arbeitsverzeichnis für den Dateizugriff während der aktuellen Sitzung hinzu. Die meisten `.claude/`-Konfigurationen werden [nicht erkannt](/de/permissions#additional-directories-grant-file-access-not-configuration) aus dem hinzugefügten Verzeichnis. Sie können die Sitzung später aus dem hinzugefügten Verzeichnis mit `--continue` oder `--resume` fortsetzen |

43| `/autofix-pr [prompt]` | Starten Sie eine [Claude Code im Web](/de/claude-code-on-the-web#auto-fix-pull-requests)-Sitzung, die den aktuellen Branch-PR überwacht und Fixes pusht, wenn CI fehlschlägt oder Reviewer Kommentare hinterlassen. Erkennt den offenen PR aus Ihrem ausgecheckten Branch mit `gh pr view`; um einen anderen PR zu überwachen, checken Sie zuerst seinen Branch aus. Standardmäßig wird der Remote-Sitzung mitgeteilt, jeden CI-Fehler und Review-Kommentar zu beheben; übergeben Sie eine Eingabeaufforderung, um ihr andere Anweisungen zu geben, zum Beispiel `/autofix-pr only fix lint and type errors`. Erfordert die `gh` CLI und Zugriff auf [Claude Code im Web](/de/claude-code-on-the-web#who-can-use-claude-code-on-the-web) |45| `/autofix-pr [prompt]` | Starten Sie eine [Claude Code im Web](/de/claude-code-on-the-web#auto-fix-pull-requests)-Sitzung, die den aktuellen Branch-PR überwacht und Fixes pusht, wenn CI fehlschlägt oder Reviewer Kommentare hinterlassen. Erkennt den offenen PR aus Ihrem ausgecheckten Branch mit `gh pr view`; um einen anderen PR zu überwachen, checken Sie zuerst seinen Branch aus. Standardmäßig wird der Remote-Sitzung mitgeteilt, jeden CI-Fehler und Review-Kommentar zu beheben; übergeben Sie eine Eingabeaufforderung, um ihr andere Anweisungen zu geben, zum Beispiel `/autofix-pr only fix lint and type errors`. Erfordert die `gh` CLI und Zugriff auf [Claude Code im Web](/de/claude-code-on-the-web#who-can-use-claude-code-on-the-web) |

44| `/batch <instruction>` | **[Skill](/de/skills#bundled-skills).** Orchestrieren Sie großflächige Änderungen über eine Codebasis parallel. Recherchiert die Codebasis, zerlegt die Arbeit in 5 bis 30 unabhängige Einheiten und präsentiert einen Plan. Nach Genehmigung startet es einen Hintergrund-Agent pro Einheit in einem isolierten [Git-Worktree](/de/worktrees). Jeder Agent implementiert seine Einheit, führt Tests aus und öffnet einen Pull Request. Erfordert ein Git-Repository. Beispiel: `/batch migrate src/ from Solid to React` |46| `/background [prompt]` | Trennen Sie die aktuelle Sitzung, um als [Hintergrund-Agent](/de/agent-view) zu laufen und dieses Terminal freizugeben. Übergeben Sie eine Eingabeaufforderung, um eine weitere Anweisung vor dem Trennen zu senden. Überwachen Sie die Sitzung mit `claude agents`. Alias: `/bg` |

47| `/batch <instruction>` | **[Skill](/de/skills#bundled-skills).** Orchestrieren Sie großflächige Änderungen über eine Codebasis parallel. Recherchiert die Codebasis, zerlegt die Arbeit in 5 bis 30 unabhängige Einheiten und präsentiert einen Plan. Nach Genehmigung startet es einen [Hintergrund-Subagenten](/de/sub-agents#run-subagents-in-foreground-or-background) pro Einheit in einem isolierten [Git-Worktree](/de/worktrees). Jeder Subagent implementiert seine Einheit, führt Tests aus und öffnet einen Pull Request. Erfordert ein Git-Repository. Beispiel: `/batch migrate src/ from Solid to React` |

45| `/branch [name]` | Erstellen Sie einen Branch des aktuellen Gesprächs an dieser Stelle. Wechselt Sie in den Branch und bewahrt das Original, zu dem Sie mit `/resume` zurückkehren können. Alias: `/fork`. Wenn [`CLAUDE_CODE_FORK_SUBAGENT`](/de/env-vars) gesetzt ist, startet `/fork` stattdessen einen [verzweigten Subagenten](/de/sub-agents#fork-the-current-conversation) und ist kein Alias für diesen Befehl mehr |48| `/branch [name]` | Erstellen Sie einen Branch des aktuellen Gesprächs an dieser Stelle. Wechselt Sie in den Branch und bewahrt das Original, zu dem Sie mit `/resume` zurückkehren können. Alias: `/fork`. Wenn [`CLAUDE_CODE_FORK_SUBAGENT`](/de/env-vars) gesetzt ist, startet `/fork` stattdessen einen [verzweigten Subagenten](/de/sub-agents#fork-the-current-conversation) und ist kein Alias für diesen Befehl mehr |

46| `/btw <question>` | Stellen Sie eine schnelle [Nebenfrage](/de/interactive-mode#side-questions-with-%2Fbtw) ohne Hinzufügen zum Gespräch |49| `/btw <question>` | Stellen Sie eine schnelle [Nebenfrage](/de/interactive-mode#side-questions-with-%2Fbtw) ohne Hinzufügen zum Gespräch |

66| `/fewer-permission-prompts` | **[Skill](/de/skills#bundled-skills).** Scannen Sie Ihre Transkripte nach häufigen schreibgeschützten Bash- und MCP-Tool-Aufrufen, dann fügen Sie eine priorisierte Allowlist zu Projekt `.claude/settings.json` hinzu, um Berechtigungsaufforderungen zu reduzieren |69| `/fewer-permission-prompts` | **[Skill](/de/skills#bundled-skills).** Scannen Sie Ihre Transkripte nach häufigen schreibgeschützten Bash- und MCP-Tool-Aufrufen, dann fügen Sie eine priorisierte Allowlist zu Projekt `.claude/settings.json` hinzu, um Berechtigungsaufforderungen zu reduzieren |

67| `/focus` | Schalten Sie die Fokusansicht um, die nur Ihre letzte Eingabeaufforderung, eine einzeilige Tool-Call-Zusammenfassung mit Edit-Diffstats und die endgültige Antwort anzeigt. Die Auswahl bleibt über Sitzungen hinweg erhalten; legen Sie [`viewMode`](/de/settings#available-settings) in Einstellungen fest, um dies zu überschreiben. Nur in [Vollbildrendering](/de/fullscreen) verfügbar |70| `/focus` | Schalten Sie die Fokusansicht um, die nur Ihre letzte Eingabeaufforderung, eine einzeilige Tool-Call-Zusammenfassung mit Edit-Diffstats und die endgültige Antwort anzeigt. Die Auswahl bleibt über Sitzungen hinweg erhalten; legen Sie [`viewMode`](/de/settings#available-settings) in Einstellungen fest, um dies zu überschreiben. Nur in [Vollbildrendering](/de/fullscreen) verfügbar |

71| `/goal [condition\|clear]` | Legen Sie ein [Ziel](/de/goal) fest: Claude arbeitet über Turns hinweg weiter, bis die Bedingung erfüllt ist. Ohne Argument wird das aktuelle oder zuletzt erreichte Ziel angezeigt. `clear`, `stop`, `off`, `reset`, `none` oder `cancel` entfernt ein aktives Ziel frühzeitig |

68| `/heapdump` | Schreiben Sie einen JavaScript-Heap-Snapshot und eine Speicheraufschlüsselung nach `~/Desktop`, oder Ihr Home-Verzeichnis unter Linux ohne Desktop-Ordner, um hohe Speichernutzung zu diagnostizieren. Siehe [Troubleshooting](/de/troubleshooting#high-cpu-or-memory-usage) |72| `/heapdump` | Schreiben Sie einen JavaScript-Heap-Snapshot und eine Speicheraufschlüsselung nach `~/Desktop`, oder Ihr Home-Verzeichnis unter Linux ohne Desktop-Ordner, um hohe Speichernutzung zu diagnostizieren. Siehe [Troubleshooting](/de/troubleshooting#high-cpu-or-memory-usage) |

109| `/status` | Öffnen Sie die Einstellungsschnittstelle (Registerkarte Status) mit Version, Modell, Konto und Konnektivität. Funktioniert, während Claude antwortet, ohne auf die Fertigstellung der aktuellen Antwort zu warten |113| `/status` | Öffnen Sie die Einstellungsschnittstelle (Registerkarte Status) mit Version, Modell, Konto und Konnektivität. Funktioniert, während Claude antwortet, ohne auf die Fertigstellung der aktuellen Antwort zu warten |

110| `/statusline` | Konfigurieren Sie Claude Codes [Statuszeile](/de/statusline). Beschreiben Sie, was Sie möchten, oder führen Sie ohne Argumente aus, um automatisch von Ihrer Shell-Eingabeaufforderung zu konfigurieren |114| `/statusline` | Konfigurieren Sie Claude Codes [Statuszeile](/de/statusline). Beschreiben Sie, was Sie möchten, oder führen Sie ohne Argumente aus, um automatisch von Ihrer Shell-Eingabeaufforderung zu konfigurieren |

116| `/stop` | Stoppen Sie die aktuelle [Hintergrund-Sitzung](/de/agent-view). Nur verfügbar, wenn Sie an eine Hintergrund-Sitzung angehängt sind; das Transkript und alle Worktrees werden beibehalten. Um zu trennen, ohne zu stoppen, verwenden Sie `/exit` oder drücken Sie `←` |

113| `/team-onboarding` | Generieren Sie einen Team-Onboarding-Leitfaden aus Ihrer Claude Code-Nutzungshistorie. Claude analysiert Ihre Sitzungen, Befehle und MCP-Server-Nutzung der letzten 30 Tage und erstellt einen Markdown-Leitfaden, den ein Teamkollege als erste Nachricht einfügen kann, um sich schnell einzurichten. Für claude.ai-Abonnenten in Pro-, Max-, Team- und Enterprise-Plänen wird auch ein Share-Link zurückgegeben, den Teamkollegen direkt in Claude Code öffnen können |118| `/team-onboarding` | Generieren Sie einen Team-Onboarding-Leitfaden aus Ihrer Claude Code-Nutzungshistorie. Claude analysiert Ihre Sitzungen, Befehle und MCP-Server-Nutzung der letzten 30 Tage und erstellt einen Markdown-Leitfaden, den ein Teamkollege als erste Nachricht einfügen kann, um sich schnell einzurichten. Für claude.ai-Abonnenten in Pro-, Max-, Team- und Enterprise-Plänen wird auch ein Share-Link zurückgegeben, den Teamkollegen direkt in Claude Code öffnen können |

114| `/teleport` | Ziehen Sie eine [Claude Code im Web](/de/claude-code-on-the-web#from-web-to-terminal)-Sitzung in dieses Terminal: öffnet eine Auswahl, dann ruft den Branch und das Gespräch ab. Auch verfügbar als `/tp`. Erfordert ein claude.ai-Abonnement |119| `/teleport` | Ziehen Sie eine [Claude Code im Web](/de/claude-code-on-the-web#from-web-to-terminal)-Sitzung in dieses Terminal: öffnet eine Auswahl, dann ruft den Branch und das Gespräch ab. Auch verfügbar als `/tp`. Erfordert ein claude.ai-Abonnement |

common-workflows.md +89 −593

Details

6 6

7> Schritt-für-Schritt-Anleitungen zum Erkunden von Codebases, Beheben von Fehlern, Refaktorierung, Testen und anderen alltäglichen Aufgaben mit Claude Code.7> Schritt-für-Schritt-Anleitungen zum Erkunden von Codebases, Beheben von Fehlern, Refaktorierung, Testen und anderen alltäglichen Aufgaben mit Claude Code.

8 8

9Diese Seite behandelt praktische Workflows für die alltägliche Entwicklung: Erkunden unbekannter Code, Debugging, Refaktorierung, Schreiben von Tests, Erstellen von PRs und Verwalten von Sitzungen. Jeder Abschnitt enthält Beispiel-Prompts, die Sie an Ihre eigenen Projekte anpassen können. Für übergeordnete Muster und Tipps siehe [Best Practices](/de/best-practices).9Diese Seite sammelt kurze Rezepte für die alltägliche Entwicklung. Für übergeordnete Anleitungen zum Prompting und zur Kontextverwaltung siehe [Best Practices](/de/best-practices).

10 10

~~11## Neue Codebases verstehen~~11Diese Seite behandelt:

12 12

~~13### Schnelle Codebase-Übersicht erhalten~~13* [Prompt-Rezepte](#prompt-recipes) zum Erkunden von Code, Beheben von Fehlern, Refaktorierung, Testen, PRs und Dokumentation

14* [Vorherige Gespräche fortsetzen](#resume-previous-conversations), damit eine Aufgabe mehrere Sitzungen umfassen kann

15* [Parallele Sitzungen mit Worktrees ausführen](#run-parallel-sessions-with-worktrees), damit gleichzeitige Änderungen nicht kollidieren

16* [Vor dem Bearbeiten planen](#plan-before-editing), um Änderungen zu überprüfen, bevor sie die Festplatte berühren

17* [Forschung an Subagents delegieren](#delegate-research-to-subagents), um Ihren Hauptkontext sauber zu halten

18* [Claude in Skripte pipen](#pipe-claude-into-scripts) für CI und Batch-Verarbeitung

20## Prompt-Rezepte

22Dies sind Prompt-Muster für alltägliche Aufgaben wie das Erkunden unbekannter Code, Debugging, Refaktorierung, Schreiben von Tests und Erstellen von PRs. Jedes funktioniert auf jeder Claude Code-Oberfläche; passen Sie die Formulierung an Ihr Projekt an.

24### Neue Codebases verstehen

26#### Schnelle Codebase-Übersicht erhalten

14 27

15Angenommen, Sie sind gerade einem neuen Projekt beigetreten und müssen dessen Struktur schnell verstehen.28Angenommen, Sie sind gerade einem neuen Projekt beigetreten und müssen dessen Struktur schnell verstehen.

16 29

56 * Fordern Sie ein Glossar projektspezifischer Begriffe an69 * Fordern Sie ein Glossar projektspezifischer Begriffe an

57</Tip>70</Tip>

58 71

~~59### Relevanten Code finden~~72#### Relevanten Code finden

60 73

61Angenommen, Sie müssen Code finden, der sich auf eine bestimmte Funktion oder Funktionalität bezieht.74Angenommen, Sie müssen Code finden, der sich auf eine bestimmte Funktion oder Funktionalität bezieht.

62 75

90 103

91***104***

92 105

~~93## Fehler effizient beheben~~106### Fehler effizient beheben

94 107

95Angenommen, Sie sind auf eine Fehlermeldung gestoßen und müssen deren Quelle finden und beheben.108Angenommen, Sie sind auf eine Fehlermeldung gestoßen und müssen deren Quelle finden und beheben.

96 109

124 137

125***138***

126 139

127## Code refaktorieren140### Code refaktorieren

128 141

129Angenommen, Sie müssen alten Code aktualisieren, um moderne Muster und Praktiken zu verwenden.142Angenommen, Sie müssen alten Code aktualisieren, um moderne Muster und Praktiken zu verwenden.

130 143

164 177

165***178***

166 179

167## Spezialisierte Subagents verwenden180### Mit Tests arbeiten

~~168~~

169Angenommen, Sie möchten spezialisierte KI-Subagents verwenden, um bestimmte Aufgaben effektiver zu bewältigen.

~~170~~

171<Steps>

172 <Step title="Verfügbare Subagents anzeigen">

173 ```text theme={null}

174 /agents

175 ```

~~176~~

177 Dies zeigt alle verfügbaren Subagents und ermöglicht es Ihnen, neue zu erstellen.

178 </Step>

~~179~~

180 <Step title="Subagents automatisch verwenden">

181 Claude Code delegiert automatisch geeignete Aufgaben an spezialisierte Subagents:

~~182~~

183 ```text theme={null}

184 review my recent code changes for security issues

185 ```

~~186~~

187 ```text theme={null}

188 run all tests and fix any failures

189 ```

190 </Step>

~~191~~

192 <Step title="Fordern Sie explizit spezifische Subagents an">

193 ```text theme={null}

194 use the code-reviewer subagent to check the auth module

195 ```

~~196~~

197 ```text theme={null}

198 have the debugger subagent investigate why users can't log in

199 ```

200 </Step>

~~201~~

202 <Step title="Erstellen Sie benutzerdefinierte Subagents für Ihren Workflow">

203 ```text theme={null}

204 /agents

205 ```

~~206~~

207 Wählen Sie dann 'Create New subagent" und folgen Sie den Aufforderungen, um Folgendes zu definieren:

~~208~~

209 * Eine eindeutige Kennung, die den Zweck des Subagent beschreibt (z. B. `code-reviewer`, `api-designer`).

210 * Wann Claude diesen Agent verwenden sollte

211 * Welche Tools er verwenden kann

212 * Ein System-Prompt, der die Rolle und das Verhalten des Agents beschreibt

213 </Step>

214</Steps>

~~215~~

216<Tip>

217 Tipps:

~~218~~

219 * Erstellen Sie projektspezifische Subagents in `.claude/agents/` zum Teilen im Team

220 * Verwenden Sie beschreibende `description`-Felder, um automatische Delegation zu ermöglichen

221 * Begrenzen Sie den Tool-Zugriff auf das, was jeder Subagent tatsächlich benötigt

222 * Überprüfen Sie die [Subagents-Dokumentation](/de/sub-agents) für detaillierte Beispiele

223</Tip>

~~224~~

225***

~~226~~

227## Plan Mode für sichere Code-Analyse verwenden

~~228~~

229Plan Mode weist Claude an, einen Plan zu erstellen, indem die Codebase mit schreibgeschützten Operationen analysiert wird. Dies ist perfekt zum Erkunden von Codebases, Planen komplexer Änderungen oder sicheren Überprüfen von Code. Im Plan Mode verwendet Claude [`AskUserQuestion`](/de/tools-reference), um Anforderungen zu sammeln und Ihre Ziele zu klären, bevor ein Plan vorgeschlagen wird.

~~230~~

231### Wann Plan Mode verwendet werden sollte

~~232~~

233* **Multi-Schritt-Implementierung**: Wenn Ihre Funktion Änderungen an vielen Dateien erfordert

234* **Code-Exploration**: Wenn Sie die Codebase gründlich erforschen möchten, bevor Sie etwas ändern

235* **Interaktive Entwicklung**: Wenn Sie die Richtung mit Claude iterieren möchten

~~236~~

237### Wie Plan Mode verwendet wird

~~238~~

239**Aktivieren Sie Plan Mode während einer Sitzung**

~~240~~

241Sie können während einer Sitzung mit **Shift+Tab** in Plan Mode wechseln, um durch Berechtigungsmodi zu zyklisieren.

~~242~~

243Wenn Sie sich im Normal Mode befinden, wechselt **Shift+Tab** zunächst in Auto-Accept Mode, angezeigt durch `⏵⏵ accept edits on` am unteren Rand des Terminals. Ein nachfolgendes **Shift+Tab** wechselt in Plan Mode, angezeigt durch `⏸ plan mode on`.

~~244~~

245**Starten Sie eine neue Sitzung im Plan Mode**

~~246~~

247Um eine neue Sitzung im Plan Mode zu starten, verwenden Sie das Flag `--permission-mode plan`:

~~248~~

249```bash theme={null}

250claude --permission-mode plan

251```

~~252~~

253**Führen Sie „Headless"-Abfragen im Plan Mode aus**

~~254~~

255Sie können auch eine Abfrage im Plan Mode direkt mit `-p` ausführen (d. h. im ["Headless-Modus"](/de/headless)):

~~256~~

257```bash theme={null}

258claude --permission-mode plan -p "Analyze the authentication system and suggest improvements"

259```

~~260~~

261### Beispiel: Planen einer komplexen Refaktorierung

~~262~~

263```bash theme={null}

264claude --permission-mode plan

265```

~~266~~

267```text theme={null}

268I need to refactor our authentication system to use OAuth2. Create a detailed migration plan.

269```

~~270~~

271Claude analysiert die aktuelle Implementierung und erstellt einen umfassenden Plan. Verfeinern Sie mit Folgefragen:

~~272~~

273```text theme={null}

274What about backward compatibility?

275```

~~276~~

277```text theme={null}

278How should we handle database migration?

279```

~~280~~

281<Tip>Drücken Sie `Ctrl+G`, um den Plan in Ihrem Standard-Texteditor zu öffnen, wo Sie ihn direkt bearbeiten können, bevor Claude fortfährt.</Tip>

~~282~~

283Wenn Sie einen Plan akzeptieren, benennt Claude die Sitzung automatisch basierend auf dem Plan-Inhalt. Der Name wird in der Prompt-Leiste und in der Sitzungsauswahl angezeigt. Wenn Sie bereits einen Namen mit `--name` oder `/rename` festgelegt haben, wird das Akzeptieren eines Plans diesen nicht überschreiben.

~~284~~

285### Konfigurieren Sie Plan Mode als Standard

~~286~~

287```json theme={null}

288// .claude/settings.json

289{

290 "permissions": {

291 "defaultMode": "plan"

292 }

293}

294```

~~295~~

296Weitere Konfigurationsoptionen finden Sie in der [Einstellungsdokumentation](/de/settings#available-settings).

~~297~~

298***

~~299~~

300## Mit Tests arbeiten

301 181

302Angenommen, Sie müssen Tests für nicht abgedeckten Code hinzufügen.182Angenommen, Sie müssen Tests für nicht abgedeckten Code hinzufügen.

303 183

333 213

334***214***

335 215

336## Pull Requests erstellen216### Pull Requests erstellen

337 217

338Sie können Pull Requests erstellen, indem Sie Claude direkt fragen („create a pr for my changes"), oder Claude Schritt für Schritt führen:218Sie können Pull Requests erstellen, indem Sie Claude direkt fragen ('create a pr for my changes"), oder Claude Schritt für Schritt führen:

339 219

340<Steps>220<Steps>

341 <Step title="Fassen Sie Ihre Änderungen zusammen">221 <Step title="Fassen Sie Ihre Änderungen zusammen">

357 </Step>237 </Step>

358</Steps>238</Steps>

359 239

360Wenn Sie einen PR mit `gh pr create` erstellen, wird die Sitzung automatisch mit diesem PR verknüpft. Sie können sie später mit `claude --from-pr <number>` fortsetzen.240Wenn Sie einen PR mit `gh pr create` erstellen, wird die Sitzung automatisch mit diesem PR verknüpft. Um später zu ihr zurückzukehren, führen Sie `claude --from-pr <number>` aus oder fügen Sie die PR-URL in die [`/resume` Auswahl](/de/sessions#use-the-session-picker) ein.

361 241

362<Tip>242<Tip>

363 Überprüfen Sie den von Claude generierten PR vor dem Einreichen und bitten Sie Claude, potenzielle Risiken oder Überlegungen hervorzuheben.243 Überprüfen Sie den von Claude generierten PR vor dem Einreichen und bitten Sie Claude, potenzielle Risiken oder Überlegungen hervorzuheben.

364</Tip>244</Tip>

365 245

366## Dokumentation verwalten246### Dokumentation verwalten

367 247

368Angenommen, Sie müssen Dokumentation für Ihren Code hinzufügen oder aktualisieren.248Angenommen, Sie müssen Dokumentation für Ihren Code hinzufügen oder aktualisieren.

369 249

403 283

404***284***

405 285

406## Mit Notizen und Nicht-Code-Ordnern arbeiten286### Mit Notizen und Nicht-Code-Ordnern arbeiten

407 287

408Claude Code funktioniert in jedem Verzeichnis. Führen Sie es in einem Notiz-Vault, einem Dokumentationsordner oder einer beliebigen Sammlung von Markdown-Dateien aus, um Inhalte auf die gleiche Weise zu suchen, zu bearbeiten und zu reorganisieren wie Code.288Claude Code funktioniert in jedem Verzeichnis. Führen Sie es in einem Notiz-Vault, einem Dokumentationsordner oder einer beliebigen Sammlung von Markdown-Dateien aus, um Inhalte auf die gleiche Weise zu suchen, zu bearbeiten und zu reorganisieren wie Code.

409 289

411 291

412***292***

413 293

414## Mit Bildern arbeiten294### Mit Bildern arbeiten

415 295

416Angenommen, Sie müssen mit Bildern in Ihrer Codebase arbeiten und möchten Claudes Hilfe bei der Analyse von Bildinhalten.296Angenommen, Sie müssen mit Bildern in Ihrer Codebase arbeiten und möchten Claudes Hilfe bei der Analyse von Bildinhalten.

417 297

471 351

472***352***

473 353

474## Dateien und Verzeichnisse referenzieren354### Dateien und Verzeichnisse referenzieren

475 355

476Verwenden Sie @, um schnell Dateien oder Verzeichnisse einzubeziehen, ohne auf Claude zu warten, um sie zu lesen.356Verwenden Sie @ um schnell Dateien oder Verzeichnisse einzubeziehen, ohne auf Claude zu warten, um sie zu lesen.

477 357

478<Steps>358<Steps>

479 <Step title="Referenzieren Sie eine einzelne Datei">359 <Step title="Referenzieren Sie eine einzelne Datei">

497 Show me the data from @github:repos/owner/repo/issues377 Show me the data from @github:repos/owner/repo/issues

498 ```378 ```

499 379

500 Dies ruft Daten von verbundenen MCP-Servern im Format @server:resource ab. Weitere Details finden Sie unter [MCP-Ressourcen](/de/mcp#use-mcp-resources).380 Dies ruft Daten von verbundenen MCP-Servern im Format @server:resource ab. Siehe [MCP-Ressourcen](/de/mcp#use-mcp-resources) für Details.

501 </Step>381 </Step>

502</Steps>382</Steps>

503 383

512 392

513***393***

514 394

515## Verwenden Sie erweitertes Denken (Thinking Mode)395### Claude nach einem Zeitplan ausführen

~~516~~

517[Erweitertes Denken](https://platform.claude.com/docs/en/build-with-claude/extended-thinking) ist standardmäßig aktiviert und gibt Claude Platz, um komplexe Probleme Schritt für Schritt zu durchdenken, bevor er antwortet. Dieses Denken ist im ausführlichen Modus sichtbar, den Sie mit `Ctrl+O` umschalten können. Während des erweiterten Denkens zeigt der Spinner Inline-Fortschrittshinweise wie „still thinking" und „almost done thinking" an, um zu zeigen, dass Claude aktiv arbeitet.

~~518~~

519Darüber hinaus verwenden [Modelle, die Effort unterstützen](/de/model-config#adjust-effort-level), adaptives Denken: Anstelle eines festen Thinking-Token-Budgets entscheidet das Modell dynamisch, ob und wie viel es denken soll, basierend auf Ihrer Effort-Level-Einstellung und der anstehenden Aufgabe. Adaptives Denken ermöglicht es Claude, schneller auf Routine-Prompts zu reagieren und tieferes Denken für Schritte zu reservieren, die davon profitieren.

~~520~~

521Erweitertes Denken ist besonders wertvoll für komplexe architektonische Entscheidungen, schwierige Fehler, mehrstufige Implementierungsplanung und Bewertung von Kompromissen zwischen verschiedenen Ansätzen.

~~522~~

523<Note>

524 Phrasen wie „think", „think hard" und „think more" werden als reguläre Prompt-Anweisungen interpretiert und weisen keine Thinking-Tokens zu.

525</Note>

~~526~~

527### Konfigurieren Sie Thinking Mode

~~528~~

529Thinking ist standardmäßig aktiviert, aber Sie können es anpassen oder deaktivieren.

~~530~~

531| Bereich | Wie man konfiguriert | Details |

532| ------------------------------ | --------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

533| **Effort Level** | Führen Sie `/effort` aus, passen Sie in `/model` an, oder setzen Sie [`CLAUDE_CODE_EFFORT_LEVEL`](/de/env-vars) | Steuern Sie die Thinking-Tiefe auf [unterstützten Modellen](/de/model-config#adjust-effort-level) |

534| **`ultrathink` Schlüsselwort** | Fügen Sie „ultrathink" irgendwo in Ihrem Prompt ein | Fügt eine In-Context-Anweisung hinzu, die das Modell anweist, mehr auf diesem Turn zu denken. Ändert nicht die Effort-Ebene selbst; siehe [Effort Level anpassen](/de/model-config#adjust-effort-level) dafür |

535| **Toggle-Verknüpfung** | Drücken Sie `Option+T` (macOS) oder `Alt+T` (Windows/Linux) | Schalten Sie Thinking für die aktuelle Sitzung ein/aus (alle Modelle). Kann [Terminal-Konfiguration](/de/terminal-config) erfordern, um Option-Tasten-Verknüpfungen zu aktivieren |

536| **Globaler Standard** | Verwenden Sie `/config`, um Thinking Mode umzuschalten | Setzt Ihren Standard über alle Projekte (alle Modelle).<br />Gespeichert als `alwaysThinkingEnabled` in `~/.claude/settings.json` |

537| **Token-Budget begrenzen** | Setzen Sie die Umgebungsvariable [`MAX_THINKING_TOKENS`](/de/env-vars) | Begrenzen Sie das Thinking-Budget auf eine bestimmte Anzahl von Tokens. Auf Modellen mit adaptivem Denken gilt nur `0`, es sei denn, adaptives Denken ist deaktiviert. Beispiel: `export MAX_THINKING_TOKENS=10000` |

~~538~~

539Um Claudes Thinking-Prozess anzuzeigen, drücken Sie `Ctrl+O`, um den ausführlichen Modus umzuschalten und das interne Denken als grauer kursiver Text angezeigt zu sehen.

~~540~~

541### Wie erweitertes Denken funktioniert

~~542~~

543Erweitertes Denken steuert, wie viel internes Denken Claude vor der Antwort durchführt. Mehr Denken bietet mehr Platz, um Lösungen zu erkunden, Grenzfälle zu analysieren und Fehler selbst zu korrigieren.

~~544~~

545Auf [Modellen, die Effort unterstützen](/de/model-config#adjust-effort-level), verwendet Thinking adaptives Denken: Das Modell weist Thinking-Tokens dynamisch basierend auf dem Effort Level zu, den Sie auswählen. Dies ist die empfohlene Methode, um den Kompromiss zwischen Geschwindigkeit und Reasoning-Tiefe zu optimieren. Wenn Sie möchten, dass Claude mehr oder weniger denkt, als Ihr Effort Level sonst erzeugen würde, können Sie dies auch direkt in Ihrem Prompt oder in `CLAUDE.md` sagen.

~~546~~

547Bei älteren Modellen verwendet Thinking ein festes Token-Budget, das aus Ihrer Output-Zuteilung gezogen wird. Das Budget variiert je nach Modell; siehe [`MAX_THINKING_TOKENS`](/de/env-vars) für Obergrenzen pro Modell. Sie können das Budget mit dieser Umgebungsvariable begrenzen oder Thinking vollständig über `/config` oder den `Option+T`/`Alt+T`-Toggle deaktivieren.

~~548~~

549Auf Modellen mit adaptivem Denken gilt `MAX_THINKING_TOKENS` nur, wenn es auf `0` gesetzt ist, um Thinking zu deaktivieren, oder wenn `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1` das Modell auf das feste Budget zurückversetzt. `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` gilt nur für Opus 4.6 und Sonnet 4.6. Opus 4.7 verwendet immer adaptives Denken und unterstützt kein festes Thinking-Budget. Siehe [Umgebungsvariablen](/de/env-vars).

~~550~~

551<Warning>

552 Ihnen werden alle verwendeten Thinking-Tokens berechnet, auch wenn Thinking-Zusammenfassungen redigiert werden. Im interaktiven Modus wird Thinking standardmäßig als zusammengefasster Stub angezeigt. Setzen Sie `showThinkingSummaries: true` in `settings.json`, um vollständige Zusammenfassungen anzuzeigen.

553</Warning>

~~554~~

555***

~~556~~

557## Vorherige Gespräche fortsetzen

~~558~~

559Wenn Sie Claude Code starten, können Sie eine vorherige Sitzung fortsetzen:

~~560~~

561* `claude --continue` setzt das neueste Gespräch im aktuellen Verzeichnis fort

562* `claude --resume` öffnet eine Gesprächsauswahl oder setzt nach Name fort

563* `claude --from-pr 123` setzt Sitzungen fort, die mit einem bestimmten Pull Request verknüpft sind

~~564~~

565Verwenden Sie innerhalb einer aktiven Sitzung `/resume`, um zu einem anderen Gespräch zu wechseln.

~~566~~

567Wenn die ausgewählte Sitzung alt und groß genug ist, dass das erneute Lesen einen wesentlichen Teil Ihrer Nutzungslimits verbrauchen würde, bieten `--resume`, `--continue` und `/resume` an, statt des vollständigen Transkripts von einer Zusammenfassung aus fortzufahren. Diese Eingabeaufforderung ist nicht auf Amazon Bedrock, Google Cloud Vertex AI oder Microsoft Foundry verfügbar.

~~568~~

569Sitzungen werden pro Projektverzeichnis gespeichert. Standardmäßig zeigt die `/resume`-Auswahl interaktive Sitzungen aus dem aktuellen Worktree mit Tastaturkürzeln, um die Liste auf andere Worktrees oder Projekte zu erweitern, zu suchen, in der Vorschau anzuzeigen und umzubenennen. Siehe [Verwenden Sie die Sitzungsauswahl](#use-the-session-picker) unten für die vollständige Tastaturkürzel-Referenz.

~~570~~

571Wenn Sie eine Sitzung aus einem anderen Worktree desselben Repositorys auswählen, setzt Claude Code sie direkt fort, ohne dass Sie zuerst das Verzeichnis wechseln müssen. Wenn Sie eine Sitzung aus einem nicht verwandten Projekt auswählen, wird ein `cd`- und Resume-Befehl stattdessen in Ihre Zwischenablage kopiert.

~~572~~

573Das Fortsetzen nach Name wird über das aktuelle Repository und seine Worktrees aufgelöst. Sowohl `claude --resume <name>` als auch `/resume <name>` suchen nach einer genauen Übereinstimmung und setzen sie direkt fort, auch wenn die Sitzung in einem anderen Worktree lebt.

~~574~~

575Wenn der Name mehrdeutig ist, öffnet `claude --resume <name>` die Auswahl mit dem Namen als vorgefülltem Suchbegriff. `/resume <name>` aus einer aktiven Sitzung meldet stattdessen einen Fehler, also führen Sie `/resume` ohne Argument aus, um die Auswahl zu öffnen und auszuwählen.

~~576~~

577Sitzungen, die von `claude -p` oder SDK-Aufrufen erstellt wurden, werden nicht in der Auswahl angezeigt, aber Sie können eine trotzdem fortsetzen, indem Sie ihre Sitzungs-ID direkt an `claude --resume <session-id>` übergeben.

~~578~~

579### Benennen Sie Ihre Sitzungen

~~580~~

581Geben Sie Sitzungen beschreibende Namen, um sie später zu finden. Dies ist eine Best Practice, wenn Sie an mehreren Aufgaben oder Funktionen arbeiten.

~~582~~

583<Steps>

584 <Step title="Benennen Sie die Sitzung">

585 Benennen Sie eine Sitzung beim Start mit `-n`:

~~586~~

587 ```bash theme={null}

588 claude -n auth-refactor

589 ```

~~590~~

591 Oder verwenden Sie `/rename` während einer Sitzung, was auch den Namen in der Prompt-Leiste anzeigt:

~~592~~

593 ```text theme={null}

594 /rename auth-refactor

595 ```

~~596~~

597 Sie können jede Sitzung auch aus der Auswahl umbenennen: Führen Sie `/resume` aus, navigieren Sie zu einer Sitzung, und drücken Sie `Ctrl+R`.

598 </Step>

~~599~~

600 <Step title="Später nach Name fortsetzen">

601 Aus der Befehlszeile:

~~602~~

603 ```bash theme={null}

604 claude --resume auth-refactor

605 ```

~~606~~

607 Oder innerhalb einer aktiven Sitzung:

~~608~~

609 ```text theme={null}

610 /resume auth-refactor

611 ```

612 </Step>

613</Steps>

~~614~~

615### Verwenden Sie die Sitzungsauswahl

~~616~~

617Der Befehl `/resume` (oder `claude --resume` ohne Argumente) öffnet eine interaktive Sitzungsauswahl mit diesen Funktionen:

~~618~~

619**Tastaturkürzel in der Auswahl:**

~~620~~

621| Verknüpfung | Aktion |

622| :------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

623| `↑` / `↓` | Navigieren Sie zwischen Sitzungen |

624| `→` / `←` | Erweitern oder reduzieren Sie gruppierte Sitzungen |

625| `Enter` | Wählen Sie die hervorgehobene Sitzung aus und setzen Sie sie fort |

626| `Space` | Zeigen Sie eine Vorschau des Sitzungsinhalts an. `Ctrl+V` funktioniert auch auf Terminals, die es nicht als Einfügen erfassen |

627| `Ctrl+R` | Benennen Sie die hervorgehobene Sitzung um |

628| `/` oder ein beliebiges druckbares Zeichen außer `Space` | Geben Sie den Suchmodus ein und filtern Sie Sitzungen |

629| `Ctrl+A` | Zeigen Sie Sitzungen aus allen Projekten auf diesem Computer an. Drücken Sie erneut, um zum aktuellen Repository zurückzukehren |

630| `Ctrl+W` | Zeigen Sie Sitzungen aus allen Worktrees des aktuellen Repositorys an. Drücken Sie erneut, um zum aktuellen Worktree zurückzukehren. Wird nur in Multi-Worktree-Repositorys angezeigt |

631| `Ctrl+B` | Filtern Sie zu Sitzungen aus Ihrem aktuellen Git-Branch. Drücken Sie erneut, um Sitzungen aus allen Branches anzuzeigen |

632| `Esc` | Beenden Sie die Auswahl oder den Suchmodus |

~~633~~

634**Sitzungsorganisation:**

~~635~~

636Die Auswahl zeigt Sitzungen mit hilfreichen Metadaten an:

~~637~~

638* Sitzungsname, falls festgelegt, ansonsten die Gesprächszusammenfassung oder der erste Benutzer-Prompt

639* Verstrichene Zeit seit letzter Aktivität

640* Nachrichtenanzahl

641* Git-Branch (falls zutreffend)

642* Projektpfad, angezeigt nach Erweiterung auf alle Projekte mit `Ctrl+A`

~~643~~

644Verzweigte Sitzungen (erstellt mit `/branch`, `/rewind` oder `--fork-session`) werden unter ihrer Root-Sitzung gruppiert, was es einfacher macht, verwandte Gespräche zu finden.

~~645~~

646<Tip>

647 Tipps:

~~648~~

649 * **Benennen Sie Sitzungen früh**: Verwenden Sie `/rename`, wenn Sie mit einer bestimmten Aufgabe beginnen – es ist viel einfacher, „payment-integration" später zu finden als „explain this function"

650 * Verwenden Sie `--continue` für schnellen Zugriff auf Ihr letztes Gespräch im aktuellen Verzeichnis

651 * Verwenden Sie `--resume session-name`, wenn Sie wissen, welche Sitzung Sie benötigen

652 * Verwenden Sie `--resume` (ohne Namen), wenn Sie durchsuchen und auswählen müssen

653 * Verwenden Sie für Skripte `claude --continue --print "prompt"`, um im nicht-interaktiven Modus fortzufahren

654 * Drücken Sie `Space` in der Auswahl, um eine Sitzung vor dem Fortsetzen in der Vorschau anzuzeigen

655 * Die fortgesetzte Konversation beginnt mit demselben Modell und der gleichen Konfiguration wie das Original

~~656~~

657 Wie es funktioniert:

~~658~~

659 1. **Gesprächsspeicherung**: Alle Gespräche werden automatisch lokal mit ihrer vollständigen Nachrichtenhistorie gespeichert

660 2. **Nachricht-Deserialisierung**: Beim Fortsetzen wird die gesamte Nachrichtenhistorie wiederhergestellt, um den Kontext zu bewahren

661 3. **Tool-Status**: Die Tool-Nutzung und Ergebnisse aus dem vorherigen Gespräch werden beibehalten

662 4. **Kontext-Wiederherstellung**: Das Gespräch wird mit allen vorherigen Kontexten intakt fortgesetzt

663</Tip>

~~664~~

665***

~~666~~

667## Führen Sie parallele Claude Code-Sitzungen mit Git Worktrees aus

~~668~~

669Wenn Sie an mehreren Aufgaben gleichzeitig arbeiten, benötigt jede Claude-Sitzung ihre eigene Kopie der Codebase, damit Änderungen nicht kollidieren. Git Worktrees lösen dies, indem sie separate Arbeitsverzeichnisse erstellen, die jeweils ihre eigenen Dateien und Branches haben, während sie die gleiche Repository-Historie und Remote-Verbindungen teilen. Dies bedeutet, dass Sie Claude an einer Funktion in einem Worktree arbeiten lassen können, während Sie einen Fehler in einem anderen beheben, ohne dass eine Sitzung die andere beeinträchtigt.

~~670~~

671Verwenden Sie das Flag `--worktree` (`-w`), um einen isolierten Worktree zu erstellen und Claude darin zu starten. Der Wert, den Sie übergeben, wird zum Worktree-Verzeichnisnamen und Branch-Namen:

~~672~~

673```bash theme={null}

674# Starten Sie Claude in einem Worktree namens „feature-auth"

675# Erstellt .claude/worktrees/feature-auth/ mit einem neuen Branch

676claude --worktree feature-auth

~~677~~

678# Starten Sie eine weitere Sitzung in einem separaten Worktree

679claude --worktree bugfix-123

680```

~~681~~

682Wenn Sie den Namen weglassen, generiert Claude automatisch einen zufälligen:

~~683~~

684```bash theme={null}

685# Generiert automatisch einen Namen wie „bright-running-fox"

686claude --worktree

687```

~~688~~

689Worktrees werden unter `<repo>/.claude/worktrees/<name>` erstellt und verzweigen sich vom Standard-Remote-Branch, auf den `origin/HEAD` zeigt. Der Worktree-Branch wird `worktree-<name>` genannt.

~~690~~

691Der Basis-Branch ist nicht über ein Claude Code-Flag oder eine Einstellung konfigurierbar. `origin/HEAD` ist eine Referenz, die in Ihrem lokalen `.git`-Verzeichnis gespeichert ist und die Git einmal beim Klonen gesetzt hat. Wenn sich der Standard-Branch des Repositorys später auf GitHub oder GitLab ändert, zeigt Ihre lokale `origin/HEAD` weiterhin auf den alten, und Worktrees verzweigen sich von dort. Um Ihre lokale Referenz mit dem, was der Remote derzeit als Standard betrachtet, neu zu synchronisieren:

~~692~~

693```bash theme={null}

694git remote set-head origin -a

695```

~~696~~

697Dies ist ein Standard-Git-Befehl, der nur Ihr lokales `.git`-Verzeichnis aktualisiert. Nichts auf dem Remote-Server ändert sich. Wenn Sie möchten, dass Worktrees sich von einem bestimmten Branch aus verzweigen, anstatt vom Standard des Remote, setzen Sie ihn explizit mit `git remote set-head origin your-branch-name`.

~~698~~

699Für vollständige Kontrolle über die Erstellung von Worktrees, einschließlich der Auswahl einer anderen Basis pro Aufruf, konfigurieren Sie einen [WorktreeCreate Hook](/de/hooks#worktreecreate). Der Hook ersetzt Claudes Standard-`git worktree`-Logik vollständig, sodass Sie von jedem Ref abrufen und verzweigen können, den Sie benötigen.

~~700~~

701Sie können auch Claude während einer Sitzung bitten, „in einem Worktree zu arbeiten" oder „einen Worktree zu starten", und er erstellt automatisch einen.

~~702~~

703### Subagent Worktrees

~~704~~

705Subagents können auch Worktree-Isolation verwenden, um parallel ohne Konflikte zu arbeiten. Bitten Sie Claude, „Worktrees für Ihre Agents zu verwenden" oder konfigurieren Sie es in einem [benutzerdefinierten Subagent](/de/sub-agents#supported-frontmatter-fields), indem Sie `isolation: worktree` zum Frontmatter des Agents hinzufügen. Jeder Subagent erhält seinen eigenen Worktree, der automatisch bereinigt wird, wenn der Subagent ohne Änderungen beendet wird.

~~706~~

707### Worktree-Bereinigung

~~708~~

709Wenn Sie eine Worktree-Sitzung beenden, handhabt Claude die Bereinigung basierend darauf, ob Sie Änderungen vorgenommen haben:

~~710~~

711* **Keine Änderungen**: Der Worktree und sein Branch werden automatisch entfernt

712* **Änderungen oder Commits vorhanden**: Claude fragt Sie, ob Sie den Worktree behalten oder entfernen möchten. Das Behalten bewahrt das Verzeichnis und den Branch, damit Sie später zurückkehren können. Das Entfernen löscht das Worktree-Verzeichnis und seinen Branch und verwirft alle nicht committeten Änderungen und Commits

~~713~~

714Subagent-Worktrees, die durch einen Absturz oder einen unterbrochenen parallelen Lauf verwaist sind, werden beim Start automatisch entfernt, sobald sie älter als Ihre [`cleanupPeriodDays`](/de/settings#available-settings)-Einstellung sind, vorausgesetzt, sie haben keine nicht committeten Änderungen, keine nicht verfolgten Dateien und keine nicht gepushten Commits. Worktrees, die Sie mit `--worktree` erstellen, werden durch diese Bereinigung nie entfernt.

~~715~~

716Um Worktrees außerhalb einer Claude-Sitzung zu bereinigen, verwenden Sie [manuelle Worktree-Verwaltung](#manage-worktrees-manually).

~~717~~

718<Tip>

719 Fügen Sie `.claude/worktrees/` zu Ihrer `.gitignore` hinzu, um zu verhindern, dass Worktree-Inhalte als nicht verfolgte Dateien in Ihrem Haupt-Repository angezeigt werden.

720</Tip>

~~721~~

722### Kopieren Sie gitignorierte Dateien zu Worktrees

~~723~~

724Git Worktrees sind frische Checkouts, daher enthalten sie keine nicht verfolgten Dateien wie `.env` oder `.env.local` aus Ihrem Haupt-Repository. Um diese Dateien automatisch zu kopieren, wenn Claude einen Worktree erstellt, fügen Sie eine `.worktreeinclude`-Datei zu Ihrem Projektroot hinzu.

~~725~~

726Die Datei verwendet `.gitignore`-Syntax, um aufzulisten, welche Dateien kopiert werden sollen. Nur Dateien, die einem Muster entsprechen und auch gitignoriert sind, werden kopiert, daher werden verfolgte Dateien niemals dupliziert.

~~727~~

728```text .worktreeinclude theme={null}

729.env

730.env.local

731config/secrets.json

732```

~~733~~

734Dies gilt für Worktrees, die mit `--worktree`, Subagent-Worktrees und parallele Sitzungen in der [Desktop-App](/de/desktop#work-in-parallel-with-sessions) erstellt werden.

~~735~~

736### Verwalten Sie Worktrees manuell

~~737~~

738Für mehr Kontrolle über den Worktree-Speicherort und die Branch-Konfiguration erstellen Sie Worktrees direkt mit Git. Dies ist nützlich, wenn Sie einen bestimmten vorhandenen Branch auschecken oder den Worktree außerhalb des Repositorys platzieren müssen.

~~739~~

740```bash theme={null}

741# Erstellen Sie einen Worktree mit einem neuen Branch

742git worktree add ../project-feature-a -b feature-a

~~743~~

744# Erstellen Sie einen Worktree mit einem vorhandenen Branch

745git worktree add ../project-bugfix bugfix-123

~~746~~

747# Starten Sie Claude im Worktree

748cd ../project-feature-a && claude

~~749~~

750# Bereinigen Sie, wenn Sie fertig sind

751git worktree list

752git worktree remove ../project-feature-a

753```

~~754~~

755Weitere Informationen finden Sie in der [offiziellen Git Worktree-Dokumentation](https://git-scm.com/docs/git-worktree).

~~756~~

757<Tip>

758 Denken Sie daran, Ihre Entwicklungsumgebung in jedem neuen Worktree gemäß der Einrichtung Ihres Projekts zu initialisieren. Je nach Ihrem Stack kann dies die Ausführung der Abhängigkeitsinstallation (`npm install`, `yarn`), das Einrichten virtueller Umgebungen oder das Befolgen des Standard-Setup-Prozesses Ihres Projekts umfassen.

759</Tip>

~~760~~

761### Nicht-Git-Versionskontrolle

~~762~~

763Worktree-Isolation funktioniert standardmäßig mit Git. Für andere Versionskontrollsysteme wie SVN, Perforce oder Mercurial konfigurieren Sie [WorktreeCreate und WorktreeRemove Hooks](/de/hooks#worktreecreate), um benutzerdefinierte Worktree-Erstellungs- und Bereinigungslogik bereitzustellen. Wenn konfiguriert, ersetzen diese Hooks das Standard-Git-Verhalten, wenn Sie `--worktree` verwenden, daher wird [`.worktreeinclude`](#copy-gitignored-files-to-worktrees) nicht verarbeitet. Kopieren Sie alle lokalen Konfigurationsdateien stattdessen in Ihrem Hook-Skript.

~~764~~

765Für automatisierte Koordination paralleler Sitzungen mit gemeinsamen Aufgaben und Messaging siehe [Agent Teams](/de/agent-teams).

~~766~~

767***

~~768~~

769## Erhalten Sie Benachrichtigungen, wenn Claude Ihre Aufmerksamkeit benötigt

~~770~~

771Wenn Sie eine lange laufende Aufgabe starten und zu einem anderen Fenster wechseln, können Sie Desktop-Benachrichtigungen einrichten, damit Sie wissen, wenn Claude fertig ist oder Ihre Eingabe benötigt. Dies verwendet das `Notification` [Hook-Ereignis](/de/hooks-guide#get-notified-when-claude-needs-input), das immer dann ausgelöst wird, wenn Claude auf Berechtigung wartet, untätig ist und bereit für einen neuen Prompt ist, oder die Authentifizierung abgeschlossen ist.

~~772~~

773<Steps>

774 <Step title="Fügen Sie den Hook zu Ihren Einstellungen hinzu">

775 Öffnen Sie `~/.claude/settings.json` und fügen Sie einen `Notification` Hook hinzu, der den nativen Benachrichtigungsbefehl Ihrer Plattform aufruft:

~~776~~

777 <Tabs>

778 <Tab title="macOS">

779 ```json theme={null}

780 {

781 "hooks": {

782 "Notification": [

783 {

784 "matcher": "",

785 "hooks": [

786 {

787 "type": "command",

788 "command": "osascript -e 'display notification \"Claude Code needs your attention\" with title \"Claude Code\"'"

789 }

790 ]

791 }

792 ]

793 }

794 }

795 ```

796 </Tab>

~~797~~

798 <Tab title="Linux">

799 ```json theme={null}

800 {

801 "hooks": {

802 "Notification": [

803 {

804 "matcher": "",

805 "hooks": [

806 {

807 "type": "command",

808 "command": "notify-send 'Claude Code' 'Claude Code needs your attention'"

809 }

810 ]

811 }

812 ]

813 }

814 }

815 ```

816 </Tab>

~~817~~

818 <Tab title="Windows">

819 ```json theme={null}

820 {

821 "hooks": {

822 "Notification": [

823 {

824 "matcher": "",

825 "hooks": [

826 {

827 "type": "command",

828 "command": "powershell.exe -Command \"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('Claude Code needs your attention', 'Claude Code')\""

829 }

830 ]

831 }

832 ]

833 }

834 }

835 ```

836 </Tab>

837 </Tabs>

~~838~~

839 Wenn Ihre Einstellungsdatei bereits einen `hooks`-Schlüssel hat, führen Sie den `Notification`-Eintrag darin zusammen, anstatt ihn zu überschreiben. Sie können Claude auch bitten, den Hook für Sie zu schreiben, indem Sie beschreiben, was Sie in der CLI möchten.

840 </Step>

~~841~~

842 <Step title="Grenzen Sie den Matcher optional ein">

843 Standardmäßig wird der Hook bei allen Benachrichtigungstypen ausgelöst. Um nur für bestimmte Ereignisse ausgelöst zu werden, setzen Sie das Feld `matcher` auf einen dieser Werte:

~~844~~

845 | Matcher | Wird ausgelöst, wenn |

846 | :--------------------- | :-------------------------------------------------------------- |

847 | `permission_prompt` | Claude benötigt Ihre Genehmigung für eine Tool-Nutzung |

848 | `idle_prompt` | Claude ist fertig und wartet auf Ihren nächsten Prompt |

849 | `auth_success` | Die Authentifizierung ist abgeschlossen |

850 | `elicitation_dialog` | Ein MCP-Server öffnet ein Elicitierungsformular |

851 | `elicitation_complete` | Ein MCP-Elicitierungsformular wird eingereicht oder verworfen |

852 | `elicitation_response` | Eine MCP-Elicitierungsantwort wird an den Server zurückgesendet |

853 </Step>

~~854~~

855 <Step title="Überprüfen Sie den Hook">

856 Geben Sie `/hooks` ein und wählen Sie `Notification` aus, um zu bestätigen, dass der Hook angezeigt wird. Wenn Sie ihn auswählen, wird der Befehl angezeigt, der ausgeführt wird. Um ihn end-to-end zu testen, bitten Sie Claude, einen Befehl auszuführen, der Berechtigung erfordert, und wechseln Sie weg vom Terminal, oder bitten Sie Claude, direkt eine Benachrichtigung auszulösen.

857 </Step>

858</Steps>

~~859~~

860Für das vollständige Ereignisschema und die Benachrichtigungstypen siehe die [Benachrichtigungsreferenz](/de/hooks#notification).

~~861~~

862***

~~863~~

864## Verwenden Sie Claude als Unix-ähnliches Dienstprogramm

~~865~~

866### Fügen Sie Claude zu Ihrem Überprüfungsprozess hinzu

~~867~~

868Angenommen, Sie möchten Claude Code als Linter oder Code-Reviewer verwenden.

~~869~~

870**Fügen Sie Claude zu Ihrem Build-Skript hinzu:**

~~871~~

872```json theme={null}

873// package.json

874{

875 ...

876 "scripts": {

877 ...

878 "lint:claude": "claude -p 'you are a linter. please look at the changes vs. main and report any issues related to typos. report the filename and line number on one line, and a description of the issue on the second line. do not return any other text.'"

879 }

880}

881```

~~882~~

883<Tip>

884 Tipps:

~~885~~

886 * Verwenden Sie Claude für automatisierte Code-Überprüfung in Ihrer CI/CD-Pipeline

887 * Passen Sie den Prompt an, um auf spezifische Probleme zu überprüfen, die für Ihr Projekt relevant sind

888 * Erwägen Sie, mehrere Skripte für verschiedene Arten von Überprüfungen zu erstellen

889</Tip>

~~890~~

891### Pipe in, Pipe out

~~892~~

893Angenommen, Sie möchten Daten in Claude pipen und Daten in einem strukturierten Format zurückbekommen.

~~894~~

895**Pipen Sie Daten durch Claude:**

~~896~~

897```bash theme={null}

898cat build-error.txt | claude -p 'concisely explain the root cause of this build error' > output.txt

899```

~~900~~

901<Tip>

902 Tipps:

~~903~~

904 * Verwenden Sie Pipes, um Claude in vorhandene Shell-Skripte zu integrieren

905 * Kombinieren Sie mit anderen Unix-Tools für leistungsstarke Workflows

906 * Erwägen Sie die Verwendung von `--output-format` für strukturierte Ausgabe

907</Tip>

~~908~~

909### Steuern Sie das Ausgabeformat

~~910~~

911Angenommen, Sie benötigen Claudes Ausgabe in einem bestimmten Format, besonders wenn Sie Claude Code in Skripte oder andere Tools integrieren.

~~912~~

913<Steps>

914 <Step title="Verwenden Sie Textformat (Standard)">

915 ```bash theme={null}

916 cat data.txt | claude -p 'summarize this data' --output-format text > summary.txt

917 ```

~~918~~

919 Dies gibt nur Claudes einfache Textantwort aus (Standardverhalten).

920 </Step>

~~921~~

922 <Step title="Verwenden Sie JSON-Format">

923 ```bash theme={null}

924 cat code.py | claude -p 'analyze this code for bugs' --output-format json > analysis.json

925 ```

~~926~~

927 Dies gibt ein JSON-Array von Nachrichten mit Metadaten einschließlich Kosten und Dauer aus.

928 </Step>

~~929~~

930 <Step title="Verwenden Sie Streaming-JSON-Format">

931 ```bash theme={null}

932 cat log.txt | claude -p 'parse this log file for errors' --output-format stream-json

933 ```

~~934~~

935 Dies gibt eine Reihe von JSON-Objekten in Echtzeit aus, während Claude die Anfrage verarbeitet. Jede Nachricht ist ein gültiges JSON-Objekt, aber die gesamte Ausgabe ist kein gültiges JSON, wenn es verkettet wird.

936 </Step>

937</Steps>

~~938~~

939<Tip>

940 Tipps:

~~941~~

942 * Verwenden Sie `--output-format text` für einfache Integrationen, bei denen Sie nur Claudes Antwort benötigen

943 * Verwenden Sie `--output-format json`, wenn Sie das vollständige Gesprächsprotokoll benötigen

944 * Verwenden Sie `--output-format stream-json` für Echtzeit-Ausgabe jedes Gesprächsturn

945</Tip>

~~946~~

947***

~~948~~

949## Führen Sie Claude nach einem Zeitplan aus

950 396

951Angenommen, Sie möchten Claude automatisch eine Aufgabe auf wiederkehrender Basis ausführen, z. B. offene PRs jeden Morgen überprüfen, Abhängigkeiten wöchentlich prüfen oder über Nacht auf CI-Fehler überprüfen.397Angenommen, Sie möchten Claude automatisch eine Aufgabe auf wiederkehrender Basis ausführen, z. B. offene PRs jeden Morgen überprüfen, Abhängigkeiten wöchentlich prüfen oder über Nacht auf CI-Fehler überprüfen.

952 398

961 407

962<Tip>408<Tip>

963 Wenn Sie Prompts für geplante Aufgaben schreiben, seien Sie explizit darüber, wie Erfolg aussieht und was mit Ergebnissen zu tun ist. Die Aufgabe wird autonom ausgeführt, daher kann sie keine Klärungsfragen stellen. Beispiel: 'Überprüfen Sie offene PRs mit dem Label `needs-review`, hinterlassen Sie Inline-Kommentare zu Problemen und posten Sie eine Zusammenfassung im `#eng-reviews` Slack-Kanal."409 Wenn Sie Prompts für geplante Aufgaben schreiben, seien Sie explizit darüber, wie Erfolg aussieht und was mit Ergebnissen zu tun ist. Die Aufgabe wird autonom ausgeführt, daher kann sie keine Klärungsfragen stellen. Beispiel: „Überprüfen Sie offene PRs mit dem Label `needs-review`, hinterlassen Sie Inline-Kommentare zu Problemen und posten Sie eine Zusammenfassung im `#eng-reviews` Slack-Kanal."

964</Tip>410</Tip>

965 411

966***412***

967 413

968## Fragen Sie Claude nach seinen Fähigkeiten414### Fragen Sie Claude nach seinen Fähigkeiten

969 415

970Claude hat integrierten Zugriff auf seine Dokumentation und kann Fragen zu seinen eigenen Funktionen und Einschränkungen beantworten.416Claude hat integrierten Zugriff auf seine Dokumentation und kann Fragen zu seinen eigenen Funktionen und Einschränkungen beantworten.

971 417

972### Beispielfragen418#### Beispielfragen

973 419

974```text theme={null}420```text theme={null}

975can Claude Code create pull requests?421can Claude Code create pull requests?

1009 455

1010***456***

1011 457

458## Vorherige Gespräche fortsetzen

459

460Wenn eine Aufgabe mehrere Sitzungen umfasst, setzen Sie dort fort, wo Sie aufgehört haben, anstatt den Kontext erneut zu erklären. Claude Code speichert jedes Gespräch lokal.

461

462```bash theme={null}

463claude --continue

464```

465

466Dies setzt die neueste Sitzung im aktuellen Verzeichnis fort; wenn es noch keine gibt, wird `No conversation found to continue` gedruckt und das Programm beendet. Verwenden Sie `claude --resume`, um aus einer Liste auszuwählen, oder `/resume` innerhalb einer laufenden Sitzung. Siehe [Sitzungen verwalten](/de/sessions) für Benennung, Verzweigung und die vollständige Auswahl-Referenz.

467

468## Parallele Sitzungen mit Worktrees ausführen

469

470Arbeiten Sie an einer Funktion in einem Terminal, während Claude einen Fehler in einem anderen behebt, ohne dass die Änderungen kollidieren. Jeder Worktree ist ein separater Checkout auf seinem eigenen Branch.

471

472```bash theme={null}

473claude --worktree feature-auth

474```

475

476Führen Sie denselben Befehl mit einem anderen Namen in einem zweiten Terminal aus, um eine isolierte parallele Sitzung zu starten. Siehe [Worktrees](/de/worktrees) für Bereinigung, `.worktreeinclude` und Unterstützung für nicht-Git-VCS. Um parallele Sitzungen von einem Bildschirm aus zu überwachen, anstatt separate Terminals zu verwenden, siehe [Background Agents](/de/agent-view).

477

478## Vor dem Bearbeiten planen

479

480Für Änderungen, die Sie überprüfen möchten, bevor sie die Festplatte berühren, wechseln Sie in den Plan Mode. Claude liest Dateien und schlägt einen Plan vor, macht aber keine Änderungen, bis Sie zustimmen.

481

482```bash theme={null}

483claude --permission-mode plan

484```

485

486Sie können auch `Shift+Tab` während einer Sitzung drücken, um in den Plan Mode zu wechseln. Siehe [Plan Mode](/de/permission-modes#analyze-before-you-edit-with-plan-mode) für den Genehmigungsfluss und das Bearbeiten des Plans in Ihrem Text-Editor.

487

488## Forschung an Subagents delegieren

489

490Das Erkunden einer großen Codebase füllt Ihren Kontext mit Dateilesevorgängen. Delegieren Sie die Erkundung, damit nur die Ergebnisse zurückkommen.

491

492```text theme={null}

493use a subagent to investigate how our auth system handles token refresh

494```

495

496Der Subagent liest Dateien in seinem eigenen Kontextfenster und meldet eine Zusammenfassung. Siehe [Subagents](/de/sub-agents) für die Definition benutzerdefinierter Agents mit ihren eigenen Tools und Prompts.

497

498## Claude in Skripte pipen

499

500Führen Sie Claude nicht-interaktiv für CI, Pre-Commit-Hooks oder Batch-Verarbeitung aus. Stdin und Stdout funktionieren wie jedes Unix-Tool.

501

502```bash theme={null}

503git log --oneline -20 | claude -p "summarize these recent commits"

504```

505

506Siehe [Non-Interactive Mode](/de/headless) für Ausgabeformate, Berechtigungsflags und Fan-Out-Muster.

507

1012## Nächste Schritte508## Nächste Schritte

1013 509

1014<CardGroup cols={2}>510<CardGroup cols={2}>

1016 Muster zum Herausholen des Besten aus Claude Code512 Muster zum Herausholen des Besten aus Claude Code

1017 </Card>513 </Card>

1018 514

1019 <Card title="Wie Claude Code funktioniert" icon="gear" href="/de/how-claude-code-works">515 <Card title="Sitzungen verwalten" icon="rotate-left" href="/de/sessions">

1020 Verstehen Sie die agentic Loop und Kontextverwaltung516 Fortsetzen, Benennen und Verzweigen von Gesprächen

1021 </Card>517 </Card>

1022 518

1023 <Card title="Erweitern Sie Claude Code" icon="puzzle-piece" href="/de/features-overview">519 <Card title="Worktrees" icon="code-branch" href="/de/worktrees">

1024 Fügen Sie Skills, Hooks, MCP, Subagents und Plugins hinzu520 Führen Sie isolierte parallele Sitzungen aus

1025 </Card>521 </Card>

1026 522

1027 <Card title="Referenzimplementierung" icon="code" href="https://github.com/anthropics/claude-code/tree/main/.devcontainer">523 <Card title="Claude Code erweitern" icon="puzzle-piece" href="/de/features-overview">

1028 Klonen Sie die Referenzimplementierung des Development Containers524 Fügen Sie Skills, Hooks, MCP, Subagents und Plugins hinzu

1029 </Card>525 </Card>

1030</CardGroup>526</CardGroup>

data-usage.md +11 −11

Details

67 67

68Das folgende Diagramm zeigt, wie Claude Code während der Installation und des normalen Betriebs eine Verbindung zu externen Diensten herstellt. Durchgehende Linien zeigen erforderliche Verbindungen an, während gestrichelte Linien optionale oder vom Benutzer initiierte Datenflüsse darstellen.68Das folgende Diagramm zeigt, wie Claude Code während der Installation und des normalen Betriebs eine Verbindung zu externen Diensten herstellt. Durchgehende Linien zeigen erforderliche Verbindungen an, während gestrichelte Linien optionale oder vom Benutzer initiierte Datenflüsse darstellen.

69 69

70<img src="https://mintcdn.com/claude-code/RcOyXc06Ja8cuvMZ/images/claude-code-data-flow.svg?fit=max&auto=format&n=RcOyXc06Ja8cuvMZ&q=85&s=b5be40abf333defe984993af89546c19" alt="Diagramm, das die externen Verbindungen von Claude Code zeigt: Installation/Update verbindet sich mit dem Verteilungsserver, und Benutzeranfragen verbinden sich mit Anthropic-Diensten, einschließlich Console-Authentifizierung, öffentlicher API und optional Statsig, Sentry und Bug-Berichterstattung" width="720" height="520" data-path="images/claude-code-data-flow.svg" />70<img src="https://mintcdn.com/claude-code/RcOyXc06Ja8cuvMZ/images/claude-code-data-flow.svg?fit=max&auto=format&n=RcOyXc06Ja8cuvMZ&q=85&s=b5be40abf333defe984993af89546c19" alt="Diagramm, das die externen Verbindungen von Claude Code zeigt: Installation/Update verbindet sich mit dem Verteilungsserver, und Benutzeranfragen verbinden sich mit Anthropic-Diensten, einschließlich Console-Authentifizierung, öffentlicher API und optional Metriken, Sentry und Bug-Berichterstattung" width="720" height="520" data-path="images/claude-code-data-flow.svg" />

71 71

72Claude Code wird lokal ausgeführt. Um mit dem LLM zu interagieren, sendet Claude Code Daten über das Netzwerk. Diese Daten umfassen alle Benutzereingabeaufforderungen und Modellausgaben, verschlüsselt während der Übertragung über TLS 1.2+. Claude Code ist mit den meisten gängigen VPNs und LLM-Proxys kompatibel.72Claude Code wird lokal ausgeführt. Um mit dem LLM zu interagieren, sendet Claude Code Daten über das Netzwerk. Diese Daten umfassen alle Benutzereingabeaufforderungen und Modellausgaben, verschlüsselt während der Übertragung über TLS 1.2+. Claude Code ist mit den meisten gängigen VPNs und LLM-Proxys kompatibel.

73 73

95 95

96## Telemetrie-Dienste96## Telemetrie-Dienste

97 97

98Claude Code verbindet sich von den Maschinen der Benutzer mit dem Statsig-Dienst, um operative Metriken wie Latenz, Zuverlässigkeit und Nutzungsmuster zu protokollieren. Diese Protokollierung umfasst keinen Code oder Dateipfade. Die Daten werden während der Übertragung mit TLS und im Ruhezustand mit 256-Bit-AES-Verschlüsselung verschlüsselt. Weitere Informationen finden Sie in der [Statsig-Sicherheitsdokumentation](https://www.statsig.com/trust/security). Um sich von der Statsig-Telemetrie abzumelden, setzen Sie die Umgebungsvariable `DISABLE_TELEMETRY`.98Claude Code verbindet sich von den Maschinen der Benutzer mit Anthropic, um operative Metriken wie Latenz, Zuverlässigkeit und Nutzungsmuster zu protokollieren. Diese Protokollierung umfasst keinen Code oder Dateipfade. Die Daten werden während der Übertragung und im Ruhezustand verschlüsselt. Um sich von der Telemetrie abzumelden, setzen Sie die Umgebungsvariable `DISABLE_TELEMETRY`.

99 99

100Claude Code verbindet sich von den Maschinen der Benutzer mit Sentry für operative Fehlerprotokollierung. Die Daten werden während der Übertragung mit TLS und im Ruhezustand mit 256-Bit-AES-Verschlüsselung verschlüsselt. Weitere Informationen finden Sie in der [Sentry-Sicherheitsdokumentation](https://sentry.io/security/). Um sich von der Fehlerprotokollierung abzumelden, setzen Sie die Umgebungsvariable `DISABLE_ERROR_REPORTING`.100Claude Code verbindet sich von den Maschinen der Benutzer mit Sentry für operative Fehlerprotokollierung. Die Daten werden während der Übertragung mit TLS und im Ruhezustand mit 256-Bit-AES-Verschlüsselung verschlüsselt. Weitere Informationen finden Sie in der [Sentry-Sicherheitsdokumentation](https://sentry.io/security/). Um sich von der Fehlerprotokollierung abzumelden, setzen Sie die Umgebungsvariable `DISABLE_ERROR_REPORTING`.

101 101

103 103

104## Standardverhalten nach API-Anbieter104## Standardverhalten nach API-Anbieter

105 105

106Standardmäßig sind Fehlerberichterstattung, Telemetrie und Bug-Berichterstattung deaktiviert, wenn Sie Bedrock, Vertex oder Foundry verwenden. Sitzungsqualitätsumfragen und die WebFetch-Domänensicherheitsprüfung sind Ausnahmen und werden unabhängig vom Anbieter ausgeführt. Sie können sich auf einmal von all dem nicht wesentlichen Datenverkehr, einschließlich Umfragen, abmelden, indem Sie `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` setzen. Diese Variable beeinträchtigt die WebFetch-Prüfung nicht, die ihre eigene Abmeldeoption hat. Hier sind die vollständigen Standardverhalten:106Standardmäßig sind Fehlerberichterstattung, Telemetrie und Bug-Berichterstattung deaktiviert, wenn Sie Bedrock, Vertex, Foundry oder Claude Platform auf AWS verwenden. Sitzungsqualitätsumfragen und die WebFetch-Domänensicherheitsprüfung sind Ausnahmen und werden unabhängig vom Anbieter ausgeführt. Sie können sich auf einmal von all dem nicht wesentlichen Datenverkehr, einschließlich Umfragen, abmelden, indem Sie `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` setzen. Diese Variable beeinträchtigt die WebFetch-Prüfung nicht, die ihre eigene Abmeldeoption hat. Hier sind die vollständigen Standardverhalten:

107 107

109| -------------------------------------- | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |109| -------------------------------------- | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |

110| **Statsig (Metriken)** | Standardmäßig aktiviert.<br />`DISABLE_TELEMETRY=1` zum Deaktivieren. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_VERTEX` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_BEDROCK` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_FOUNDRY` muss 1 sein. |110| **Anthropic (Metriken)** | Standardmäßig aktiviert.<br />`DISABLE_TELEMETRY=1` zum Deaktivieren. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_VERTEX` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_BEDROCK` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_FOUNDRY` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_ANTHROPIC_AWS` muss 1 sein. |

111| **Sentry (Fehler)** | Standardmäßig aktiviert.<br />`DISABLE_ERROR_REPORTING=1` zum Deaktivieren. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_VERTEX` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_BEDROCK` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_FOUNDRY` muss 1 sein. |111| **Sentry (Fehler)** | Standardmäßig aktiviert.<br />`DISABLE_ERROR_REPORTING=1` zum Deaktivieren. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_VERTEX` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_BEDROCK` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_FOUNDRY` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_ANTHROPIC_AWS` muss 1 sein. |

112| **Claude API (`/feedback`-Berichte)** | Standardmäßig aktiviert.<br />`DISABLE_FEEDBACK_COMMAND=1` zum Deaktivieren. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_VERTEX` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_BEDROCK` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_FOUNDRY` muss 1 sein. |112| **Claude API (`/feedback`-Berichte)** | Standardmäßig aktiviert.<br />`DISABLE_FEEDBACK_COMMAND=1` zum Deaktivieren. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_VERTEX` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_BEDROCK` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_FOUNDRY` muss 1 sein. | Standardmäßig deaktiviert.<br />`CLAUDE_CODE_USE_ANTHROPIC_AWS` muss 1 sein. |

113| **Sitzungsqualitätsumfragen** | Standardmäßig aktiviert.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` zum Deaktivieren. | Standardmäßig aktiviert.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` zum Deaktivieren. | Standardmäßig aktiviert.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` zum Deaktivieren. | Standardmäßig aktiviert.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` zum Deaktivieren. |113| **Sitzungsqualitätsumfragen** | Standardmäßig aktiviert.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` zum Deaktivieren. | Standardmäßig aktiviert.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` zum Deaktivieren. | Standardmäßig aktiviert.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` zum Deaktivieren. | Standardmäßig aktiviert.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` zum Deaktivieren. | Standardmäßig aktiviert.<br />`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY=1` zum Deaktivieren. |

114| **WebFetch-Domänensicherheitsprüfung** | Standardmäßig aktiviert.<br />`skipWebFetchPreflight: true` in [Einstellungen](/de/settings) zum Deaktivieren. | Standardmäßig aktiviert.<br />`skipWebFetchPreflight: true` in [Einstellungen](/de/settings) zum Deaktivieren. | Standardmäßig aktiviert.<br />`skipWebFetchPreflight: true` in [Einstellungen](/de/settings) zum Deaktivieren. | Standardmäßig aktiviert.<br />`skipWebFetchPreflight: true` in [Einstellungen](/de/settings) zum Deaktivieren. |114| **WebFetch-Domänensicherheitsprüfung** | Standardmäßig aktiviert.<br />`skipWebFetchPreflight: true` in [Einstellungen](/de/settings) zum Deaktivieren. | Standardmäßig aktiviert.<br />`skipWebFetchPreflight: true` in [Einstellungen](/de/settings) zum Deaktivieren. | Standardmäßig aktiviert.<br />`skipWebFetchPreflight: true` in [Einstellungen](/de/settings) zum Deaktivieren. | Standardmäßig aktiviert.<br />`skipWebFetchPreflight: true` in [Einstellungen](/de/settings) zum Deaktivieren. | Standardmäßig aktiviert.<br />`skipWebFetchPreflight: true` in [Einstellungen](/de/settings) zum Deaktivieren. |

115 115

116Alle Umgebungsvariablen können in `settings.json` eingecheckt werden (siehe [Einstellungsreferenz](/de/settings)).116Alle Umgebungsvariablen können in `settings.json` eingecheckt werden (siehe [Einstellungsreferenz](/de/settings)).

117 117

118Ab v2.1.126 werden Statsig-Metriken standardmäßig aktiviert für Vertex, Bedrock und Foundry, wenn eine Host-Plattform `CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST` setzt, und folgen der Standard-Abmeldeoption `DISABLE_TELEMETRY`. Sentry-Fehlerberichterstattung und `/feedback`-Berichte bleiben standardmäßig auf diesen Anbietern deaktiviert.118Ab v2.1.126 werden Metriken standardmäßig aktiviert für Vertex, Bedrock und Foundry, wenn eine Host-Plattform `CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST` setzt, und folgen der Standard-Abmeldeoption `DISABLE_TELEMETRY`. Sentry-Fehlerberichterstattung und `/feedback`-Berichte bleiben standardmäßig auf diesen Anbietern deaktiviert.

119 119

120### WebFetch-Domänensicherheitsprüfung120### WebFetch-Domänensicherheitsprüfung

121 121

env-vars.md +10 −4

Details

12| :------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |12| :------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

13| `ANTHROPIC_API_KEY` | API-Schlüssel, der als `X-Api-Key`-Header gesendet wird. Wenn gesetzt, wird dieser Schlüssel anstelle Ihres Claude Pro-, Max-, Team- oder Enterprise-Abonnements verwendet, auch wenn Sie angemeldet sind. Im nicht-interaktiven Modus (`-p`) wird der Schlüssel immer verwendet, wenn er vorhanden ist. Im interaktiven Modus werden Sie aufgefordert, den Schlüssel einmalig zu genehmigen, bevor er Ihr Abonnement überschreibt. Um stattdessen Ihr Abonnement zu verwenden, führen Sie `unset ANTHROPIC_API_KEY` aus |13| `ANTHROPIC_API_KEY` | API-Schlüssel, der als `X-Api-Key`-Header gesendet wird. Wenn gesetzt, wird dieser Schlüssel anstelle Ihres Claude Pro-, Max-, Team- oder Enterprise-Abonnements verwendet, auch wenn Sie angemeldet sind. Im nicht-interaktiven Modus (`-p`) wird der Schlüssel immer verwendet, wenn er vorhanden ist. Im interaktiven Modus werden Sie aufgefordert, den Schlüssel einmalig zu genehmigen, bevor er Ihr Abonnement überschreibt. Um stattdessen Ihr Abonnement zu verwenden, führen Sie `unset ANTHROPIC_API_KEY` aus |

14| `ANTHROPIC_AUTH_TOKEN` | Benutzerdefinierter Wert für den `Authorization`-Header (der hier gesetzte Wert wird mit `Bearer ` vorangestellt) |14| `ANTHROPIC_AUTH_TOKEN` | Benutzerdefinierter Wert für den `Authorization`-Header (der hier gesetzte Wert wird mit `Bearer ` vorangestellt) |

15| `ANTHROPIC_AWS_API_KEY` | Workspace API-Schlüssel für [Claude Platform on AWS](/de/claude-platform-on-aws), generiert in der AWS-Konsole. Wird als `x-api-key` gesendet und hat Vorrang vor AWS SigV4 |

16| `ANTHROPIC_AWS_BASE_URL` | Überschreiben Sie die [Claude Platform on AWS](/de/claude-platform-on-aws)-Endpunkt-URL. Verwenden Sie für benutzerdefinierte Regionen oder beim Routing durch ein [LLM-Gateway](/de/llm-gateway). Standardmäßig `https://aws-external-anthropic.{AWS_REGION}.api.aws` |

17| `ANTHROPIC_AWS_WORKSPACE_ID` | Erforderlich für [Claude Platform on AWS](/de/claude-platform-on-aws). Wird bei jeder Anfrage als `anthropic-workspace-id`-Header gesendet |

15| `ANTHROPIC_BASE_URL` | Überschreiben Sie den API-Endpunkt, um Anfragen durch einen Proxy oder ein Gateway zu leiten. Wenn auf einen Nicht-First-Party-Host gesetzt, ist die [MCP-Tool-Suche](/de/mcp#scale-with-mcp-tool-search) standardmäßig deaktiviert. Setzen Sie `ENABLE_TOOL_SEARCH=true`, wenn Ihr Proxy `tool_reference`-Blöcke weiterleitet |18| `ANTHROPIC_BASE_URL` | Überschreiben Sie den API-Endpunkt, um Anfragen durch einen Proxy oder ein Gateway zu leiten. Wenn auf einen Nicht-First-Party-Host gesetzt, ist die [MCP-Tool-Suche](/de/mcp#scale-with-mcp-tool-search) standardmäßig deaktiviert. Setzen Sie `ENABLE_TOOL_SEARCH=true`, wenn Ihr Proxy `tool_reference`-Blöcke weiterleitet |

16| `ANTHROPIC_BEDROCK_BASE_URL` | Überschreiben Sie die Bedrock-Endpunkt-URL. Verwenden Sie für benutzerdefinierte Bedrock-Endpunkte oder beim Routing durch ein [LLM-Gateway](/de/llm-gateway). Siehe [Amazon Bedrock](/de/amazon-bedrock) |19| `ANTHROPIC_BEDROCK_BASE_URL` | Überschreiben Sie die Bedrock-Endpunkt-URL. Verwenden Sie für benutzerdefinierte Bedrock-Endpunkte oder beim Routing durch ein [LLM-Gateway](/de/llm-gateway). Siehe [Amazon Bedrock](/de/amazon-bedrock) |

17| `ANTHROPIC_BEDROCK_MANTLE_BASE_URL` | Überschreiben Sie die Bedrock Mantle-Endpunkt-URL. Siehe [Mantle-Endpunkt](/de/amazon-bedrock#use-the-mantle-endpoint) |20| `ANTHROPIC_BEDROCK_MANTLE_BASE_URL` | Überschreiben Sie die Bedrock Mantle-Endpunkt-URL. Siehe [Mantle-Endpunkt](/de/amazon-bedrock#use-the-mantle-endpoint) |

45| `API_TIMEOUT_MS` | Timeout für API-Anfragen in Millisekunden (Standard: 600000 oder 10 Minuten; Maximum: 2147483647). Erhöhen Sie dies, wenn Anfragen bei langsamen Netzwerken oder beim Routing durch einen Proxy Timeout-Fehler verursachen. Werte über dem Maximum führen zu Überläufen des zugrunde liegenden Timers und verursachen, dass Anfragen sofort fehlschlagen |48| `API_TIMEOUT_MS` | Timeout für API-Anfragen in Millisekunden (Standard: 600000 oder 10 Minuten; Maximum: 2147483647). Erhöhen Sie dies, wenn Anfragen bei langsamen Netzwerken oder beim Routing durch einen Proxy Timeout-Fehler verursachen. Werte über dem Maximum führen zu Überläufen des zugrunde liegenden Timers und verursachen, dass Anfragen sofort fehlschlagen |

46| `AWS_BEARER_TOKEN_BEDROCK` | Bedrock API-Schlüssel für Authentifizierung (siehe [Bedrock API-Schlüssel](https://aws.amazon.com/blogs/machine-learning/accelerate-ai-development-with-amazon-bedrock-api-keys/)) |49| `AWS_BEARER_TOKEN_BEDROCK` | Bedrock API-Schlüssel für Authentifizierung (siehe [Bedrock API-Schlüssel](https://aws.amazon.com/blogs/machine-learning/accelerate-ai-development-with-amazon-bedrock-api-keys/)) |

48| `BASH_MAX_OUTPUT_LENGTH` | Maximale Anzahl von Zeichen in Bash-Ausgaben, bevor sie in der Mitte gekürzt werden |51| `BASH_MAX_OUTPUT_LENGTH` | Maximale Anzahl von Zeichen in Bash-Ausgaben, bevor die vollständige Ausgabe in einer Datei gespeichert wird und Claude den Pfad plus eine kurze Vorschau erhält. Siehe [Bash-Tool-Verhalten](/de/tools-reference#bash-tool-behavior) |

49| `BASH_MAX_TIMEOUT_MS` | Maximales Timeout, das das Modell für lang laufende Bash-Befehle setzen kann (Standard: 600000 oder 10 Minuten) |52| `BASH_MAX_TIMEOUT_MS` | Maximales Timeout, das das Modell für lang laufende Bash-Befehle setzen kann (Standard: 600000 oder 10 Minuten) |

50| `CCR_FORCE_BUNDLE` | Setzen Sie auf `1`, um [`claude --remote`](/de/claude-code-on-the-web#send-local-repositories-without-github) zu erzwingen, Ihr lokales Repository zu bündeln und hochzuladen, auch wenn GitHub-Zugriff verfügbar ist |53| `CCR_FORCE_BUNDLE` | Setzen Sie auf `1`, um [`claude --remote`](/de/claude-code-on-the-web#send-local-repositories-without-github) zu erzwingen, Ihr lokales Repository zu bündeln und hochzuladen, auch wenn GitHub-Zugriff verfügbar ist |

51| `CLAUDECODE` | Auf `1` in Shell-Umgebungen gesetzt, die Claude Code spawnt (Bash-Tool, tmux-Sitzungen). Nicht gesetzt in [Hooks](/de/hooks) oder [Statuszeilen](/de/statusline)-Befehlen. Verwenden Sie, um zu erkennen, wenn ein Skript in einer Shell ausgeführt wird, die von Claude Code gespawnt wurde |54| `CLAUDECODE` | Auf `1` in Shell-Umgebungen gesetzt, die Claude Code spawnt (Bash-Tool, tmux-Sitzungen). Nicht gesetzt in [Hooks](/de/hooks) oder [Statuszeilen](/de/statusline)-Befehlen. Verwenden Sie, um zu erkennen, wenn ein Skript in einer Shell ausgeführt wird, die von Claude Code gespawnt wurde |

69| `CLAUDE_CODE_DEBUG_LOG_LEVEL` | Minimale Protokollierungsstufe, die in die Debug-Protokolldatei geschrieben wird. Werte: `verbose`, `debug` (Standard), `info`, `warn`, `error`. Setzen Sie auf `verbose`, um hochvolumige Diagnosen wie vollständige Statuszeilen-Befehlsausgabe einzubeziehen, oder erhöhen Sie auf `error`, um Rauschen zu reduzieren |72| `CLAUDE_CODE_DEBUG_LOG_LEVEL` | Minimale Protokollierungsstufe, die in die Debug-Protokolldatei geschrieben wird. Werte: `verbose`, `debug` (Standard), `info`, `warn`, `error`. Setzen Sie auf `verbose`, um hochvolumige Diagnosen wie vollständige Statuszeilen-Befehlsausgabe einzubeziehen, oder erhöhen Sie auf `error`, um Rauschen zu reduzieren |

70| `CLAUDE_CODE_DISABLE_1M_CONTEXT` | Setzen Sie auf `1`, um die Unterstützung des [1M-Kontextfensters](/de/model-config#extended-context) zu deaktivieren. Wenn gesetzt, sind 1M-Modellvarianten in der Modellauswahl nicht verfügbar. Nützlich für Unternehmensumgebungen mit Compliance-Anforderungen |73| `CLAUDE_CODE_DISABLE_1M_CONTEXT` | Setzen Sie auf `1`, um die Unterstützung des [1M-Kontextfensters](/de/model-config#extended-context) zu deaktivieren. Wenn gesetzt, sind 1M-Modellvarianten in der Modellauswahl nicht verfügbar. Nützlich für Unternehmensumgebungen mit Compliance-Anforderungen |

71| `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` | Setzen Sie auf `1`, um [adaptives Denken](/de/model-config#adjust-effort-level) auf Opus 4.6 und Sonnet 4.6 zu deaktivieren und auf das feste Denk-Budget zurückzufallen, das von `MAX_THINKING_TOKENS` gesteuert wird. {/* min-version: 2.1.111 */}Hat keine Auswirkung auf Opus 4.7, das immer adaptives Denken verwendet |74| `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` | Setzen Sie auf `1`, um [adaptives Denken](/de/model-config#adjust-effort-level) auf Opus 4.6 und Sonnet 4.6 zu deaktivieren und auf das feste Denk-Budget zurückzufallen, das von `MAX_THINKING_TOKENS` gesteuert wird. {/* min-version: 2.1.111 */}Hat keine Auswirkung auf Opus 4.7, das immer adaptives Denken verwendet |

75| `CLAUDE_CODE_DISABLE_AGENT_VIEW` | Setzen Sie auf `1`, um [Hintergrund-Agenten und Agent-Ansicht](/de/agent-view) auszuschalten: `claude agents`, `--bg`, `/background` und den On-Demand-Supervisor. Äquivalent zur Einstellung [`disableAgentView`](/de/settings#available-settings) |

72| `CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN` | Setzen Sie auf `1`, um die [Vollbilddarstellung](/de/fullscreen) zu deaktivieren und den klassischen Hauptbildschirm-Renderer zu verwenden. Die Konversation bleibt in Ihrem nativen Terminal-Scrollback, sodass `Cmd+f` und tmux-Kopiermodus wie gewohnt funktionieren. Hat Vorrang vor `CLAUDE_CODE_NO_FLICKER` und der [`tui`](/de/settings#available-settings)-Einstellung. Sie können auch mit `/tui default` wechseln |76| `CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN` | Setzen Sie auf `1`, um die [Vollbilddarstellung](/de/fullscreen) zu deaktivieren und den klassischen Hauptbildschirm-Renderer zu verwenden. Die Konversation bleibt in Ihrem nativen Terminal-Scrollback, sodass `Cmd+f` und tmux-Kopiermodus wie gewohnt funktionieren. Hat Vorrang vor `CLAUDE_CODE_NO_FLICKER` und der [`tui`](/de/settings#available-settings)-Einstellung. Sie können auch mit `/tui default` wechseln |

73| `CLAUDE_CODE_DISABLE_ATTACHMENTS` | Setzen Sie auf `1`, um die Verarbeitung von Anhängen zu deaktivieren. Dateierweiterungen mit `@`-Syntax werden als Klartext gesendet, anstatt in Dateiinhalte erweitert zu werden |77| `CLAUDE_CODE_DISABLE_ATTACHMENTS` | Setzen Sie auf `1`, um die Verarbeitung von Anhängen zu deaktivieren. Dateierweiterungen mit `@`-Syntax werden als Klartext gesendet, anstatt in Dateiinhalte erweitert zu werden |

74| `CLAUDE_CODE_DISABLE_AUTO_MEMORY` | Setzen Sie auf `1`, um [automatisches Speichern](/de/memory#auto-memory) zu deaktivieren. Setzen Sie auf `0`, um automatisches Speichern zu erzwingen, auch wenn `--bare`-Modus oder [`autoMemoryEnabled: false`](/de/settings#available-settings) es ansonsten deaktivieren würde. Wenn deaktiviert, erstellt oder lädt Claude keine automatischen Speicherdateien |78| `CLAUDE_CODE_DISABLE_AUTO_MEMORY` | Setzen Sie auf `1`, um [automatisches Speichern](/de/memory#auto-memory) zu deaktivieren. Setzen Sie auf `0`, um automatisches Speichern zu erzwingen, auch wenn `--bare`-Modus oder [`autoMemoryEnabled: false`](/de/settings#available-settings) es ansonsten deaktivieren würde. Wenn deaktiviert, erstellt oder lädt Claude keine automatischen Speicherdateien |

104| `CLAUDE_CODE_FORCE_SYNC_OUTPUT` | Setzen Sie auf `1`, um DEC Private Mode 2026 [synchronisierte Ausgabe](https://gist.github.com/christianparpart/d8a62cc1ab659194337d73e399004036) zu erzwingen, wenn Ihr Terminal sie unterstützt, aber nicht automatisch erkannt wird. Nützlich für Emulatoren wie Emacs `eat`, die BSU/ESU implementieren, aber nicht auf die Capability-Abfrage antworten. Hat keine Auswirkung unter tmux |108| `CLAUDE_CODE_FORCE_SYNC_OUTPUT` | Setzen Sie auf `1`, um DEC Private Mode 2026 [synchronisierte Ausgabe](https://gist.github.com/christianparpart/d8a62cc1ab659194337d73e399004036) zu erzwingen, wenn Ihr Terminal sie unterstützt, aber nicht automatisch erkannt wird. Nützlich für Emulatoren wie Emacs `eat`, die BSU/ESU implementieren, aber nicht auf die Capability-Abfrage antworten. Hat keine Auswirkung unter tmux |

105| `CLAUDE_CODE_FORK_SUBAGENT` | Setzen Sie auf `1`, um [abgespaltete Subagenten](/de/sub-agents#fork-the-current-conversation) zu aktivieren. Ein abgespalteter Subagent erbt den vollständigen Konversationskontext aus der Hauptsitzung, anstatt neu zu beginnen. Wenn aktiviert, spawnt `/fork` einen abgespalteten Subagent, anstatt als Alias für [`/branch`](/de/commands) zu fungieren, und alle Subagent-Spawns werden im Hintergrund ausgeführt. Funktioniert im interaktiven Modus und über das SDK oder `claude -p` |109| `CLAUDE_CODE_FORK_SUBAGENT` | Setzen Sie auf `1`, um [abgespaltete Subagenten](/de/sub-agents#fork-the-current-conversation) zu aktivieren. Ein abgespalteter Subagent erbt den vollständigen Konversationskontext aus der Hauptsitzung, anstatt neu zu beginnen. Wenn aktiviert, spawnt `/fork` einen abgespalteten Subagent, anstatt als Alias für [`/branch`](/de/commands) zu fungieren, und alle Subagent-Spawns werden im Hintergrund ausgeführt. Funktioniert im interaktiven Modus und über das SDK oder `claude -p` |

106| `CLAUDE_CODE_GIT_BASH_PATH` | Nur Windows: Pfad zur Git Bash-Ausführungsdatei (`bash.exe`). Verwenden Sie, wenn Git Bash installiert ist, aber nicht in Ihrem PATH. Siehe [Windows-Setup](/de/setup#set-up-on-windows) |110| `CLAUDE_CODE_GIT_BASH_PATH` | Nur Windows: Pfad zur Git Bash-Ausführungsdatei (`bash.exe`). Verwenden Sie, wenn Git Bash installiert ist, aber nicht in Ihrem PATH. Siehe [Windows-Setup](/de/setup#set-up-on-windows) |

107| `CLAUDE_CODE_GLOB_HIDDEN` | Setzen Sie auf `false`, um versteckte Dateien aus Ergebnissen auszuschließen, wenn Claude das [Glob-Tool](/de/tools-reference) aufruft. Standardmäßig enthalten. Beeinflusst nicht `@`-Datei-Autovervollständigung, `ls`, Grep oder Read |111| `CLAUDE_CODE_GLOB_HIDDEN` | Setzen Sie auf `false`, um versteckte Dateien aus Ergebnissen auszuschließen, wenn Claude das [Glob-Tool](/de/tools-reference#glob-tool-behavior) aufruft. Standardmäßig enthalten. Beeinflusst nicht `@`-Datei-Autovervollständigung, `ls`, Grep oder Read |

108| `CLAUDE_CODE_GLOB_NO_IGNORE` | Setzen Sie auf `false`, um das [Glob-Tool](/de/tools-reference) `.gitignore`-Muster respektieren zu lassen. Standardmäßig gibt Glob alle übereinstimmenden Dateien zurück, einschließlich gitignorierter. Beeinflusst nicht `@`-Datei-Autovervollständigung, die ihre eigene [`respectGitignore`-Einstellung](/de/settings#available-settings) hat |112| `CLAUDE_CODE_GLOB_NO_IGNORE` | Setzen Sie auf `false`, um das [Glob-Tool](/de/tools-reference#glob-tool-behavior) `.gitignore`-Muster respektieren zu lassen. Standardmäßig gibt Glob alle übereinstimmenden Dateien zurück, einschließlich gitignorierter. Beeinflusst nicht `@`-Datei-Autovervollständigung, die ihre eigene [`respectGitignore`-Einstellung](/de/settings#available-settings) hat |

109| `CLAUDE_CODE_GLOB_TIMEOUT_SECONDS` | Timeout in Sekunden für die Glob-Tool-Dateiermittlung. Standardmäßig 20 Sekunden auf den meisten Plattformen und 60 Sekunden auf WSL |113| `CLAUDE_CODE_GLOB_TIMEOUT_SECONDS` | Timeout in Sekunden für die Glob-Tool-Dateiermittlung. Standardmäßig 20 Sekunden auf den meisten Plattformen und 60 Sekunden auf WSL |

110| `CLAUDE_CODE_HIDE_CWD` | Setzen Sie auf `1`, um das Arbeitsverzeichnis im Startup-Logo auszublenden. Nützlich für Bildschirmfreigaben oder Aufzeichnungen, bei denen der Pfad Ihren OS-Benutzernamen offenlegt |114| `CLAUDE_CODE_HIDE_CWD` | Setzen Sie auf `1`, um das Arbeitsverzeichnis im Startup-Logo auszublenden. Nützlich für Bildschirmfreigaben oder Aufzeichnungen, bei denen der Pfad Ihren OS-Benutzernamen offenlegt |

111| `CLAUDE_CODE_IDE_HOST_OVERRIDE` | Überschreiben Sie die Host-Adresse, die zum Verbinden mit der IDE-Erweiterung verwendet wird. Standardmäßig erkennt Claude Code die richtige Adresse automatisch, einschließlich WSL-zu-Windows-Routing |115| `CLAUDE_CODE_IDE_HOST_OVERRIDE` | Überschreiben Sie die Host-Adresse, die zum Verbinden mit der IDE-Erweiterung verwendet wird. Standardmäßig erkennt Claude Code die richtige Adresse automatisch, einschließlich WSL-zu-Windows-Routing |

144| `CLAUDE_CODE_SHELL_PREFIX` | Befehlspräfix zum Umhüllen von Shell-Befehlen, die Claude Code spawnt: Bash-Tool-Aufrufe, [Hook](/de/hooks)-Befehle und stdio [MCP-Server](/de/mcp)-Startup-Befehle. Nützlich für Protokollierung oder Auditing. Beispiel: Das Setzen von `/path/to/logger.sh` führt jeden Befehl als `/path/to/logger.sh <command>` aus |148| `CLAUDE_CODE_SHELL_PREFIX` | Befehlspräfix zum Umhüllen von Shell-Befehlen, die Claude Code spawnt: Bash-Tool-Aufrufe, [Hook](/de/hooks)-Befehle und stdio [MCP-Server](/de/mcp)-Startup-Befehle. Nützlich für Protokollierung oder Auditing. Beispiel: Das Setzen von `/path/to/logger.sh` führt jeden Befehl als `/path/to/logger.sh <command>` aus |

145| `CLAUDE_CODE_SIMPLE` | Setzen Sie auf `1`, um mit einem minimalen System-Prompt und nur den Tools Bash, Datei lesen und Datei bearbeiten auszuführen. MCP-Tools aus `--mcp-config` sind weiterhin verfügbar. Deaktiviert die automatische Erkennung von Hooks, Skills, Plugins, MCP-Servern, automatisches Speichern und CLAUDE.md. Das CLI-Flag [`--bare`](/de/headless#start-faster-with-bare-mode) setzt dies |149| `CLAUDE_CODE_SIMPLE` | Setzen Sie auf `1`, um mit einem minimalen System-Prompt und nur den Tools Bash, Datei lesen und Datei bearbeiten auszuführen. MCP-Tools aus `--mcp-config` sind weiterhin verfügbar. Deaktiviert die automatische Erkennung von Hooks, Skills, Plugins, MCP-Servern, automatisches Speichern und CLAUDE.md. Das CLI-Flag [`--bare`](/de/headless#start-faster-with-bare-mode) setzt dies |

146| `CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT` | Setzen Sie auf `1`, um einen kürzeren System-Prompt und zusammengefasste Tool-Beschreibungen auf Opus 4.7 zu verwenden. Hat keine Auswirkung auf andere Modelle. Der vollständige Tool-Satz, Hooks, MCP-Server und CLAUDE.md-Erkennung bleiben aktiviert |150| `CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT` | Setzen Sie auf `1`, um einen kürzeren System-Prompt und zusammengefasste Tool-Beschreibungen auf Opus 4.7 zu verwenden. Hat keine Auswirkung auf andere Modelle. Der vollständige Tool-Satz, Hooks, MCP-Server und CLAUDE.md-Erkennung bleiben aktiviert |

151| `CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH` | Überspringen Sie die clientseitige Authentifizierung für [Claude Platform on AWS](/de/claude-platform-on-aws), für Gateways, die Anfragen selbst signieren |

147| `CLAUDE_CODE_SKIP_BEDROCK_AUTH` | Überspringen Sie die AWS-Authentifizierung für Bedrock (z. B. bei Verwendung eines LLM-Gateways) |152| `CLAUDE_CODE_SKIP_BEDROCK_AUTH` | Überspringen Sie die AWS-Authentifizierung für Bedrock (z. B. bei Verwendung eines LLM-Gateways) |

148| `CLAUDE_CODE_SKIP_FOUNDRY_AUTH` | Überspringen Sie die Azure-Authentifizierung für Microsoft Foundry (z. B. bei Verwendung eines LLM-Gateways) |153| `CLAUDE_CODE_SKIP_FOUNDRY_AUTH` | Überspringen Sie die Azure-Authentifizierung für Microsoft Foundry (z. B. bei Verwendung eines LLM-Gateways) |

149| `CLAUDE_CODE_SKIP_MANTLE_AUTH` | Überspringen Sie die AWS-Authentifizierung für Bedrock Mantle (z. B. bei Verwendung eines LLM-Gateways) |154| `CLAUDE_CODE_SKIP_MANTLE_AUTH` | Überspringen Sie die AWS-Authentifizierung für Bedrock Mantle (z. B. bei Verwendung eines LLM-Gateways) |

158| `CLAUDE_CODE_TEAM_NAME` | Name des Agent-Teams, zu dem dieser Teamkollege gehört. Automatisch auf [Agent-Team](/de/agent-teams)-Mitgliedern gesetzt |163| `CLAUDE_CODE_TEAM_NAME` | Name des Agent-Teams, zu dem dieser Teamkollege gehört. Automatisch auf [Agent-Team](/de/agent-teams)-Mitgliedern gesetzt |

159| `CLAUDE_CODE_TMPDIR` | Überschreiben Sie das Temp-Verzeichnis, das für interne Temp-Dateien verwendet wird. Claude Code hängt `/claude-{uid}/` (Unix) oder `/claude/` (Windows) an diesen Pfad an. Standard: `/tmp` auf macOS, `os.tmpdir()` auf Linux/Windows |164| `CLAUDE_CODE_TMPDIR` | Überschreiben Sie das Temp-Verzeichnis, das für interne Temp-Dateien verwendet wird. Claude Code hängt `/claude-{uid}/` (Unix) oder `/claude/` (Windows) an diesen Pfad an. Standard: `/tmp` auf macOS, `os.tmpdir()` auf Linux/Windows |

160| `CLAUDE_CODE_TMUX_TRUECOLOR` | Setzen Sie auf `1`, um 24-Bit-Truecolor-Ausgabe in tmux zu ermöglichen. Standardmäßig begrenzt Claude Code auf 256 Farben, wenn `$TMUX` gesetzt ist, da tmux Truecolor-Escape-Sequenzen nicht durchleitet, es sei denn, es ist konfiguriert. Setzen Sie dies nach dem Hinzufügen von `set -ga terminal-overrides ',*:Tc'` zu Ihrer `~/.tmux.conf`. Siehe [Terminal-Konfiguration](/de/terminal-config) für andere tmux-Einstellungen |165| `CLAUDE_CODE_TMUX_TRUECOLOR` | Setzen Sie auf `1`, um 24-Bit-Truecolor-Ausgabe in tmux zu ermöglichen. Standardmäßig begrenzt Claude Code auf 256 Farben, wenn `$TMUX` gesetzt ist, da tmux Truecolor-Escape-Sequenzen nicht durchleitet, es sei denn, es ist konfiguriert. Setzen Sie dies nach dem Hinzufügen von `set -ga terminal-overrides ',*:Tc'` zu Ihrer `~/.tmux.conf`. Siehe [Terminal-Konfiguration](/de/terminal-config) für andere tmux-Einstellungen |

166| `CLAUDE_CODE_USE_ANTHROPIC_AWS` | Verwenden Sie [Claude Platform on AWS](/de/claude-platform-on-aws) |

195| `DO_NOT_TRACK` | Setzen Sie auf `1`, um sich von Telemetrie abzumelden. Äquivalent zum Setzen von `DISABLE_TELEMETRY`. Wird als [Standard-Cross-Tool-Konvention](https://consoledonottrack.com/) anerkannt |201| `DO_NOT_TRACK` | Setzen Sie auf `1`, um sich von Telemetrie abzumelden. Äquivalent zum Setzen von `DISABLE_TELEMETRY`. Wird als [Standard-Cross-Tool-Konvention](https://consoledonottrack.com/) anerkannt |

196| `ENABLE_CLAUDEAI_MCP_SERVERS` | Setzen Sie auf `false`, um [claude.ai MCP-Server](/de/mcp#use-mcp-servers-from-claude-ai) in Claude Code zu deaktivieren. Standardmäßig für angemeldete Benutzer aktiviert |202| `ENABLE_CLAUDEAI_MCP_SERVERS` | Setzen Sie auf `false`, um [claude.ai MCP-Server](/de/mcp#use-mcp-servers-from-claude-ai) in Claude Code zu deaktivieren. Standardmäßig für angemeldete Benutzer aktiviert |

197| `ENABLE_PROMPT_CACHING_1H` | Setzen Sie auf `1`, um eine 1-Stunden-Prompt-Cache-TTL anstelle der Standard-5-Minuten anzufordern. Vorgesehen für API-Schlüssel-, [Bedrock](/de/amazon-bedrock)-, [Vertex](/de/google-vertex-ai)- und [Foundry](/de/microsoft-foundry)-Benutzer. Abonnement-Benutzer erhalten automatisch 1-Stunden-TTL. 1-Stunden-Cache-Schreibvorgänge werden mit einer höheren Rate abgerechnet |203| `ENABLE_PROMPT_CACHING_1H` | Setzen Sie auf `1`, um eine 1-Stunden-Prompt-Cache-TTL anstelle der Standard-5-Minuten anzufordern. Vorgesehen für API-Schlüssel-, [Bedrock](/de/amazon-bedrock)-, [Vertex](/de/google-vertex-ai)-, [Foundry](/de/microsoft-foundry)- und [Claude Platform on AWS](/de/claude-platform-on-aws)-Benutzer. Abonnement-Benutzer erhalten automatisch 1-Stunden-TTL. 1-Stunden-Cache-Schreibvorgänge werden mit einer höheren Rate abgerechnet |

199| `ENABLE_TOOL_SEARCH` | Steuert [MCP-Tool-Suche](/de/mcp#scale-with-mcp-tool-search). Nicht gesetzt: alle MCP-Tools standardmäßig aufgeschoben, aber upfront geladen auf Vertex AI oder wenn `ANTHROPIC_BASE_URL` auf einen Nicht-First-Party-Host verweist. Werte: `true` (immer aufgeschoben, einschließlich Proxies und Vertex AI), `auto` (Schwellenwertmodus: upfront laden, wenn Tools in 10 % des Kontexts passen), `auto:N` (benutzerdefinierter Schwellenwert, z. B. `auto:5` für 5 %), `false` (alle upfront laden) |205| `ENABLE_TOOL_SEARCH` | Steuert [MCP-Tool-Suche](/de/mcp#scale-with-mcp-tool-search). Nicht gesetzt: alle MCP-Tools standardmäßig aufgeschoben, aber upfront geladen auf Vertex AI oder wenn `ANTHROPIC_BASE_URL` auf einen Nicht-First-Party-Host verweist. Werte: `true` (immer aufgeschoben, einschließlich Proxies und Vertex AI), `auto` (Schwellenwertmodus: upfront laden, wenn Tools in 10 % des Kontexts passen), `auto:N` (benutzerdefinierter Schwellenwert, z. B. `auto:5` für 5 %), `false` (alle upfront laden) |

200| `FALLBACK_FOR_ALL_PRIMARY_MODELS` | Setzen Sie auf einen beliebigen Nicht-Leer-Wert, um das Fallback zu [`--fallback-model`](/de/cli-reference#cli-flags) nach wiederholten Überladungsfehlern auf einem beliebigen primären Modell auszulösen. Standardmäßig lösen nur Opus-Modelle das Fallback aus |206| `FALLBACK_FOR_ALL_PRIMARY_MODELS` | Setzen Sie auf einen beliebigen Nicht-Leer-Wert, um das Fallback zu [`--fallback-model`](/de/cli-reference#cli-flags) nach wiederholten Überladungsfehlern auf einem beliebigen primären Modell auszulösen. Standardmäßig lösen nur Opus-Modelle das Fallback aus |

glossary.md +8 −2

Details

126 126

127Sichtbares schrittweises Reasoning, das das Modell vor der Antwort durchführt. Sie können Thinking-Tokens mit `MAX_THINKING_TOKENS` begrenzen oder das [Effort Level](#effort-level) anpassen. Thinking erscheint in grauem kursivem Text im Terminal.127Sichtbares schrittweises Reasoning, das das Modell vor der Antwort durchführt. Sie können Thinking-Tokens mit `MAX_THINKING_TOKENS` begrenzen oder das [Effort Level](#effort-level) anpassen. Thinking erscheint in grauem kursivem Text im Terminal.

128 128

129Weitere Informationen: [Verwenden Sie Extended Thinking](/de/common-workflows#use-extended-thinking-thinking-mode)129Weitere Informationen: [Verwenden Sie Extended Thinking](/de/model-config#extended-thinking)

130 130

131## H131## H

132 132

286 286

287Weitere Informationen: [Tools, die Claude zur Verfügung stehen](/de/tools-reference)287Weitere Informationen: [Tools, die Claude zur Verfügung stehen](/de/tools-reference)

288 288

289### Turn

290

291Eine vollständige Antwort von Claude innerhalb einer [Sitzung](#session). Ein Turn beginnt, wenn Sie eine Nachricht senden, und endet, wenn Claude die Antwort beendet, mit einer beliebigen Anzahl von [Tool](#tool)-Aufrufen dazwischen. [Stop Hooks](#hook) werden am Ende jedes Turns ausgelöst. Eine Sitzung besteht aus vielen Turns, und die [Agentic Loop](#agentic-loop) beschreibt, was innerhalb eines Turns passiert.

292

293Weitere Informationen: [Wie Claude Code funktioniert](/de/how-claude-code-works#the-agentic-loop)

294

289## W295## W

290 296

291### Worktree Isolation297### Worktree Isolation

292 298

293Ein Isolationsmodus, der Claude in einem separaten Git-Worktree unter `.claude/worktrees/` ausführt, aktiviert mit dem `-w`-Flag oder `isolation: worktree` in der Subagent-Konfiguration. Änderungen bleiben auf einem separaten Branch in einem separaten Verzeichnis, sodass parallele Agenten die Dateien des anderen nicht überschreiben.299Ein Isolationsmodus, der Claude in einem separaten Git-Worktree unter `.claude/worktrees/` ausführt, aktiviert mit dem `-w`-Flag oder `isolation: worktree` in der Subagent-Konfiguration. Änderungen bleiben auf einem separaten Branch in einem separaten Verzeichnis, sodass parallele Agenten die Dateien des anderen nicht überschreiben.

294 300

295Weitere Informationen: [Führen Sie parallele Sitzungen mit Git Worktrees aus](/de/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees)301Weitere Informationen: [Führen Sie parallele Sitzungen mit Git Worktrees aus](/de/worktrees)

296 302

297***303***

298 304

goal.md +138 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Claude auf ein Ziel hinarbeiten lassen

7> Legen Sie mit /goal eine Abschlussbedingung fest und Claude arbeitet über mehrere Turns hinweg daran, bis die Bedingung erfüllt ist.

9Der Befehl `/goal` legt eine Abschlussbedingung fest und Claude arbeitet darauf hin, ohne dass Sie jeden Schritt eingeben müssen. Nach jedem Turn überprüft ein kleines schnelles Modell, ob die Bedingung erfüllt ist. Falls nicht, startet Claude einen weiteren Turn, anstatt die Kontrolle an Sie zurückzugeben. Das Ziel wird automatisch gelöscht, sobald die Bedingung erfüllt ist.

11Verwenden Sie ein Ziel für umfangreiche Arbeiten mit einem überprüfbaren Endzustand:

13* Migration eines Moduls zu einer neuen API, bis jede Aufrufstelle kompiliert und Tests bestanden sind

14* Implementierung eines Design-Dokuments, bis alle Akzeptanzkriterien erfüllt sind

15* Aufteilung einer großen Datei in fokussierte Module, bis jedes unter einem Größenlimit liegt

16* Durcharbeitung einer gekennzeichneten Issue-Warteschlange, bis die Warteschlange leer ist

18Diese Seite behandelt folgende Themen:

20* [Vergleich autonomer Workflow-Ansätze](#compare-to-other-autonomous-workflows): `/loop`, Stop Hooks und Auto-Modus

21* [Ziel festlegen](#set-a-goal) und [effektive Bedingung schreiben](#write-an-effective-condition)

22* [Status überprüfen](#check-status), [frühzeitig löschen](#clear-a-goal) und [nicht-interaktiv ausführen](#run-non-interactively)

23* Siehe [wie Evaluierung funktioniert](#how-evaluation-works) und [Anforderungen](#requirements)

25## Vergleich zu anderen autonomen Workflows

27Drei Ansätze halten die aktuelle Sitzung zwischen Eingaben aktiv. Wählen Sie basierend darauf, was den nächsten Turn starten sollte:

29| Ansatz | Nächster Turn startet wenn | Stoppt wenn |

30| :------------------------------------------------------------------ | :----------------------------- | :-------------------------------------------------------------------- |

31| `/goal` | Der vorherige Turn beendet ist | Ein Modell bestätigt, dass die Bedingung erfüllt ist |

32| [`/loop`](/de/scheduled-tasks#run-a-prompt-repeatedly-with-%2Floop) | Ein Zeitintervall verstreicht | Sie stoppen es, oder Claude entscheidet, dass die Arbeit erledigt ist |

33| [Stop Hook](/de/hooks-guide#prompt-based-hooks) | Der vorherige Turn beendet ist | Ihr eigenes Skript oder Ihre Eingabe entscheidet |

35`/goal` und ein Stop Hook werden beide nach jedem Turn ausgelöst. `/goal` ist eine Sitzungs-Verknüpfung: Sie geben eine Bedingung ein und sie ist nur für die aktuelle Sitzung aktiv. Ein Stop Hook befindet sich in Ihrer Einstellungsdatei, gilt für jede Sitzung in seinem Bereich und kann ein Skript für deterministische Überprüfungen oder eine Eingabe für modellbewertete Überprüfungen ausführen.

37[Auto-Modus](/de/auto-mode-config) genehmigt von selbst Tool-Aufrufe innerhalb eines einzelnen Turns, startet aber keinen neuen. Claude stoppt, wenn es die Arbeit als erledigt einstuft. `/goal` fügt einen separaten Evaluator hinzu, der Ihre Bedingung nach jedem Turn überprüft, sodass die Fertigstellung von einem frischen Modell entschieden wird, anstatt von dem, das die Arbeit ausführt. Die beiden sind komplementär: Auto-Modus entfernt Pro-Tool-Eingaben und `/goal` entfernt Pro-Turn-Eingaben.

39<Tip>

40 Die obigen Ansätze halten die aktuelle Sitzung aktiv. Sie können auch Arbeiten planen, die unabhängig von einer offenen Sitzung ausgeführt werden, z. B. nächtliche Tests oder morgendliche Triage. Siehe [Planungsoptionen](/de/scheduled-tasks#compare-scheduling-options) für Cloud-Routinen und Desktop-geplante Aufgaben.

41</Tip>

43## `/goal` verwenden

45Pro Sitzung kann ein Ziel aktiv sein. Der gleiche Befehl legt es fest, überprüft es und löscht es je nach Argument.

47### Ziel festlegen

49Führen Sie `/goal` gefolgt von der Bedingung aus, die Sie erfüllt haben möchten. Wenn bereits ein Ziel aktiv ist, ersetzt das neue es.

51```text theme={null}

52/goal all tests in test/auth pass and the lint step is clean

53```

55Das Festlegen eines Ziels startet sofort einen Turn mit der Bedingung selbst als Direktive. Sie müssen keine separate Eingabe senden. Während das Ziel aktiv ist, zeigt ein `◎ /goal active` Indikator, wie lange das Ziel bereits läuft.

57Nach jedem Turn gibt der Evaluator einen kurzen Grund zurück, der erklärt, warum die Bedingung erfüllt ist oder nicht. Der neueste Grund wird in der Statusansicht und im Transkript angezeigt, damit Sie sehen können, worauf Claude als nächstes hinarbeitet.

59<Note>

60 Ein Ziel läuft weiter, bis die Bedingung erfüllt ist oder Sie `/goal clear` ausführen. Führen Sie `/goal` ohne Argument aus, um die bisherigen Turns und Token zu sehen.

61</Note>

63### Effektive Bedingung schreiben

65Der [Evaluator](#how-evaluation-works) beurteilt Ihre Bedingung anhand dessen, was Claude im Gespräch dargelegt hat. Er führt Befehle nicht aus oder liest Dateien unabhängig, daher schreiben Sie die Bedingung als etwas, das Claudes eigene Ausgabe demonstrieren kann. „Alle Tests in `test/auth` bestanden" funktioniert, weil Claude die Tests ausführt und das Ergebnis im Transkript für den Evaluator zum Lesen landet.

67Eine Bedingung, die über viele Turns hinweg hält, hat normalerweise:

69* **Einen messbaren Endzustand**: ein Testergebnis, ein Build-Exit-Code, eine Dateianzahl, eine leere Warteschlange

70* **Eine angegebene Überprüfung**: wie Claude es beweisen sollte, z. B. „`npm test` beendet mit 0" oder „`git status` ist sauber"

71* **Einschränkungen, die wichtig sind**: alles, das sich auf dem Weg dorthin nicht ändern darf, z. B. „keine andere Testdatei wird geändert"

73Die Bedingung kann bis zu 4.000 Zeichen lang sein.

75Um zu begrenzen, wie lange ein Ziel läuft, fügen Sie eine Turn- oder Zeitklausel in die Bedingung ein, z. B. `or stop after 20 turns`. Claude meldet den Fortschritt gegen diese Klausel jeden Turn und der Evaluator beurteilt sie aus dem Gespräch.

77### Status überprüfen

79Führen Sie `/goal` ohne Argumente aus, um den aktuellen Zustand zu sehen.

81```text theme={null}

82/goal

83```

85Wenn ein Ziel aktiv ist, zeigt der Status:

87* Die Bedingung

88* Wie lange es läuft

89* Wie viele Turns evaluiert wurden

90* Die aktuelle Token-Ausgabe

91* Den neuesten Grund des Evaluators

93Wenn kein Ziel aktiv ist, aber eines früher in der Sitzung erreicht wurde, zeigt der Status die erreichte Bedingung zusammen mit ihrer Dauer, Turnanzahl und Token-Ausgabe.

95### Ziel löschen

97Führen Sie `/goal clear` aus, um ein aktives Ziel zu entfernen, bevor seine Bedingung erfüllt ist.

99```text theme={null}

100/goal clear

101```

102

103`stop`, `off`, `reset`, `none` und `cancel` werden als Aliase für `clear` akzeptiert. Das Ausführen von `/clear` zum Starten eines neuen Gesprächs entfernt auch alle aktiven Ziele.

104

105### Mit aktivem Ziel fortfahren

106

107Ein Ziel, das noch aktiv war, als eine Sitzung endete, wird wiederhergestellt, wenn Sie diese Sitzung mit `--resume` oder `--continue` fortsetzen. Die Bedingung wird übernommen, aber die Turnanzahl, der Timer und die Token-Ausgabe-Baseline werden alle beim Fortsetzen zurückgesetzt. Ein Ziel, das bereits erreicht oder gelöscht wurde, wird nicht wiederhergestellt.

108

109### Nicht-interaktiv ausführen

110

111`/goal` funktioniert im [nicht-interaktiven Modus](/de/headless) und über [Remote Control](/de/remote-control). Das Festlegen eines Ziels mit `-p` führt die Schleife in einem einzigen Aufruf bis zur Fertigstellung aus:

112

113```bash theme={null}

114claude -p "/goal CHANGELOG.md has an entry for every PR merged this week"

115```

116

117Unterbrechen Sie den Prozess mit Ctrl+C, um ein nicht-interaktives Ziel zu stoppen, bevor die Bedingung erfüllt ist.

118

119## Wie Evaluierung funktioniert

120

121`/goal` ist ein Wrapper um einen Sitzungs-Bereich [prompt-basierten Stop Hook](/de/hooks#prompt-based-hooks). Jedes Mal, wenn Claude einen Turn beendet, werden die Bedingung und das bisherige Gespräch an Ihr konfiguriertes [kleines schnelles Modell](/de/model-config) gesendet, das standardmäßig Haiku ist. Das Modell gibt eine Ja-oder-Nein-Entscheidung und einen kurzen Grund zurück. Ein „Nein" teilt Claude mit, dass es weiterarbeiten soll und enthält den Grund als Anleitung für den nächsten Turn. Ein „Ja" löscht das Ziel und zeichnet einen erreichten Eintrag im Transkript auf.

122

123Der Evaluator läuft auf dem Provider, für den Ihre Sitzung konfiguriert ist. Er ruft keine Tools auf, daher kann er nur beurteilen, was Claude bereits im Gespräch dargelegt hat.

124

125<Note>

126 Evaluierungs-Token werden auf dem kleinen schnellen Modell abgerechnet, das für Ihren Provider konfiguriert ist, und sind normalerweise vernachlässigbar im Vergleich zur Hauptausgabe.

127</Note>

128

129## Anforderungen

130

131`/goal` läuft nur in Arbeitsbereichen, in denen Sie den Vertrauensdialog akzeptiert haben, da der Evaluator Teil des Hooks-Systems ist. Wenn [`disableAllHooks`](/de/hooks#disable-or-remove-hooks) in verwalteten Richtlinieneinstellungen festgelegt ist, ist `/goal` nicht verfügbar. In beiden Fällen teilt Ihnen der Befehl mit, warum, anstatt stillschweigend nichts zu tun.

132

133## Siehe auch

134

135* [Eingabe wiederholt mit `/loop` ausführen](/de/scheduled-tasks#run-a-prompt-repeatedly-with-%2Floop): auf einem Zeitintervall erneut ausführen, anstatt bis eine Bedingung erfüllt ist

136* [Prompt-basierte Hooks](/de/hooks-guide#prompt-based-hooks): schreiben Sie Ihren eigenen Stop Hook, wenn Sie benutzerdefinierte Evaluierungslogik benötigen

137* [Auto-Modus](/de/auto-mode-config): genehmigen Sie Tool-Aufrufe automatisch, damit jeder Ziel-Turn unbeaufsichtigt läuft

138* [Planungsvergleich](/de/scheduled-tasks#compare-scheduling-options): führen Sie Arbeiten unabhängig von einer offenen Sitzung nach einem Zeitplan aus

hooks.md +4 −0

Details

1768 1768

1769Wird ausgeführt, wenn der Haupt-Claude Code-Agent fertig mit der Antwort ist. Wird nicht ausgeführt, wenn der Stopp durch eine Benutzerunterbrechung verursacht wurde. API-Fehler lösen stattdessen [StopFailure](#stopfailure) aus.1769Wird ausgeführt, wenn der Haupt-Claude Code-Agent fertig mit der Antwort ist. Wird nicht ausgeführt, wenn der Stopp durch eine Benutzerunterbrechung verursacht wurde. API-Fehler lösen stattdessen [StopFailure](#stopfailure) aus.

1770 1770

1771<Tip>

1772 Der Befehl [`/goal`](/de/goal) ist eine eingebaute Verknüpfung für einen sitzungsspezifischen Prompt-basierten Stop-Hook. Verwenden Sie ihn, wenn Sie möchten, dass Claude weiterarbeitet, bis eine Bedingung erfüllt ist, ohne Hook-Konfiguration zu schreiben.

1773</Tip>

1774

1771#### Stop-Eingabe1775#### Stop-Eingabe

1772 1776

1773Zusätzlich zu den [gemeinsamen Eingabefeldern](#common-input-fields) erhalten Stop-Hooks `stop_hook_active` und `last_assistant_message`. Das Feld `stop_hook_active` ist `true`, wenn Claude Code bereits als Ergebnis eines Stop-Hooks fortgesetzt wird. Überprüfen Sie diesen Wert oder verarbeiten Sie das Transkript, um zu verhindern, dass Claude Code unbegrenzt läuft. Das Feld `last_assistant_message` enthält den Textinhalt von Claudes letzter Antwort, daher können Hooks darauf zugreifen, ohne die Transkript-Datei zu analysieren.1777Zusätzlich zu den [gemeinsamen Eingabefeldern](#common-input-fields) erhalten Stop-Hooks `stop_hook_active` und `last_assistant_message`. Das Feld `stop_hook_active` ist `true`, wenn Claude Code bereits als Ergebnis eines Stop-Hooks fortgesetzt wird. Überprüfen Sie diesen Wert oder verarbeiten Sie das Transkript, um zu verhindern, dass Claude Code unbegrenzt läuft. Das Feld `last_assistant_message` enthält den Textinhalt von Claudes letzter Antwort, daher können Hooks darauf zugreifen, ohne die Transkript-Datei zu analysieren.

interactive-mode.md +2 −2

Details

23### Allgemeine Steuerelemente23### Allgemeine Steuerelemente

24 24

26| :---------------------------------------------------- | :------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |26| :---------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

28| `Ctrl+X Ctrl+K` | Alle Hintergrund-Agenten beenden. Zweimal innerhalb von 3 Sekunden drücken, um zu bestätigen | Steuerung von Hintergrund-Agenten |28| `Ctrl+X Ctrl+K` | Alle laufenden [Hintergrund-Subagenten](/de/sub-agents#run-subagents-in-foreground-or-background) in dieser Sitzung beenden. Zweimal innerhalb von 3 Sekunden drücken, um zu bestätigen | Subagenten-Steuerung |

30| `Ctrl+G` oder `Ctrl+X Ctrl+E` | Im Standard-Texteditor öffnen | Bearbeiten Sie Ihren Prompt oder benutzerdefinierte Antwort in Ihrem Standard-Texteditor. `Ctrl+X Ctrl+E` ist die readline-native Bindung. Aktivieren Sie „Show last response in external editor" in `/config`, um Claudes vorherige Antwort als `#`-kommentierter Kontext über Ihrem Prompt einzufügen; der Kommentarblock wird beim Speichern entfernt |30| `Ctrl+G` oder `Ctrl+X Ctrl+E` | Im Standard-Texteditor öffnen | Bearbeiten Sie Ihren Prompt oder benutzerdefinierte Antwort in Ihrem Standard-Texteditor. `Ctrl+X Ctrl+E` ist die readline-native Bindung. Aktivieren Sie „Show last response in external editor" in `/config`, um Claudes vorherige Antwort als `#`-kommentierter Kontext über Ihrem Prompt einzufügen; der Kommentarblock wird beim Speichern entfernt |

31| `Ctrl+L` | Bildschirm neu zeichnen | Erzwingt eine vollständige Terminal-Neuzeichnung. Eingabe und Gesprächsverlauf werden beibehalten. Verwenden Sie dies, um die Anzeige wiederherzustellen, wenn sie verzerrt oder teilweise leer wird |31| `Ctrl+L` | Bildschirm neu zeichnen | Erzwingt eine vollständige Terminal-Neuzeichnung. Eingabe und Gesprächsverlauf werden beibehalten. Verwenden Sie dies, um die Anzeige wiederherzustellen, wenn sie verzerrt oder teilweise leer wird |

keybindings.md +1 −1

Details

105| `chat:clearInput` | Ctrl+L | Vollständiges Bildschirm-Neuzeichnen erzwingen, Eingabe beibehalten. Im [Vollbildrendering](/de/fullscreen#clear-the-conversation) zweimal innerhalb von zwei Sekunden drücken, um `/clear` auszuführen |105| `chat:clearInput` | Ctrl+L | Vollständiges Bildschirm-Neuzeichnen erzwingen, Eingabe beibehalten. Im [Vollbildrendering](/de/fullscreen#clear-the-conversation) zweimal innerhalb von zwei Sekunden drücken, um `/clear` auszuführen |

llm-gateway.md +11 −0

Details

186export CLOUD_ML_REGION=us-east5186export CLOUD_ML_REGION=us-east5

187```187```

188 188

189##### Claude Platform auf AWS über ein Gateway

190

191Weiterleitung an ein Gateway, das zum [Claude Platform auf AWS](/de/claude-platform-on-aws) Endpoint weiterleitet:

192

193```bash theme={null}

194export ANTHROPIC_AWS_BASE_URL=https://litellm-server:4000/anthropic-aws

195export ANTHROPIC_AWS_WORKSPACE_ID=wrkspc_01ABCDEFGHIJKLMN

196export CLAUDE_CODE_SKIP_ANTHROPIC_AWS_AUTH=1

197export CLAUDE_CODE_USE_ANTHROPIC_AWS=1

198```

199

189Weitere detaillierte Informationen finden Sie in der [LiteLLM-Dokumentation](https://docs.litellm.ai/).200Weitere detaillierte Informationen finden Sie in der [LiteLLM-Dokumentation](https://docs.litellm.ai/).

190 201

191## Zusätzliche Ressourcen202## Zusätzliche Ressourcen

model-config.md +2 −2

Details

36| **`opus[1m]`** | Verwendet Opus mit einem [1-Million-Token-Kontextfenster](https://platform.claude.com/docs/de/build-with-claude/context-windows#1m-token-context-window) für lange Sitzungen |36| **`opus[1m]`** | Verwendet Opus mit einem [1-Million-Token-Kontextfenster](https://platform.claude.com/docs/de/build-with-claude/context-windows#1m-token-context-window) für lange Sitzungen |

37| **`opusplan`** | Spezieller Modus, der `opus` während des Plan-Modus verwendet und dann zu `sonnet` für die Ausführung wechselt |37| **`opusplan`** | Spezieller Modus, der `opus` während des Plan-Modus verwendet und dann zu `sonnet` für die Ausführung wechselt |

38 38

39Bei der Anthropic API wird `opus` zu Opus 4.7 und `sonnet` zu Sonnet 4.6 aufgelöst. Bei Bedrock, Vertex und Foundry wird `opus` zu Opus 4.6 und `sonnet` zu Sonnet 4.5 aufgelöst; neuere Modelle sind bei diesen Anbietern verfügbar, indem Sie den vollständigen Modellnamen explizit auswählen oder `ANTHROPIC_DEFAULT_OPUS_MODEL` oder `ANTHROPIC_DEFAULT_SONNET_MODEL` setzen.39Bei der Anthropic API und [Claude Platform on AWS](/de/claude-platform-on-aws) wird `opus` zu Opus 4.7 und `sonnet` zu Sonnet 4.6 aufgelöst. Bei Bedrock, Vertex und Foundry wird `opus` zu Opus 4.6 und `sonnet` zu Sonnet 4.5 aufgelöst; neuere Modelle sind bei diesen Anbietern verfügbar, indem Sie den vollständigen Modellnamen explizit auswählen oder `ANTHROPIC_DEFAULT_OPUS_MODEL` oder `ANTHROPIC_DEFAULT_SONNET_MODEL` setzen.

40 40

41Aliase verweisen auf die empfohlene Version für Ihren Anbieter und werden im Laufe der Zeit aktualisiert. Um eine bestimmte Version zu fixieren, verwenden Sie den vollständigen Modellnamen (z. B. `claude-opus-4-7`) oder setzen Sie die entsprechende Umgebungsvariable wie `ANTHROPIC_DEFAULT_OPUS_MODEL`.41Aliase verweisen auf die empfohlene Version für Ihren Anbieter und werden im Laufe der Zeit aktualisiert. Um eine bestimmte Version zu fixieren, verwenden Sie den vollständigen Modellnamen (z. B. `claude-opus-4-7`) oder setzen Sie die entsprechende Umgebungsvariable wie `ANTHROPIC_DEFAULT_OPUS_MODEL`.

42 42

294 294

295### Modelle für Drittanbieter-Bereitstellungen fixieren295### Modelle für Drittanbieter-Bereitstellungen fixieren

296 296

297Beim Bereitstellen von Claude Code über [Bedrock](/de/amazon-bedrock), [Vertex AI](/de/google-vertex-ai) oder [Foundry](/de/microsoft-foundry) sollten Sie Modellversionen vor dem Rollout für Benutzer fixieren.297Beim Bereitstellen von Claude Code über [Bedrock](/de/amazon-bedrock), [Vertex AI](/de/google-vertex-ai), [Foundry](/de/microsoft-foundry) oder [Claude Platform on AWS](/de/claude-platform-on-aws) sollten Sie Modellversionen vor dem Rollout für Benutzer fixieren.

298 298

299Ohne Fixierung verwendet Claude Code Modellaliase (`sonnet`, `opus`, `haiku`), die zur neuesten Version aufgelöst werden. Wenn Anthropic ein neues Modell veröffentlicht, das noch nicht in einem Benutzerkonto aktiviert ist, sehen Bedrock- und Vertex AI-Benutzer einen Hinweis und greifen für diese Sitzung auf die vorherige Version zurück, während Foundry-Benutzer Fehler sehen, da Foundry keine entsprechende Startprüfung hat.299Ohne Fixierung verwendet Claude Code Modellaliase (`sonnet`, `opus`, `haiku`), die zur neuesten Version aufgelöst werden. Wenn Anthropic ein neues Modell veröffentlicht, das noch nicht in einem Benutzerkonto aktiviert ist, sehen Bedrock- und Vertex AI-Benutzer einen Hinweis und greifen für diese Sitzung auf die vorherige Version zurück, während Foundry-Benutzer Fehler sehen, da Foundry keine entsprechende Startprüfung hat.

300 300

permissions.md +1 −1

Details

185`Edit`-Regeln gelten für alle integrierten Werkzeuge, die Dateien bearbeiten. Claude versucht nach besten Kräften, `Read`-Regeln auf alle integrierten Werkzeuge anzuwenden, die Dateien lesen, wie Grep und Glob.185`Edit`-Regeln gelten für alle integrierten Werkzeuge, die Dateien bearbeiten. Claude versucht nach besten Kräften, `Read`-Regeln auf alle integrierten Werkzeuge anzuwenden, die Dateien lesen, wie Grep und Glob.

186 186

187<Warning>187<Warning>

188 Read- und Edit-Deny-Regeln gelten für Claude's integrierte Dateiwerkzeuge, nicht für Bash-Unterprozesse. Eine `Read(./.env)`-Deny-Regel blockiert das Read-Werkzeug, verhindert aber nicht `cat .env` in Bash. Für OS-Ebenen-Durchsetzung, die alle Prozesse daran hindert, auf einen Pfad zuzugreifen, [aktivieren Sie die Sandbox](/de/sandboxing).188 Read- und Edit-Deny-Regeln gelten für Claude's integrierte Dateiwerkzeuge und für Dateibefehle, die Claude Code in Bash erkennt, wie `cat`, `head`, `tail` und `sed`. Sie gelten nicht für beliebige Unterprozesse, die Dateien indirekt lesen oder schreiben, wie ein Python- oder Node-Skript, das Dateien selbst öffnet. Für OS-Ebenen-Durchsetzung, die alle Prozesse daran hindert, auf einen Pfad zuzugreifen, [aktivieren Sie die Sandbox](/de/sandboxing).

189</Warning>189</Warning>

190 190

191Read- und Edit-Regeln folgen beide der [gitignore](https://git-scm.com/docs/gitignore)-Spezifikation mit vier unterschiedlichen Mustertypen:191Read- und Edit-Regeln folgen beide der [gitignore](https://git-scm.com/docs/gitignore)-Spezifikation mit vier unterschiedlichen Mustertypen:

scheduled-tasks.md +5 −3

Details

10 Geplante Aufgaben erfordern Claude Code v2.1.72 oder später. Überprüfen Sie Ihre Version mit `claude --version`.10 Geplante Aufgaben erfordern Claude Code v2.1.72 oder später. Überprüfen Sie Ihre Version mit `claude --version`.

11</Note>11</Note>

12 12

13Geplante Aufgaben ermöglichen es Claude, einen Prompt automatisch in regelmäßigen Abständen erneut auszuführen. Verwenden Sie sie, um eine Bereitstellung abzurufen, einen PR zu überwachen, einen langwierigen Build zu überprüfen oder sich später in der Sitzung an etwas zu erinnern. Um auf Ereignisse zu reagieren, während sie geschehen, anstatt abzurufen, siehe [Kanäle](/de/channels): Ihr CI kann den Fehler direkt in die Sitzung übertragen.13Geplante Aufgaben ermöglichen es Claude, einen Prompt automatisch in regelmäßigen Abständen erneut auszuführen. Verwenden Sie sie, um eine Bereitstellung abzurufen, einen PR zu überwachen, einen langwierigen Build zu überprüfen oder sich später in der Sitzung an etwas zu erinnern. Um auf Ereignisse zu reagieren, während sie geschehen, anstatt abzurufen, siehe [Kanäle](/de/channels): Ihr CI kann den Fehler direkt in die Sitzung übertragen. Um die Sitzung Zug um Zug weiterarbeiten zu lassen, bis eine Bedingung erfüllt ist, anstatt in einem Intervall, siehe [`/goal`](/de/goal).

14 14

15Aufgaben sind sitzungsbezogen: Sie existieren im aktuellen Gespräch und werden beendet, wenn Sie ein neues starten. Das Fortsetzen mit `--resume` oder `--continue` bringt alle Aufgaben zurück, die nicht [abgelaufen sind](#seven-day-expiry): eine wiederkehrende Aufgabe, die in den letzten 7 Tagen erstellt wurde, oder eine einmalige Aufgabe, deren geplante Zeit noch nicht vergangen ist. Für Planung, die unabhängig von einer Sitzung bestehen bleibt, verwenden Sie [Routinen](/de/routines), [Desktop-geplante Aufgaben](/de/desktop-scheduled-tasks) oder [GitHub Actions](/de/github-actions).15Aufgaben sind sitzungsbezogen: Sie existieren im aktuellen Gespräch und werden beendet, wenn Sie ein neues starten. Das Fortsetzen mit `--resume` oder `--continue` bringt alle Aufgaben zurück, die nicht [abgelaufen sind](#seven-day-expiry): eine wiederkehrende Aufgabe, die in den letzten 7 Tagen erstellt wurde, oder eine einmalige Aufgabe, deren geplante Zeit noch nicht vergangen ist. Für Planung, die unabhängig von einer Sitzung bestehen bleibt, verwenden Sie [Routinen](/de/routines), [Desktop-geplante Aufgaben](/de/desktop-scheduled-tasks) oder [GitHub Actions](/de/github-actions).

16 16

122 122

123Um eine `/loop` zu stoppen, während sie auf die nächste Iteration wartet, drücken Sie `Esc`. Dies löscht den ausstehenden Wakeup, sodass die Schleife nicht erneut läuft. Aufgaben, die Sie durch [direktes Fragen an Claude](#manage-scheduled-tasks) geplant haben, sind nicht von `Esc` betroffen und bleiben bestehen, bis Sie sie löschen.123Um eine `/loop` zu stoppen, während sie auf die nächste Iteration wartet, drücken Sie `Esc`. Dies löscht den ausstehenden Wakeup, sodass die Schleife nicht erneut läuft. Aufgaben, die Sie durch [direktes Fragen an Claude](#manage-scheduled-tasks) geplant haben, sind nicht von `Esc` betroffen und bleiben bestehen, bis Sie sie löschen.

124 124

125In [selbstgesteuertem Modus](#let-claude-choose-the-interval) kann Claude die Schleife auch selbst beenden, indem es die nächste Wakeup nicht plant, sobald die Aufgabe nachweislich abgeschlossen ist. Schleifen nach einem festen Intervall laufen weiter, bis Sie sie stoppen oder [sieben Tage vergehen](#seven-day-expiry).

126

125## Setzen Sie eine einmalige Erinnerung127## Setzen Sie eine einmalige Erinnerung

126 128

127Für einmalige Erinnerungen beschreiben Sie, was Sie möchten, in natürlicher Sprache, anstatt `/loop` zu verwenden. Claude plant eine einmalige Aufgabe, die sich nach der Ausführung selbst löscht.129Für einmalige Erinnerungen beschreiben Sie, was Sie möchten, in natürlicher Sprache, anstatt `/loop` zu verwenden. Claude plant eine einmalige Aufgabe, die sich nach der Ausführung selbst löscht.

166 168

167### Jitter169### Jitter

168 170

169Um zu vermeiden, dass jede Sitzung die API zum gleichen Wanduhrzeitpunkt trifft, fügt der Scheduler einen kleinen deterministischen Offset zu Ausführungszeiten hinzu:171Um zu vermeiden, dass jede Sitzung die API zum gleichen Wanduhrzeitpunkt trifft, fügt der Scheduler einen deterministischen Offset zu Ausführungszeiten hinzu:

170 172

171* Wiederkehrende Aufgaben laufen bis zu 10% ihrer Periode zu spät, begrenzt auf 15 Minuten. Ein stündlicher Job könnte überall von `:00` bis `:06` laufen.173* Wiederkehrende Aufgaben laufen bis zu 30 Minuten nach der geplanten Zeit (oder bis zu der Hälfte des Intervalls für Aufgaben, die häufiger als stündlich ausgeführt werden). Ein stündlicher Job, der für `:00` geplant ist, kann überall bis `:30` laufen.

172* Einmalige Aufgaben, die für die Ober- oder Unterseite der Stunde geplant sind, laufen bis zu 90 Sekunden früh.174* Einmalige Aufgaben, die für die Ober- oder Unterseite der Stunde geplant sind, laufen bis zu 90 Sekunden früh.

173 175

174Der Offset wird von der Aufgaben-ID abgeleitet, daher erhält die gleiche Aufgabe immer den gleichen Offset. Wenn genaue Zeitangaben wichtig sind, wählen Sie eine Minute, die nicht `:00` oder `:30` ist, zum Beispiel `3 9 * * *` statt `0 9 * * *`, und der einmalige Jitter wird nicht angewendet.176Der Offset wird von der Aufgaben-ID abgeleitet, daher erhält die gleiche Aufgabe immer den gleichen Offset. Wenn genaue Zeitangaben wichtig sind, wählen Sie eine Minute, die nicht `:00` oder `:30` ist, zum Beispiel `3 9 * * *` statt `0 9 * * *`, und der einmalige Jitter wird nicht angewendet.

settings.md +1 −0

Details

183| `companyAnnouncements` | Ankündigung, die Benutzern beim Start angezeigt werden soll. Wenn mehrere Ankündigungen bereitgestellt werden, werden sie zufällig durchlaufen. | `["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]` |183| `companyAnnouncements` | Ankündigung, die Benutzern beim Start angezeigt werden soll. Wenn mehrere Ankündigungen bereitgestellt werden, werden sie zufällig durchlaufen. | `["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]` |

184| `defaultShell` | Standard-Shell für Input-Box `!` Befehle. Akzeptiert `"bash"` (Standard) oder `"powershell"`. Das Setzen auf `"powershell"` leitet interaktive `!` Befehle über PowerShell unter Windows. Erfordert `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`. Siehe [PowerShell-Tool](/de/tools-reference#powershell-tool) | `"powershell"` |184| `defaultShell` | Standard-Shell für Input-Box `!` Befehle. Akzeptiert `"bash"` (Standard) oder `"powershell"`. Das Setzen auf `"powershell"` leitet interaktive `!` Befehle über PowerShell unter Windows. Erfordert `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`. Siehe [PowerShell-Tool](/de/tools-reference#powershell-tool) | `"powershell"` |

185| `deniedMcpServers` | Wenn in managed-settings.json gesetzt, Denylist von MCP-Servern, die explizit blockiert sind. Gilt für alle Bereiche einschließlich verwalteter Server. Denylist hat Vorrang vor Allowlist. Siehe [Verwaltete MCP-Konfiguration](/de/mcp#managed-mcp-configuration) | `[{ "serverName": "filesystem" }]` |185| `deniedMcpServers` | Wenn in managed-settings.json gesetzt, Denylist von MCP-Servern, die explizit blockiert sind. Gilt für alle Bereiche einschließlich verwalteter Server. Denylist hat Vorrang vor Allowlist. Siehe [Verwaltete MCP-Konfiguration](/de/mcp#managed-mcp-configuration) | `[{ "serverName": "filesystem" }]` |

186| `disableAgentView` | Setzen Sie auf `true`, um [Hintergrund-Agenten und Agent-Ansicht](/de/agent-view) auszuschalten: `claude agents`, `--bg`, `/background` und den On-Demand-Supervisor. Normalerweise in [verwalteten Einstellungen](/de/permissions#managed-settings) gesetzt. Entspricht dem Setzen von `CLAUDE_CODE_DISABLE_AGENT_VIEW` auf `1` | `true` |

187| `disableAutoMode` | Setzen Sie auf `"disable"`, um zu verhindern, dass der [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode) aktiviert wird. Entfernt `auto` aus dem `Shift+Tab`-Zyklus und lehnt `--permission-mode auto` beim Start ab. Am nützlichsten in [verwalteten Einstellungen](/de/permissions#managed-settings), wo Benutzer es nicht überschreiben können | `"disable"` |188| `disableAutoMode` | Setzen Sie auf `"disable"`, um zu verhindern, dass der [Auto-Modus](/de/permission-modes#eliminate-prompts-with-auto-mode) aktiviert wird. Entfernt `auto` aus dem `Shift+Tab`-Zyklus und lehnt `--permission-mode auto` beim Start ab. Am nützlichsten in [verwalteten Einstellungen](/de/permissions#managed-settings), wo Benutzer es nicht überschreiben können | `"disable"` |

188| `disableDeepLinkRegistration` | Setzen Sie auf `"disable"`, um zu verhindern, dass Claude Code den `claude-cli://` Protokoll-Handler beim Start mit dem Betriebssystem registriert. [Deep Links](/de/deep-links) ermöglichen es externen Tools, eine Claude Code-Sitzung mit einer vorausgefüllten Aufforderung zu öffnen. Nützlich in Umgebungen, in denen die Protokoll-Handler-Registrierung eingeschränkt oder separat verwaltet wird | `"disable"` |189| `disableDeepLinkRegistration` | Setzen Sie auf `"disable"`, um zu verhindern, dass Claude Code den `claude-cli://` Protokoll-Handler beim Start mit dem Betriebssystem registriert. [Deep Links](/de/deep-links) ermöglichen es externen Tools, eine Claude Code-Sitzung mit einer vorausgefüllten Aufforderung zu öffnen. Nützlich in Umgebungen, in denen die Protokoll-Handler-Registrierung eingeschränkt oder separat verwaltet wird | `"disable"` |

sub-agents.md +8 −8

Details

11Jeder Subagent läuft in seinem eigenen Kontextfenster mit einem benutzerdefinierten Systemprompt, spezifischem Werkzeugzugriff und unabhängigen Berechtigungen. Wenn Claude auf eine Aufgabe trifft, die der Beschreibung eines Subagenten entspricht, delegiert es an diesen Subagenten, der unabhängig arbeitet und Ergebnisse zurückgibt. Um die Kontexteinsparungen in der Praxis zu sehen, zeigt die [Kontextfenster-Visualisierung](/de/context-window) eine Sitzung, in der ein Subagent Recherchen in seinem eigenen separaten Fenster durchführt.11Jeder Subagent läuft in seinem eigenen Kontextfenster mit einem benutzerdefinierten Systemprompt, spezifischem Werkzeugzugriff und unabhängigen Berechtigungen. Wenn Claude auf eine Aufgabe trifft, die der Beschreibung eines Subagenten entspricht, delegiert es an diesen Subagenten, der unabhängig arbeitet und Ergebnisse zurückgibt. Um die Kontexteinsparungen in der Praxis zu sehen, zeigt die [Kontextfenster-Visualisierung](/de/context-window) eine Sitzung, in der ein Subagent Recherchen in seinem eigenen separaten Fenster durchführt.

12 12

13<Note>13<Note>

14 Wenn Sie mehrere Agenten benötigen, die parallel arbeiten und miteinander kommunizieren, siehe stattdessen [Agent-Teams](/de/agent-teams). Subagenten arbeiten innerhalb einer einzelnen Sitzung; Agent-Teams koordinieren über separate Sitzungen hinweg.14 Subagenten arbeiten innerhalb einer einzelnen Sitzung. Um viele unabhängige Sitzungen parallel auszuführen und sie von einem Ort aus zu überwachen, siehe [Hintergrund-Agenten](/de/agent-view). Für Sitzungen, die miteinander kommunizieren, siehe [Agent-Teams](/de/agent-teams).

15</Note>15</Note>

16 16

17Subagenten helfen Ihnen:17Subagenten helfen Ihnen:

158 158

159Dies ist die empfohlene Methode zum Erstellen und Verwalten von Subagenten. Für manuelle Erstellung oder Automatisierung können Sie auch Subagenten-Dateien direkt hinzufügen.159Dies ist die empfohlene Methode zum Erstellen und Verwalten von Subagenten. Für manuelle Erstellung oder Automatisierung können Sie auch Subagenten-Dateien direkt hinzufügen.

160 160

161Um alle konfigurierten Subagenten von der Befehlszeile aus ohne Starten einer interaktiven Sitzung aufzulisten, führen Sie `claude agents` aus. Dies zeigt Agenten gruppiert nach Quelle und gibt an, welche durch höherrangige Definitionen überschrieben werden.161Um alle konfigurierten Subagenten von der Befehlszeile aus ohne Öffnen der [Agent-Ansicht](/de/agent-view) aufzulisten, leiten Sie die Ausgabe von `claude agents` weiter. Zum Beispiel druckt `claude agents | cat` Agenten gruppiert nach Quelle und gibt an, welche durch höherrangige Definitionen überschrieben werden.

162 162

163### Wählen Sie den Subagenten-Umfang163### Wählen Sie den Subagenten-Umfang

164 164

260 260

262| :---------------- | :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |262| :---------------- | :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

263| `name` | Ja | Eindeutige Kennung mit Kleinbuchstaben und Bindestrichen |263| `name` | Ja | Eindeutige Kennung mit Kleinbuchstaben und Bindestrichen. [Hooks](/de/hooks#subagentstart) erhalten diesen Wert als `agent_type`. Der Dateiname muss nicht übereinstimmen |

264| `description` | Ja | Wann Claude an diesen Subagenten delegieren sollte |264| `description` | Ja | Wann Claude an diesen Subagenten delegieren sollte |

265| `tools` | Nein | [Werkzeuge](#available-tools), die der Subagent verwenden kann. Erbt alle Werkzeuge, wenn weggelassen. Um Skills in den Kontext zu laden, verwenden Sie das `skills`-Feld statt `Skill` hier aufzulisten |265| `tools` | Nein | [Werkzeuge](#available-tools), die der Subagent verwenden kann. Erbt alle Werkzeuge, wenn weggelassen. Um Skills in den Kontext zu laden, verwenden Sie das `skills`-Feld statt `Skill` hier aufzulisten |

666 666

667Subagenten können im Vordergrund (blockierend) oder Hintergrund (gleichzeitig) ausgeführt werden:667Subagenten können im Vordergrund (blockierend) oder Hintergrund (gleichzeitig) ausgeführt werden:

668 668

669* **Vordergrund-Subagenten** blockieren die Hauptkonversation bis zur Fertigstellung. Berechtigungsaufforderungen und Klarstellungsfragen (wie [`AskUserQuestion`](/de/tools-reference)) werden an Sie weitergeleitet.669* **Vordergrund-Subagenten** blockieren die Hauptkonversation bis zur Fertigstellung. Berechtigungsaufforderungen werden an Sie weitergeleitet, wenn sie auftreten.

670* **Hintergrund-Subagenten** laufen gleichzeitig, während Sie weiterarbeiten. Vor dem Start fordert Claude Code alle Werkzeugberechtigungen an, die der Subagent benötigt, um sicherzustellen, dass er die erforderlichen Genehmigungen hat. Nach dem Start erbt der Subagent diese Berechtigungen und lehnt automatisch alles ab, was nicht vorab genehmigt wurde. Wenn ein Hintergrund-Subagent Klarstellungsfragen stellen muss, schlägt dieser Werkzeugaufruf fehl, aber der Subagent setzt fort.670* **Hintergrund-Subagenten** laufen gleichzeitig, während Sie weiterarbeiten. Sie laufen mit den Berechtigungen, die bereits in der Sitzung gewährt wurden, und lehnen automatisch jeden Werkzeugaufruf ab, der sonst eine Aufforderung auslösen würde. Wenn ein Hintergrund-Subagent Klarstellungsfragen stellen muss, schlägt dieser Werkzeugaufruf fehl, aber der Subagent setzt fort.

671 671

672Wenn ein Hintergrund-Subagent aufgrund fehlender Berechtigungen fehlschlägt, können Sie einen neuen Vordergrund-Subagenten mit derselben Aufgabe starten, um es mit interaktiven Aufforderungen erneut zu versuchen.672Wenn ein Hintergrund-Subagent aufgrund fehlender Berechtigungen fehlschlägt, können Sie einen neuen Vordergrund-Subagenten mit derselben Aufgabe starten, um es mit interaktiven Aufforderungen erneut zu versuchen.

673 673

678 678

679Um alle Hintergrund-Aufgaben-Funktionalität zu deaktivieren, setzen Sie die Umgebungsvariable `CLAUDE_CODE_DISABLE_BACKGROUND_TASKS` auf `1`. Siehe [Umgebungsvariablen](/de/env-vars).679Um alle Hintergrund-Aufgaben-Funktionalität zu deaktivieren, setzen Sie die Umgebungsvariable `CLAUDE_CODE_DISABLE_BACKGROUND_TASKS` auf `1`. Siehe [Umgebungsvariablen](/de/env-vars).

680 680

681Wenn der Fork-Modus aktiviert ist, wird jeder Subagenten-Spawn im Hintergrund ausgeführt, unabhängig vom `background`-Feld. Forks zeigen weiterhin Berechtigungsaufforderungen in Ihrem Terminal an, wenn sie auftreten, anstatt vorab zu genehmigen; benannte Subagenten folgen dem Vorab-Genehmigungsfluss oben.681Wenn der Fork-Modus aktiviert ist, wird jeder Subagenten-Spawn im Hintergrund ausgeführt, unabhängig vom `background`-Feld. Forks zeigen weiterhin Berechtigungsaufforderungen in Ihrem Terminal an, wenn sie auftreten; benannte Subagenten lehnen automatisch alles ab, was eine Aufforderung auslösen würde, wie oben beschrieben.

682 682

683### Häufige Muster683### Häufige Muster

684 684

824Ein Fork erbt alles, was die Hauptsitzung zum Zeitpunkt des Spawnens hat. Ein benannter Subagent startet von seiner eigenen Definition.824Ein Fork erbt alles, was die Hauptsitzung zum Zeitpunkt des Spawnens hat. Ein benannter Subagent startet von seiner eigenen Definition.

825 825

826| | Fork | Benannter Subagent |826| | Fork | Benannter Subagent |

827| :------------------------- | :------------------------------------------ | :------------------------------------------------------------------------------------------------------ |827| :------------------------- | :------------------------------------------ | :------------------------------------------------------------------------------------------------ |

833 833

834Da der Systemprompt und die Werkzeugdefinitionen eines Forks identisch mit dem übergeordneten Element sind, wird seine erste Anfrage den Prompt-Cache des übergeordneten Elements wiederverwenden. Dies macht das Forking billiger als das Spawnen eines frischen Subagenten für Aufgaben, die denselben Kontext benötigen.834Da der Systemprompt und die Werkzeugdefinitionen eines Forks identisch mit dem übergeordneten Element sind, wird seine erste Anfrage den Prompt-Cache des übergeordneten Elements wiederverwenden. Dies macht das Forking billiger als das Spawnen eines frischen Subagenten für Aufgaben, die denselben Kontext benötigen.

third-party-integrations.md +12 −2

Details

99 <th>Claude for Teams/Enterprise</th>99 <th>Claude for Teams/Enterprise</th>

100 <th>Anthropic Console</th>100 <th>Anthropic Console</th>

101 <th>Amazon Bedrock</th>101 <th>Amazon Bedrock</th>

102 <th>Claude Platform on AWS</th>

102 <th>Google Vertex AI</th>103 <th>Google Vertex AI</th>

103 <th>Microsoft Foundry</th>104 <th>Microsoft Foundry</th>

104 </tr>105 </tr>

110 <td>Die meisten Organisationen (empfohlen)</td>111 <td>Die meisten Organisationen (empfohlen)</td>

111 <td>Einzelne Entwickler</td>112 <td>Einzelne Entwickler</td>

112 <td>AWS-native Bereitstellungen</td>113 <td>AWS-native Bereitstellungen</td>

114 <td>AWS Marketplace-Abrechnung mit Claude API-Funktionen</td>

113 <td>GCP-native Bereitstellungen</td>115 <td>GCP-native Bereitstellungen</td>

114 <td>Azure-native Bereitstellungen</td>116 <td>Azure-native Bereitstellungen</td>

115 </tr>117 </tr>

119 <td><strong>Teams:</strong> 150 USD/Platz (Premium) mit PAYG verfügbar<br /><strong>Enterprise:</strong> <a href="https://claude.com/contact-sales?utm_source=claude_code&utm_medium=docs&utm_content=third_party_enterprise">Kontaktieren Sie den Vertrieb</a></td>121 <td><strong>Teams:</strong> 150 USD/Platz (Premium) mit PAYG verfügbar<br /><strong>Enterprise:</strong> <a href="https://claude.com/contact-sales?utm_source=claude_code&utm_medium=docs&utm_content=third_party_enterprise">Kontaktieren Sie den Vertrieb</a></td>

120 <td>PAYG</td>122 <td>PAYG</td>

121 <td>PAYG über AWS</td>123 <td>PAYG über AWS</td>

124 <td>PAYG über AWS Marketplace</td>

122 <td>PAYG über GCP</td>125 <td>PAYG über GCP</td>

123 <td>PAYG über Azure</td>126 <td>PAYG über Azure</td>

124 </tr>127 </tr>

128 <td>Unterstützte [Länder](https://www.anthropic.com/supported-countries)</td>131 <td>Unterstützte [Länder](https://www.anthropic.com/supported-countries)</td>

129 <td>Unterstützte [Länder](https://www.anthropic.com/supported-countries)</td>132 <td>Unterstützte [Länder](https://www.anthropic.com/supported-countries)</td>

130 <td>Mehrere AWS [Regionen](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html)</td>133 <td>Mehrere AWS [Regionen](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html)</td>

134 <td>Mehrere AWS-Regionen</td>

131 <td>Mehrere GCP [Regionen](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations)</td>135 <td>Mehrere GCP [Regionen](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations)</td>

132 <td>Mehrere Azure [Regionen](https://azure.microsoft.com/en-us/explore/global-infrastructure/products-by-region/)</td>136 <td>Mehrere Azure [Regionen](https://azure.microsoft.com/en-us/explore/global-infrastructure/products-by-region/)</td>

133 </tr>137 </tr>

139 <td>Standardmäßig aktiviert</td>143 <td>Standardmäßig aktiviert</td>

140 <td>Standardmäßig aktiviert</td>144 <td>Standardmäßig aktiviert</td>

141 <td>Standardmäßig aktiviert</td>145 <td>Standardmäßig aktiviert</td>

146 <td>Standardmäßig aktiviert</td>

142 </tr>147 </tr>

143 148

144 <tr>149 <tr>

146 <td>Claude.ai SSO oder E-Mail</td>151 <td>Claude.ai SSO oder E-Mail</td>

147 <td>API-Schlüssel</td>152 <td>API-Schlüssel</td>

148 <td>API-Schlüssel oder AWS-Anmeldedaten</td>153 <td>API-Schlüssel oder AWS-Anmeldedaten</td>

154 <td>API-Schlüssel oder AWS-Anmeldedaten</td>

149 <td>GCP-Anmeldedaten</td>155 <td>GCP-Anmeldedaten</td>

150 <td>API-Schlüssel oder Microsoft Entra ID</td>156 <td>API-Schlüssel oder Microsoft Entra ID</td>

151 </tr>157 </tr>

155 <td>Nutzungs-Dashboard</td>161 <td>Nutzungs-Dashboard</td>

156 <td>Nutzungs-Dashboard</td>162 <td>Nutzungs-Dashboard</td>

157 <td>AWS Cost Explorer</td>163 <td>AWS Cost Explorer</td>

164 <td>AWS Cost Explorer</td>

158 <td>GCP Billing</td>165 <td>GCP Billing</td>

159 <td>Azure Cost Management</td>166 <td>Azure Cost Management</td>

160 </tr>167 </tr>

166 <td>Nein</td>173 <td>Nein</td>

167 <td>Nein</td>174 <td>Nein</td>

168 <td>Nein</td>175 <td>Nein</td>

176 <td>Nein</td>

169 </tr>177 </tr>

170 178

171 <tr>179 <tr>

173 <td>Teamverwaltung, SSO, Nutzungsüberwachung</td>181 <td>Teamverwaltung, SSO, Nutzungsüberwachung</td>

174 <td>Keine</td>182 <td>Keine</td>

175 <td>IAM-Richtlinien, CloudTrail</td>183 <td>IAM-Richtlinien, CloudTrail</td>

184 <td>IAM-Richtlinien, CloudTrail</td>

176 <td>IAM-Rollen, Cloud Audit Logs</td>185 <td>IAM-Rollen, Cloud Audit Logs</td>

177 <td>RBAC-Richtlinien, Azure Monitor</td>186 <td>RBAC-Richtlinien, Azure Monitor</td>

178 </tr>187 </tr>

184* [Claude for Teams oder Enterprise](/de/authentication#claude-for-teams-or-enterprise)193* [Claude for Teams oder Enterprise](/de/authentication#claude-for-teams-or-enterprise)

185* [Anthropic Console](/de/authentication#claude-console-authentication)194* [Anthropic Console](/de/authentication#claude-console-authentication)

186* [Amazon Bedrock](/de/amazon-bedrock)195* [Amazon Bedrock](/de/amazon-bedrock)

196* [Claude Platform on AWS](/de/claude-platform-on-aws)

187* [Google Vertex AI](/de/google-vertex-ai)197* [Google Vertex AI](/de/google-vertex-ai)

188* [Microsoft Foundry](/de/microsoft-foundry)198* [Microsoft Foundry](/de/microsoft-foundry)

189 199

192Die meisten Organisationen können einen Cloud-Anbieter direkt ohne zusätzliche Konfiguration nutzen. Möglicherweise müssen Sie jedoch einen Unternehmens-Proxy oder LLM-Gateway konfigurieren, wenn Ihre Organisation spezifische Netzwerk- oder Verwaltungsanforderungen hat. Dies sind unterschiedliche Konfigurationen, die zusammen verwendet werden können:202Die meisten Organisationen können einen Cloud-Anbieter direkt ohne zusätzliche Konfiguration nutzen. Möglicherweise müssen Sie jedoch einen Unternehmens-Proxy oder LLM-Gateway konfigurieren, wenn Ihre Organisation spezifische Netzwerk- oder Verwaltungsanforderungen hat. Dies sind unterschiedliche Konfigurationen, die zusammen verwendet werden können:

193 203

194* **Unternehmens-Proxy**: Leitet Datenverkehr über einen HTTP/HTTPS-Proxy weiter. Verwenden Sie dies, wenn Ihre Organisation verlangt, dass der gesamte ausgehende Datenverkehr einen Proxy-Server für Sicherheitsüberwachung, Compliance oder Netzwerkrichtliniendurchsetzung durchläuft. Konfigurieren Sie mit den Umgebungsvariablen `HTTPS_PROXY` oder `HTTP_PROXY`. Erfahren Sie mehr in [Enterprise-Netzwerkkonfiguration](/de/network-config).204* **Unternehmens-Proxy**: Leitet Datenverkehr über einen HTTP/HTTPS-Proxy weiter. Verwenden Sie dies, wenn Ihre Organisation verlangt, dass der gesamte ausgehende Datenverkehr einen Proxy-Server für Sicherheitsüberwachung, Compliance oder Netzwerkrichtliniendurchsetzung durchläuft. Konfigurieren Sie mit den Umgebungsvariablen `HTTPS_PROXY` oder `HTTP_PROXY`. Erfahren Sie mehr in [Enterprise-Netzwerkkonfiguration](/de/network-config).

195* **LLM-Gateway**: Ein Dienst, der sich zwischen Claude Code und dem Cloud-Anbieter befindet, um Authentifizierung und Routing zu verwalten. Verwenden Sie dies, wenn Sie eine zentralisierte Nutzungsverfolgung über Teams, benutzerdefinierte Ratenbegrenzung oder Budgets oder zentralisierte Authentifizierungsverwaltung benötigen. Konfigurieren Sie mit den Umgebungsvariablen `ANTHROPIC_BASE_URL`, `ANTHROPIC_BEDROCK_BASE_URL` oder `ANTHROPIC_VERTEX_BASE_URL`. Erfahren Sie mehr in [LLM-Gateway-Konfiguration](/de/llm-gateway).205* **LLM-Gateway**: Ein Dienst, der sich zwischen Claude Code und dem Cloud-Anbieter befindet, um Authentifizierung und Routing zu verwalten. Verwenden Sie dies, wenn Sie eine zentralisierte Nutzungsverfolgung über Teams, benutzerdefinierte Ratenbegrenzung oder Budgets oder zentralisierte Authentifizierungsverwaltung benötigen. Konfigurieren Sie mit den Umgebungsvariablen `ANTHROPIC_BASE_URL`, `ANTHROPIC_BEDROCK_BASE_URL`, `ANTHROPIC_AWS_BASE_URL` oder `ANTHROPIC_VERTEX_BASE_URL`. Erfahren Sie mehr in [LLM-Gateway-Konfiguration](/de/llm-gateway).

196 206

197Die folgenden Beispiele zeigen die Umgebungsvariablen, die in Ihrer Shell oder Shell-Profildatei (`.bashrc`, `.zshrc`) gesetzt werden sollen. Siehe [Einstellungen](/de/settings) für andere Konfigurationsmethoden.207Die folgenden Beispiele zeigen die Umgebungsvariablen, die in Ihrer Shell oder Shell-Profildatei (`.bashrc`, `.zshrc`) gesetzt werden sollen. Siehe [Einstellungen](/de/settings) für andere Konfigurationsmethoden.

198 208

313 323

314### Pinnen Sie Modellversionen für Cloud-Anbieter324### Pinnen Sie Modellversionen für Cloud-Anbieter

315 325

316Wenn Sie über [Bedrock](/de/amazon-bedrock), [Vertex AI](/de/google-vertex-ai) oder [Foundry](/de/microsoft-foundry) bereitstellen, pinnen Sie spezifische Modellversionen mit `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL` und `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Ohne Pinning werden Modellaliase zur neuesten Version aufgelöst, die möglicherweise noch nicht in Ihrem Konto aktiviert ist, wenn Anthropic ein Update veröffentlicht. Pinning ermöglicht es Ihnen, zu kontrollieren, wann Ihre Benutzer zu einem neuen Modell wechseln. Siehe [Modellkonfiguration](/de/model-config#pin-models-for-third-party-deployments) für Details zu dem, was jeder Anbieter tut, wenn die neueste Version nicht verfügbar ist.326Wenn Sie über [Bedrock](/de/amazon-bedrock), [Vertex AI](/de/google-vertex-ai), [Foundry](/de/microsoft-foundry) oder [Claude Platform on AWS](/de/claude-platform-on-aws) bereitstellen, pinnen Sie spezifische Modellversionen mit `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL` und `ANTHROPIC_DEFAULT_HAIKU_MODEL`. Ohne Pinning werden Modellaliase zur neuesten Version aufgelöst, die möglicherweise noch nicht in Ihrem Konto aktiviert ist, wenn Anthropic ein Update veröffentlicht. Pinning ermöglicht es Ihnen, zu kontrollieren, wann Ihre Benutzer zu einem neuen Modell wechseln. Siehe [Modellkonfiguration](/de/model-config#pin-models-for-third-party-deployments) für Details zu dem, was jeder Anbieter tut, wenn die neueste Version nicht verfügbar ist.

317 327

318### Konfigurieren Sie Sicherheitsrichtlinien328### Konfigurieren Sie Sicherheitsrichtlinien

319 329

tools-reference.md +180 −13

Details

4 4

5# Werkzeugreferenz5# Werkzeugreferenz

6 6

~~7> Vollständige Referenz für die Werkzeuge, die Claude Code verwenden kann, einschließlich Berechtigungsanforderungen.~~7> Vollständige Referenz für die Werkzeuge, die Claude Code verwenden kann, einschließlich Berechtigungsanforderungen und Verhalten pro Werkzeug.

8 8

9Claude Code hat Zugriff auf eine Reihe von integrierten Werkzeugen, die ihm helfen, Ihre Codebasis zu verstehen und zu ändern. Die Werkzeugnamen sind die genauen Zeichenketten, die Sie in [Berechtigungsregeln](/de/permissions#tool-specific-permission-rules), [Subagent-Werkzeuglisten](/de/sub-agents) und [Hook-Matchern](/de/hooks) verwenden. Um ein Werkzeug vollständig zu deaktivieren, fügen Sie seinen Namen zum `deny`-Array in Ihren [Berechtigungseinstellungen](/de/permissions#tool-specific-permission-rules) hinzu.9Claude Code hat Zugriff auf eine Reihe von integrierten Werkzeugen, die ihm helfen, Ihre Codebasis zu verstehen und zu ändern. Die Werkzeugnamen sind die genauen Zeichenketten, die Sie in [Berechtigungsregeln](/de/permissions#tool-specific-permission-rules), [Subagent-Werkzeuglisten](/de/sub-agents) und [Hook-Matchern](/de/hooks) verwenden. Um ein Werkzeug vollständig zu deaktivieren, fügen Sie seinen Namen zum `deny`-Array in Ihren [Berechtigungseinstellungen](/de/permissions#tool-specific-permission-rules) hinzu.

10 10

11Um benutzerdefinierte Werkzeuge hinzuzufügen, verbinden Sie einen [MCP-Server](/de/mcp). Um Claude mit wiederverwendbaren Prompt-basierten Workflows zu erweitern, schreiben Sie einen [Skill](/de/skills), der über das vorhandene `Skill`-Werkzeug ausgeführt wird, anstatt einen neuen Werkzeugeintrag hinzuzufügen.11Um benutzerdefinierte Werkzeuge hinzuzufügen, verbinden Sie einen [MCP-Server](/de/mcp). Um Claude mit wiederverwendbaren Prompt-basierten Workflows zu erweitern, schreiben Sie einen [Skill](/de/skills), der über das vorhandene `Skill`-Werkzeug ausgeführt wird, anstatt einen neuen Werkzeugeintrag hinzuzufügen.

12 12

14| :--------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------------------------ |14| :--------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------ |

17| `Bash` | Führt Shell-Befehle in Ihrer Umgebung aus. Siehe [Bash-Werkzeugverhalten](#bash-tool-behavior) | Ja |17| `Bash` | Führt Shell-Befehle in Ihrer Umgebung aus. Siehe [Bash-Werkzeugverhalten](#bash-tool-behavior) | Ja |

18| `CronCreate` | Plant eine wiederkehrende oder einmalige Eingabeaufforderung innerhalb der aktuellen Sitzung. Aufgaben sind sitzungsbezogen und werden bei `--resume` oder `--continue` wiederhergestellt, wenn sie nicht abgelaufen sind. Siehe [geplante Aufgaben](/de/scheduled-tasks) | Nein |18| `CronCreate` | Plant eine wiederkehrende oder einmalige Eingabeaufforderung innerhalb der aktuellen Sitzung. Aufgaben sind sitzungsbezogen und werden bei `--resume` oder `--continue` wiederhergestellt, wenn sie nicht abgelaufen sind. Siehe [geplante Aufgaben](/de/scheduled-tasks) | Nein |

21| `Edit` | Nimmt gezielte Änderungen an bestimmten Dateien vor | Ja |21| `Edit` | Nimmt gezielte Änderungen an bestimmten Dateien vor. Siehe [Edit-Werkzeugverhalten](#edit-tool-behavior) | Ja |

23| `EnterWorktree` | Erstellt einen isolierten [Git Worktree](/de/common-workflows#run-parallel-claude-code-sessions-with-git-worktrees) und wechselt hinein. Übergeben Sie einen `path`, um stattdessen in einen vorhandenen Worktree des aktuellen Repositorys zu wechseln, anstatt einen neuen zu erstellen. Nicht für Subagenten verfügbar | Nein |23| `EnterWorktree` | Erstellt einen isolierten [Git Worktree](/de/worktrees) und wechselt hinein. Übergeben Sie einen `path`, um stattdessen in einen vorhandenen Worktree des aktuellen Repositorys zu wechseln, anstatt einen neuen zu erstellen. Nicht für Subagenten verfügbar | Nein |

24| `ExitPlanMode` | Präsentiert einen Plan zur Genehmigung und beendet Plan Mode | Ja |24| `ExitPlanMode` | Präsentiert einen Plan zur Genehmigung und beendet Plan Mode | Ja |

29| `LSP` | Code-Intelligenz über Sprachserver: Sprung zu Definitionen, Suche nach Referenzen, Meldung von Typfehlern und Warnungen. Siehe [LSP-Werkzeugverhalten](#lsp-tool-behavior) | Nein |29| `LSP` | Code-Intelligenz über Sprachserver: Sprung zu Definitionen, Suche nach Referenzen, Meldung von Typfehlern und Warnungen. Siehe [LSP-Werkzeugverhalten](#lsp-tool-behavior) | Nein |

30| `Monitor` | Führt einen Befehl im Hintergrund aus und gibt jede Ausgabezeile an Claude zurück, damit er auf Protokolleinträge, Dateiänderungen oder abgerufene Status während des Gesprächs reagieren kann. Siehe [Monitor-Werkzeug](#monitor-tool) | Ja |30| `Monitor` | Führt einen Befehl im Hintergrund aus und gibt jede Ausgabezeile an Claude zurück, damit er auf Protokolleinträge, Dateiänderungen oder abgerufene Status während des Gesprächs reagieren kann. Siehe [Monitor-Werkzeug](#monitor-tool) | Ja |

31| `NotebookEdit` | Ändert Jupyter-Notebook-Zellen | Ja |31| `NotebookEdit` | Ändert Jupyter-Notebook-Zellen. Siehe [NotebookEdit-Werkzeugverhalten](#notebookedit-tool-behavior) | Ja |

32| `PowerShell` | Führt PowerShell-Befehle nativ aus. Siehe [PowerShell-Werkzeug](#powershell-tool) für Verfügbarkeit | Ja |32| `PowerShell` | Führt PowerShell-Befehle nativ aus. Siehe [PowerShell-Werkzeug](#powershell-tool) für Verfügbarkeit | Ja |

33| `Read` | Liest den Inhalt von Dateien | Nein |33| `PushNotification` | Sendet eine Desktop-Benachrichtigung und eine Telefon-Push-Benachrichtigung, wenn [Remote Control](/de/remote-control) verbunden ist, damit eine langfristige Aufgabe oder [geplante Aufgabe](/de/scheduled-tasks) Sie erreichen kann, wenn Sie weg sind. {/* plan-availability: feature=push-notifications providers=anthropic */}Push-Zustellung läuft über von Anthropic gehostete Infrastruktur, auf die von Amazon Bedrock, Google Vertex AI oder Microsoft Foundry nicht zugegriffen werden kann | Nein |

34| `Read` | Liest den Inhalt von Dateien. Siehe [Read-Werkzeugverhalten](#read-tool-behavior) | Nein |

36| `RemoteTrigger` | Erstellt, aktualisiert, führt aus und listet [Routinen](/de/routines) auf claude.ai auf. Unterstützt den `/schedule`-Befehl. {/* plan-availability: feature=routines plans=pro,max,team,enterprise providers=anthropic */}Routinen befinden sich auf claude.ai und erfordern einen Pro-, Max-, Team- oder Enterprise-Plan, daher ist dieses Werkzeug nicht über Amazon Bedrock, Google Vertex AI oder Microsoft Foundry zugänglich | Nein |

35| `SendMessage` | Sendet eine Nachricht an einen [Agent-Team](/de/agent-teams)-Mitarbeiter oder [setzt einen Subagenten](/de/sub-agents#resume-subagents) nach seiner Agent-ID fort. Gestoppte Subagenten werden automatisch im Hintergrund fortgesetzt. Nur verfügbar, wenn `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` gesetzt ist | Nein |37| `SendMessage` | Sendet eine Nachricht an einen [Agent-Team](/de/agent-teams)-Mitarbeiter oder [setzt einen Subagenten](/de/sub-agents#resume-subagents) nach seiner Agent-ID fort. Gestoppte Subagenten werden automatisch im Hintergrund fortgesetzt. Nur verfügbar, wenn `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` gesetzt ist | Nein |

38| `ShareOnboardingGuide` | {/* plan-availability: feature=onboarding-guide-share plans=pro,max,team,enterprise providers=anthropic */}Lädt `ONBOARDING.md` hoch und gibt einen Freigabelink zurück, den Mitarbeiter in Claude Code öffnen können. Wird nach dem Schreiben des Leitfadens von `/team-onboarding` aufgerufen. Verfügbar für claude.ai-Abonnenten mit Pro-, Max-, Team- und Enterprise-Plänen | Ja |

36| `Skill` | Führt einen [Skill](/de/skills#control-who-invokes-a-skill) innerhalb des Hauptgesprächs aus | Ja |39| `Skill` | Führt einen [Skill](/de/skills#control-who-invokes-a-skill) innerhalb des Hauptgesprächs aus | Ja |

45| `TodoWrite` | Verwaltet die Sitzungs-Aufgabenliste. Verfügbar im nicht-interaktiven Modus und im [Agent SDK](/de/headless); interaktive Sitzungen verwenden stattdessen TaskCreate, TaskGet, TaskList und TaskUpdate | Nein |48| `TodoWrite` | Verwaltet die Sitzungs-Aufgabenliste. Verfügbar im nicht-interaktiven Modus und im [Agent SDK](/de/headless); interaktive Sitzungen verwenden stattdessen TaskCreate, TaskGet, TaskList und TaskUpdate | Nein |

47| `WebFetch` | Ruft Inhalte von einer angegebenen URL ab | Ja |50| `WebFetch` | Ruft Inhalte von einer angegebenen URL ab. Siehe [WebFetch-Werkzeugverhalten](#webfetch-tool-behavior) | Ja |

48| `WebSearch` | Führt Web-Suchen durch | Ja |51| `WebSearch` | Führt Web-Suchen durch. Siehe [WebSearch-Werkzeugverhalten](#websearch-tool-behavior) | Ja |

49| `Write` | Erstellt oder überschreibt Dateien | Ja |52| `Write` | Erstellt oder überschreibt Dateien. Siehe [Write-Werkzeugverhalten](#write-tool-behavior) | Ja |

50 53

51Berechtigungsregeln können mit `/permissions` oder in [Berechtigungseinstellungen](/de/settings#available-settings) konfiguriert werden. Siehe auch [Werkzeugspezifische Berechtigungsregeln](/de/permissions#tool-specific-permission-rules).54## Werkzeuge mit Berechtigungsregeln und Hooks konfigurieren

56Größtenteils entscheidet Claude, wann diese Werkzeuge verwendet werden sollen, und Sie müssen sie nicht selbst benennen, wenn Sie mit Claude interagieren. Sie verweisen direkt auf Werkzeugnamen, wenn Sie Berechtigungen und andere Konfigurationen definieren:

58* in [`permissions.allow` und `permissions.deny`](/de/settings#available-settings) in den Einstellungen und der `/permissions`-Schnittstelle

59* in den [CLI-Flags](/de/cli-reference) `--allowedTools` und `--disallowedTools`

60* in den Optionen [`allowedTools` und `disallowedTools`](/de/agent-sdk/permissions#allow-and-deny-rules) des Agent SDK

61* in einem [Subagenten-`tools` oder `disallowedTools`](/de/sub-agents#supported-frontmatter-fields)-Frontmatter

62* in einem [Skill-`allowed-tools`](/de/skills#frontmatter-reference)-Frontmatter

63* in der [`if`-Bedingung](/de/hooks-guide#filter-by-tool-name-and-arguments-with-the-if-field) eines Hooks

65Alle diese akzeptieren das gleiche Regelformat, `ToolName(specifier)`. Der Specifier hängt vom Werkzeug ab, und mehrere Werkzeuge teilen ein Format:

67| Regelformat | Gilt für | Details |

68| :----------------------------- | :------------------------ | :---------------------------------------------------------------- |

69| `Bash(npm run *)` | Bash, Monitor | [Befehlsmuster-Matching](/de/permissions#bash) |

70| `PowerShell(Get-ChildItem *)` | PowerShell | [Befehlsmuster-Matching](/de/permissions#powershell) |

71| `Read(~/secrets/**)` | Read, Grep, Glob, LSP | [Pfadmuster-Matching](/de/permissions#read-and-edit) |

72| `Edit(/src/**)` | Edit, Write, NotebookEdit | [Pfadmuster-Matching](/de/permissions#read-and-edit) |

73| `Skill(deploy *)` | Skill | [Skill-Namen-Matching](/de/skills#restrict-claude's-skill-access) |

74| `Agent(Explore)` | Agent | [Subagenten-Typ-Matching](/de/permissions#agent-subagents) |

75| `WebFetch(domain:example.com)` | WebFetch | [Domain-Matching](/de/permissions#webfetch) |

76| `WebSearch` | WebSearch | Kein Specifier; Werkzeug als Ganzes zulassen oder ablehnen |

78Werkzeuge, die hier nicht aufgelistet sind, wie `ExitPlanMode` oder `ShareOnboardingGuide`, akzeptieren nur den bloßen Werkzeugnamen ohne Specifier.

80Eine `Edit(...)`-Zulassungsregel gewährt auch Lesezugriff auf denselben Pfad, daher benötigen Sie keine entsprechende `Read(...)`-Regel.

82Hook-`matcher`-Felder verwenden bloße Werkzeugnamen, nicht das geklammerte Regelformat. Siehe [Matcher-Muster](/de/hooks#matcher-patterns) für die Matching-Regeln. Für die Feldnamen, die jedes Werkzeug an `tool_input` in Hooks übergibt, siehe die [PreToolUse-Eingabereferenz](/de/hooks#pretooluse-input).

84## Agent-Werkzeugverhalten

86Das Agent-Werkzeug erzeugt einen Subagenten in einem separaten Kontextfenster. Der Subagent arbeitet seine Aufgabe autonom durch und gibt dann ein einzelnes Textergebnis an das übergeordnete Gespräch zurück. Das übergeordnete Gespräch sieht nicht die Zwischenwerkzeugaufrufe oder Ausgaben des Subagenten, sondern nur dieses Endergebnis. Um zu begrenzen, wie viele Durchläufe ein Subagent ausführt, setzen Sie `maxTurns` in der [Subagenten-Definition](/de/sub-agents#supported-frontmatter-fields).

88Das gleiche Agent-Werkzeug startet auch [verzweigte Subagenten](/de/sub-agents#fork-the-current-conversation), wenn der Fork-Modus aktiviert ist. Ein Fork erbt das vollständige übergeordnete Gespräch, anstatt neu zu beginnen, läuft immer im Hintergrund und zeigt dennoch Berechtigungsaufforderungen in Ihrem Terminal. Der Rest dieses Abschnitts beschreibt benannte Subagenten.

90Welche Werkzeuge ein benannter Subagent verwenden kann, hängt von den Feldern `tools` und `disallowedTools` in der [Subagenten-Definition](/de/sub-agents) ab:

92* **Keines der Felder gesetzt**: Der Subagent erbt jedes Werkzeug, das dem übergeordneten Agenten zur Verfügung steht.

93* **Nur `tools`**: Der Subagent erhält nur die aufgelisteten Werkzeuge.

94* **Nur `disallowedTools`**: Der Subagent erhält jedes übergeordnete Werkzeug außer den aufgelisteten.

95* **Beide gesetzt**: `disallowedTools` hat Vorrang. Ein Werkzeug, das in beiden aufgelistet ist, wird entfernt.

97Das Starten des Subagenten fordert nicht selbst zur Berechtigung auf. Die eigenen Werkzeugaufrufe des Subagenten werden während der Ausführung gegen Ihre Berechtigungsregeln überprüft:

99* **Vordergrund-Subagenten** zeigen die gleichen Berechtigungsaufforderungen, die Sie im Hauptgespräch sehen würden, in dem Moment, in dem jeder Werkzeugaufruf stattfindet.

100* **Hintergrund-Subagenten** zeigen keine Aufforderungen. Sie laufen mit den bereits in der Sitzung gewährten Berechtigungen und lehnen automatisch jeden Werkzeugaufruf ab, der sonst eine Aufforderung auslösen würde. Nach einer Ablehnung läuft der Subagent ohne dieses Werkzeug weiter.

101

102Um zu begrenzen, was ein Subagent in erster Linie erreichen kann, verengen Sie sein `tools`-Feld, lassen Sie Bash von der Liste weg oder setzen Sie Ablehnungsregeln in Ihren Einstellungen, wie in [Subagenten-Funktionen steuern](/de/sub-agents#control-subagent-capabilities) beschrieben. Weitere Informationen zur Wahl zwischen Vordergrund und Hintergrund finden Sie unter [Subagenten im Vordergrund oder Hintergrund ausführen](/de/sub-agents#run-subagents-in-foreground-or-background).

52 103

53## Bash-Werkzeugverhalten104## Bash-Werkzeugverhalten

54 105

61 112

62Aktivieren Sie Ihre virtualenv- oder Conda-Umgebung, bevor Sie Claude Code starten. Um Umgebungsvariablen über Bash-Befehle hinweg persistent zu machen, setzen Sie [`CLAUDE_ENV_FILE`](/de/env-vars) auf ein Shell-Skript, bevor Sie Claude Code starten, oder verwenden Sie einen [SessionStart-Hook](/de/hooks#persist-environment-variables), um ihn dynamisch zu füllen.113Aktivieren Sie Ihre virtualenv- oder Conda-Umgebung, bevor Sie Claude Code starten. Um Umgebungsvariablen über Bash-Befehle hinweg persistent zu machen, setzen Sie [`CLAUDE_ENV_FILE`](/de/env-vars) auf ein Shell-Skript, bevor Sie Claude Code starten, oder verwenden Sie einen [SessionStart-Hook](/de/hooks#persist-environment-variables), um ihn dynamisch zu füllen.

63 114

115Zwei Grenzen begrenzen jeden Befehl:

116

117* **Timeout**: Standardmäßig zwei Minuten. Claude kann bis zu 10 Minuten pro Befehl mit dem `timeout`-Parameter anfordern. Überschreiben Sie den Standard und die Obergrenze mit [`BASH_DEFAULT_TIMEOUT_MS` und `BASH_MAX_TIMEOUT_MS`](/de/env-vars).

118* **Ausgabelänge**: Standardmäßig 30.000 Zeichen. Wenn ein Befehl mehr als das produziert, speichert Claude Code die vollständige Ausgabe in einer Datei im Sitzungsverzeichnis und gibt Claude den Dateipfad plus eine kurze Vorschau vom Anfang. Claude liest oder durchsucht diese Datei, wenn er den Rest benötigt. Erhöhen Sie das Limit mit [`BASH_MAX_OUTPUT_LENGTH`](/de/env-vars), bis zu einer harten Obergrenze von 150.000 Zeichen.

119

120Für langfristige Prozesse wie Dev-Server oder Watch-Builds kann Claude `run_in_background: true` setzen, um den Befehl als Hintergrundaufgabe zu starten und weiter zu arbeiten, während er läuft. Listen Sie Hintergrundaufgaben auf und beenden Sie sie mit `/tasks`.

121

122## Edit-Werkzeugverhalten

123

124Das Edit-Werkzeug führt exakte Zeichenkettenersetzung durch. Es nimmt einen `old_string` und einen `new_string` und ersetzt den ersten mit dem zweiten. Es verwendet keine Regex oder Fuzzy-Matching.

125

126Drei Überprüfungen müssen bestanden werden, damit eine Bearbeitung angewendet wird:

127

128* **Lesen vor Bearbeitung**: Claude muss die Datei im aktuellen Gespräch gelesen haben, und die Datei darf sich auf der Festplatte nicht geändert haben, seit sie gelesen wurde. Diese Überprüfung läuft zuerst, vor jedem Zeichenkettenabgleich.

129* **Abgleich**: `old_string` muss in der Datei genau wie geschrieben vorkommen. Ein einzelnes Zeichen Unterschied in Leerzeichen oder Einrückung reicht aus, um zu verfehlen.

130* **Eindeutigkeit**: `old_string` muss genau einmal vorkommen. Wenn es mehr als einmal vorkommt, liefert Claude entweder eine längere Zeichenkette mit ausreichend umgebendem Kontext, um ein Vorkommen festzulegen, oder setzt `replace_all: true`, um alle zu ersetzen.

131

132Das Anzeigen einer Datei mit Bash erfüllt auch die Anforderung zum Lesen vor Bearbeitung, wenn der Befehl `cat path/to/file` oder `sed -n 'X,Yp' path/to/file` auf einer einzelnen Datei ohne Pipes oder Umleitungen ist. Andere Bash-Befehle wie `head`, `tail` oder gepipte Ausgabe zählen nicht, und Claude muss in diesen Fällen Read vor der Bearbeitung verwenden.

133

134Dies betrifft nur die Bearbeitungsberechtigung, nicht die Berechtigungen. [Read- und Edit-Ablehnungsregeln](/de/permissions#tool-specific-permission-rules) gelten auch für Dateibefehle, die Claude Code in Bash erkennt, wie `cat`, `head`, `tail` und `sed`, aber nicht für beliebige Unterprozesse, die Dateien indirekt lesen oder schreiben, wie ein Python- oder Node-Skript, das Dateien selbst öffnet. Für OS-Ebenen-Durchsetzung, die jeden Prozess abdeckt, [aktivieren Sie die Sandbox](/de/sandboxing).

135

136## Glob-Werkzeugverhalten

137

138Das Glob-Werkzeug findet Dateien nach Namensmuster. Es unterstützt Standard-Glob-Syntax einschließlich `**` für rekursives Verzeichnis-Matching:

139

140* `**/*.js` passt alle `.js`-Dateien in beliebiger Tiefe

141* `src/**/*.ts` passt alle `.ts`-Dateien unter `src/`

142* `*.{json,yaml}` passt `.json`- und `.yaml`-Dateien im aktuellen Verzeichnis

143

144Ergebnisse werden nach Änderungszeit sortiert und auf 100 Dateien begrenzt. Wenn die Obergrenze erreicht wird, sieht Claude ein Kürzungsflag im Ergebnis und kann das Muster verengen.

145

146Glob respektiert `.gitignore` standardmäßig nicht, daher findet es gitignorierte Dateien neben verfolgten. Dies unterscheidet sich von [Grep](#grep-tool-behavior), das gitignorierte Dateien überspringt. Um Glob `.gitignore` respektieren zu lassen, setzen Sie `CLAUDE_CODE_GLOB_NO_IGNORE=false`, bevor Sie Claude Code starten.

147

148## Grep-Werkzeugverhalten

149

150Das Grep-Werkzeug durchsucht Dateiinhalte nach Mustern. Während [Glob](#glob-tool-behavior) Dateien nach Namen findet, findet Grep Zeilen in ihnen.

151

152Grep basiert auf [ripgrep](https://github.com/BurntSushi/ripgrep) und verwendet ripgreps Regex-Syntax, nicht POSIX-Grep. Muster, die Regex-Metazeichen enthalten, müssen maskiert werden. Zum Beispiel erfordert das Finden von `interface{}` in Go-Code das Muster `interface\{\}`.

153

154Drei Ausgabemodi steuern, was zurückkommt:

155

156* `files_with_matches`: nur Dateipfade, kein Zeileninhalt. Dies ist die Standardeinstellung.

157* `content`: übereinstimmende Zeilen mit Datei und Zeilennummer.

158* `count`: Übereinstimmungsanzahl pro Datei.

159

160Claude kann Ergebnisse nach Datei mit dem `glob`-Parameter wie `**/*.tsx` oder nach Sprache mit dem `type`-Parameter wie `py` oder `rust` eingrenzen. Standardmäßig passen Muster innerhalb einer einzelnen Zeile. Claude kann `multiline: true` setzen, um über Zeilengrenzen hinweg zu passen.

161

162Grep respektiert `.gitignore`, daher werden gitignorierte Dateien übersprungen. Um eine gitignorierte Datei zu durchsuchen, übergibt Claude ihren Pfad direkt.

163

64## LSP-Werkzeugverhalten164## LSP-Werkzeugverhalten

65 165

66Das LSP-Werkzeug gibt Claude Code-Intelligenz von einem laufenden Sprachserver. Nach jeder Dateiänderung meldet es automatisch Typfehler und Warnungen, damit Claude Probleme ohne einen separaten Build-Schritt beheben kann. Claude kann es auch direkt aufrufen, um Code zu navigieren:166Das LSP-Werkzeug gibt Claude Code-Intelligenz von einem laufenden Sprachserver. Nach jeder Dateiänderung meldet es automatisch Typfehler und Warnungen, damit Claude Probleme ohne einen separaten Build-Schritt beheben kann. Claude kann es auch direkt aufrufen, um Code zu navigieren:

93 193

94Plugins können Monitore deklarieren, die automatisch starten, wenn das Plugin aktiv ist, anstatt Claude zu bitten, sie zu starten. Siehe [Plugin-Monitore](/de/plugins-reference#monitors).194Plugins können Monitore deklarieren, die automatisch starten, wenn das Plugin aktiv ist, anstatt Claude zu bitten, sie zu starten. Siehe [Plugin-Monitore](/de/plugins-reference#monitors).

95 195

196## NotebookEdit-Werkzeugverhalten

197

198NotebookEdit ändert ein Jupyter-Notebook eine Zelle nach der anderen, indem es Zellen nach ihrer `cell_id` anvisiert. Es führt keine Zeichenkettenersetzung über das Notebook durch wie [Edit](#edit-tool-behavior) auf einfachen Dateien.

199

200Drei Bearbeitungsmodi steuern, was mit der Zielzelle geschieht:

201

202* `replace`: Überschreiben Sie die Quelle der Zelle. Dies ist die Standardeinstellung.

203* `insert`: Fügen Sie eine neue Zelle nach der Zielzelle hinzu. Ohne `cell_id` geht die neue Zelle an den Anfang des Notebooks. Erfordert `cell_type` auf `code` oder `markdown` gesetzt.

204* `delete`: Entfernen Sie die Zielzelle.

205

206Berechtigungsregeln verwenden das `Edit(...)`-Pfadformat. Eine Regel wie `Edit(notebooks/**)` deckt NotebookEdit-Aufrufe auf Dateien in diesem Verzeichnis ab.

207

96## PowerShell-Werkzeug208## PowerShell-Werkzeug

97 209

98Das PowerShell-Werkzeug ermöglicht es Claude, PowerShell-Befehle nativ auszuführen. Unter Windows bedeutet dies, dass Befehle in PowerShell ausgeführt werden, anstatt sie über Git Bash zu leiten. Unter Windows ohne Git Bash ist das Werkzeug automatisch aktiviert. Unter Windows mit installiertem Git Bash wird das Werkzeug schrittweise eingeführt. Unter Linux, macOS und WSL ist das Werkzeug optional.210Das PowerShell-Werkzeug ermöglicht es Claude, PowerShell-Befehle nativ auszuführen. Unter Windows bedeutet dies, dass Befehle in PowerShell ausgeführt werden, anstatt sie über Git Bash zu leiten. Unter Windows ohne Git Bash ist das Werkzeug automatisch aktiviert. Unter Windows mit installiertem Git Bash wird das Werkzeug schrittweise eingeführt. Unter Linux, macOS und WSL ist das Werkzeug optional.

130* PowerShell-Profile werden nicht geladen242* PowerShell-Profile werden nicht geladen

131* Unter Windows wird Sandboxing nicht unterstützt243* Unter Windows wird Sandboxing nicht unterstützt

132 244

245## Read-Werkzeugverhalten

246

247Das Read-Werkzeug nimmt einen Dateipfad und gibt den Inhalt mit Zeilennummern zurück. Claude wird angewiesen, immer absolute Pfade zu übergeben.

248

249Standardmäßig gibt Read die Datei vom Anfang zurück. Dateien über einer Größenschwelle geben einen Fehler zurück, anstatt Teilinhalte zu geben, was Claude auffordert, mit `offset` und `limit` erneut zu versuchen, um einen bestimmten Bereich zu lesen.

250

251Read verarbeitet mehrere Dateitypen über einfachen Text hinaus:

252

253* **Bilder**: PNG, JPG und andere Bildformate werden als visueller Inhalt zurückgegeben, den Claude sehen kann, nicht als Rohbytes. Claude Code ändert die Größe großer Bilder und komprimiert sie neu, um sie in die Bildgrößenlimits des Modells zu passen, bevor sie gesendet werden, daher kann Claude eine herunterskalierte Version eines großen Screenshots sehen. Wenn Claude feines Pixel-Level-Detail in einem großen Bild vermisst, bitten Sie es, die Region von Interesse zuerst zuzuschneiden, zum Beispiel mit ImageMagick über Bash.

254* **PDFs**: Claude liest kurze `.pdf`-Dateien ganz. Für PDFs länger als 10 Seiten liest es in Bereichen mit einem `pages`-Parameter wie `"1-5"` bis zu 20 Seiten auf einmal.

255* **Jupyter-Notebooks**: `.ipynb`-Dateien geben alle Zellen mit ihren Ausgaben zurück, einschließlich Code, Markdown und Visualisierungen.

256

257Read liest nur Dateien, keine Verzeichnisse. Claude verwendet `ls` über das Bash-Werkzeug, um Verzeichnisinhalte aufzulisten.

258

259## WebFetch-Werkzeugverhalten

260

261WebFetch nimmt eine URL und eine Eingabeaufforderung, die beschreibt, was extrahiert werden soll. Es ruft die Seite ab, konvertiert die Antwort in Markdown, wenn der Server HTML zurückgibt, und führt die Eingabeaufforderung gegen den Inhalt mit einem kleinen, schnellen Modell aus. Für die meisten Abrufe erhält Claude die Antwort dieses Modells, nicht die Rohseite. Der Konvertierungsschritt ist nicht konfigurierbar.

262

263Dies macht WebFetch absichtlich verlustbehaftet. Die Extraktions-Eingabeaufforderung bestimmt, was Claude erreicht, daher kann ein Ergebnis, das besagt, dass eine Seite etwas nicht erwähnt, nur bedeuten, dass die Eingabeaufforderung nicht danach gefragt hat. Bitten Sie Claude, erneut mit einer spezifischeren Eingabeaufforderung abzurufen, oder verwenden Sie `curl` über Bash für die unverarbeitete Seite.

264

265Einige Verhaltensweisen prägen die Antwort, die Claude erhält:

266

267* HTTP-URLs werden automatisch auf HTTPS aktualisiert.

268* Große Seiten werden auf ein festes Zeichenlimit gekürzt, bevor sie verarbeitet werden.

269* Antworten werden 15 Minuten lang zwischengespeichert, daher geben wiederholte Abrufe derselben URL schnell zurück.

270* Wenn eine URL zu einem anderen Host umleitet, gibt WebFetch ein Textergebnis zurück, das die ursprüngliche URL und das Umleitungsziel benennt, anstatt es zu folgen. Claude ruft dann die neue URL mit einem zweiten WebFetch-Aufruf ab.

271

272In den Standard- und `acceptEdits`-Berechtigungsmodi fordert WebFetch das erste Mal auf, wenn es eine neue Domain erreicht. Um eine Domain im Voraus ohne Aufforderung zuzulassen, fügen Sie eine Berechtigungsregel wie `WebFetch(domain:example.com)` hinzu. Die `auto`- und `bypassPermissions`-[Berechtigungsmodi](/de/permissions#permission-modes) überspringen die Aufforderung vollständig.

273

274WebFetch setzt einen `User-Agent`-Header, der mit `Claude-User` beginnt, und einen `Accept`-Header, der Markdown gegenüber HTML bevorzugt, damit Server, die Content-Negotiation unterstützen, Markdown direkt zurückgeben können. [Sandbox](/de/sandboxing)-Netzwerkregeln werden separat konfiguriert, daher benötigt eine Domain, die ein Sandbox-Prozess erreichen soll, immer noch eine explizite Sandbox-Berechtigungsregel.

275

276## WebSearch-Werkzeugverhalten

277

278WebSearch führt eine Abfrage gegen Anthropics [Web-Suche](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool)-Backend aus und gibt Ergebnistitel und URLs zurück. Es ruft die Ergebnisseiten nicht ab. Um eine Seite zu lesen, die Claude in Suchergebnissen findet, folgt es mit [WebFetch](#webfetch-tool-behavior) auf.

279

280Das Werkzeug kann bis zu acht Backend-Suchen pro Aufruf durchführen und die Suche intern verfeinern, bevor Ergebnisse zurückgegeben werden. Claude kann Ergebnisse mit `allowed_domains` eingrenzen, um nur bestimmte Hosts einzuschließen, oder `blocked_domains`, um sie auszuschließen. Die beiden Listen können nicht in einem einzelnen Aufruf kombiniert werden.

281

282Das Such-Backend ist nicht konfigurierbar. Um mit einem anderen Anbieter zu suchen, fügen Sie einen [MCP-Server](/de/mcp) hinzu, der ein Such-Werkzeug bereitstellt.

283

284WebSearch-Berechtigungsregeln nehmen keinen Specifier. Ein bloßer `WebSearch`-Eintrag in `allow` oder `deny` ist die einzige Form.

285

286<Note>

287 WebSearch ist auf der Claude API und Microsoft Foundry verfügbar. Auf Google Cloud Vertex AI funktioniert es mit Claude 4-Modellen, einschließlich Opus, Sonnet und Haiku. Amazon Bedrock stellt das serverseitige Web-Such-Werkzeug nicht bereit.

288</Note>

289

290## Write-Werkzeugverhalten

291

292Das Write-Werkzeug erstellt eine neue Datei oder überschreibt eine vorhandene mit dem vollständigen bereitgestellten Inhalt. Es fügt nicht an oder führt zusammen.

293

294Wenn der Zielpfad bereits existiert, muss Claude diese Datei mindestens einmal im aktuellen Gespräch gelesen haben, bevor er sie überschreibt. Ein Write zu einer ungelesenen vorhandenen Datei schlägt mit einem Fehler fehl. Diese Einschränkung gilt nicht für neue Dateien.

295

296Das Anzeigen der Datei mit Bash `cat` oder `sed -n` erfüllt auch diese Anforderung, wie in [Edit-Werkzeugverhalten](#edit-tool-behavior) beschrieben.

297

298Für teilweise Änderungen an einer vorhandenen Datei verwendet Claude Edit anstelle von Write.

299

133## Überprüfen Sie, welche Werkzeuge verfügbar sind300## Überprüfen Sie, welche Werkzeuge verfügbar sind

134 301

135Ihr genaues Werkzeugsatz hängt von Ihrem Anbieter, Ihrer Plattform und Ihren Einstellungen ab. Um zu überprüfen, was in einer laufenden Sitzung geladen ist, fragen Sie Claude direkt:302Ihr genaues Werkzeugsatz hängt von Ihrem Anbieter, Ihrer Plattform und Ihren Einstellungen ab. Um zu überprüfen, was in einer laufenden Sitzung geladen ist, fragen Sie Claude direkt:

worktrees.md +161 −0 created

Details

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

5# Parallele Sitzungen mit Worktrees ausführen

7> Isolieren Sie parallele Claude Code-Sitzungen in separaten Git-Worktrees, damit Änderungen nicht kollidieren. Behandelt das Flag `--worktree`, Subagent-Isolation, `.worktreeinclude`, Bereinigung und Non-Git-VCS-Hooks.

9Ein [Git-Worktree](https://git-scm.com/docs/git-worktree) ist ein separates Arbeitsverzeichnis mit eigenen Dateien und Branch, das die gleiche Repository-Historie und Remote wie Ihr Haupt-Checkout teilt. Das Ausführen jeder Claude Code-Sitzung in ihrem eigenen Worktree bedeutet, dass Änderungen in einer Sitzung niemals Dateien in einer anderen berühren, sodass Claude in einem Terminal ein Feature entwickeln kann, während Sie in einem zweiten einen Bug beheben.

11Diese Seite behandelt die Worktree-Isolation in der CLI. Alles unten setzt ein Git-Repository voraus. Für andere Versionskontrollsysteme siehe [Non-Git-Versionskontrolle](#non-git-version-control). Die [Desktop-App](/de/desktop#work-in-parallel-with-sessions) erstellt für jede neue Sitzung automatisch einen Worktree.

13Worktrees sind eine von mehreren Möglichkeiten, Claude parallel auszuführen. Sie isolieren Datei-Änderungen, während [Subagents](/de/sub-agents) und [Agent-Teams](/de/agent-teams) die Arbeit selbst koordinieren. Siehe [Agenten parallel ausführen](/de/agents), um die Ansätze zu vergleichen, oder springen Sie direkt zu [Subagents mit Worktrees isolieren](#isolate-subagents-with-worktrees), um Worktrees und Subagents zusammen zu verwenden.

15## Starten Sie Claude in einem Worktree

17Übergeben Sie `--worktree` oder `-w`, um einen isolierten Worktree zu erstellen und Claude darin zu starten. Standardmäßig wird der Worktree unter `.claude/worktrees/<value>/` in Ihrem Repository-Root erstellt, auf einem neuen Branch namens `worktree-<value>`:

19```bash theme={null}

20claude --worktree feature-auth

21```

23Um Worktrees an anderer Stelle zu platzieren, konfigurieren Sie einen [`WorktreeCreate`-Hook](#non-git-version-control). Führen Sie den Befehl erneut mit einem anderen Namen in einem anderen Terminal aus, um eine zweite isolierte Sitzung zu starten:

25```bash theme={null}

26claude --worktree bugfix-123

27```

29Wenn Sie den Namen weglassen, generiert Claude einen Namen wie `bright-running-fox`:

31```bash theme={null}

32claude --worktree

33```

35Sie können Claude auch während einer Sitzung bitten, „in einem Worktree zu arbeiten", und es wird einen mit dem [`EnterWorktree`](/de/tools-reference)-Tool erstellen.

37Bevor Sie `--worktree` in einem Verzeichnis zum ersten Mal verwenden, akzeptieren Sie den Dialog zum Vertrauen des Arbeitsbereichs, indem Sie `claude` einmal in diesem Verzeichnis ausführen. Wenn das Vertrauen noch nicht akzeptiert wurde, beendet sich `--worktree` mit einem Fehler und fordert Sie auf, zuerst `claude` im Verzeichnis auszuführen, auch wenn es mit `-p` kombiniert wird.

39<Tip>

40 Fügen Sie `.claude/worktrees/` zu Ihrer `.gitignore` hinzu, damit Worktree-Inhalte nicht als nicht verfolgte Dateien in Ihrem Haupt-Checkout angezeigt werden.

41</Tip>

43### Wählen Sie den Basis-Branch

45Worktrees verzweigen sich vom Standard-Branch Ihres Repositories, `origin/HEAD`, sodass sie von einem sauberen Tree starten, der dem Remote entspricht. Wenn kein Remote konfiguriert ist oder der Abruf fehlschlägt, fällt der Worktree auf Ihren aktuellen lokalen `HEAD` zurück. Um immer vom lokalen `HEAD` zu verzweigen, setzen Sie `worktree.baseRef` auf `"head"` in [Einstellungen](/de/settings#worktree-settings). Das Setzen von `baseRef` auf `"head"` führt dazu, dass neue Worktrees Ihre nicht gepushten Commits und den Feature-Branch-Status tragen, was nützlich ist, wenn Sie Subagents isolieren, die an laufenden Arbeiten arbeiten müssen. Die Einstellung akzeptiert nur `"fresh"` oder `"head"`, nicht beliebige Git-Refs:

47```json theme={null}

48{

49 "worktree": {

50 "baseRef": "head"

51 }

52}

53```

55Um von einem bestimmten Pull Request zu verzweigen, übergeben Sie die PR-Nummer mit `#` vorangestellt oder eine vollständige GitHub-Pull-Request-URL. Claude Code ruft `pull/<number>/head` von `origin` ab und erstellt den Worktree unter `.claude/worktrees/pr-<number>`:

57```bash theme={null}

58claude --worktree "#1234"

59```

61Für vollständige Kontrolle über die Erstellung von Worktrees konfigurieren Sie einen [`WorktreeCreate`-Hook](/de/hooks#worktreecreate), der die Standard-`git worktree`-Logik vollständig ersetzt.

63## Kopieren Sie gitignorierte Dateien in Worktrees

65Ein Worktree ist ein frischer Checkout, daher sind nicht verfolgte Dateien wie `.env` oder `.env.local` aus Ihrem Haupt-Repository nicht vorhanden. Um sie automatisch zu kopieren, wenn Claude einen Worktree erstellt, fügen Sie eine `.worktreeinclude`-Datei zu Ihrem Projekt-Root hinzu.

67Die Datei verwendet `.gitignore`-Syntax. Nur Dateien, die einem Muster entsprechen und auch gitignoriert sind, werden kopiert, sodass verfolgte Dateien niemals dupliziert werden.

69Diese `.worktreeinclude` kopiert zwei Env-Dateien und eine Secrets-Konfiguration in jeden neuen Worktree:

71```text .worktreeinclude theme={null}

72.env

73.env.local

74config/secrets.json

75```

77Dies gilt für Worktrees, die mit `--worktree` erstellt werden, [Subagent-Worktrees](#isolate-subagents-with-worktrees) und parallele Sitzungen in der [Desktop-App](/de/desktop#work-in-parallel-with-sessions).

79## Isolieren Sie Subagents mit Worktrees

81Subagents können in ihren eigenen Worktrees ausgeführt werden, sodass parallele Änderungen nicht kollidieren. Bitten Sie Claude, „Worktrees für Ihre Agenten zu verwenden", oder setzen Sie es dauerhaft auf einem [benutzerdefinierten Subagent](/de/sub-agents#supported-frontmatter-fields), indem Sie `isolation: worktree` zum Frontmatter hinzufügen. Jeder Subagent erhält einen temporären Worktree, der automatisch entfernt wird, wenn der Subagent ohne Änderungen beendet wird.

83## Bereinigen Sie Worktrees

85Wenn Sie eine Worktree-Sitzung beenden, hängt die Bereinigung davon ab, ob Sie Änderungen vorgenommen haben:

87* **Keine Änderungen**: Der Worktree und sein Branch werden automatisch entfernt

88* **Änderungen oder Commits vorhanden**: Claude fordert Sie auf, den Worktree zu behalten oder zu entfernen. Das Behalten bewahrt das Verzeichnis und den Branch, sodass Sie später zurückkehren können. Das Entfernen löscht das Worktree-Verzeichnis und seinen Branch und verwirft alle nicht committeten Änderungen und Commits

89* **Nicht-interaktive Ausführungen**: Worktrees, die mit `--worktree` zusammen mit `-p` erstellt werden, werden nicht automatisch bereinigt, da es keine Exit-Eingabeaufforderung gibt. Entfernen Sie sie mit `git worktree remove`

91Subagent-Worktrees, die durch einen Absturz oder unterbrochene Ausführung verwaist sind, werden beim Start entfernt, sobald sie älter als Ihre [`cleanupPeriodDays`](/de/settings#available-settings)-Einstellung sind, sofern sie keine nicht committeten Änderungen, keine nicht verfolgten Dateien und keine nicht gepushten Commits haben. Worktrees, die Sie mit `--worktree` erstellen, werden niemals durch diese Bereinigung entfernt.

93## Verwalten Sie Worktrees manuell

95Für vollständige Kontrolle über den Worktree-Speicherort und die Branch-Konfiguration erstellen Sie Worktrees direkt mit Git. Dies ist nützlich, wenn Sie einen bestimmten vorhandenen Branch auschecken oder den Worktree außerhalb des Repositories platzieren müssen.

97Erstellen Sie einen Worktree auf einem neuen Branch:

99```bash theme={null}

100git worktree add ../project-feature-a -b feature-a

101```

102

103Erstellen Sie einen Worktree aus einem vorhandenen Branch:

104

105```bash theme={null}

106git worktree add ../project-bugfix bugfix-123

107```

108

109Starten Sie Claude im Worktree:

110

111```bash theme={null}

112cd ../project-feature-a && claude

113```

114

115Listen Sie Ihre Worktrees auf:

116

117```bash theme={null}

118git worktree list

119```

120

121Entfernen Sie einen, wenn Sie damit fertig sind:

122

123```bash theme={null}

124git worktree remove ../project-feature-a

125```

126

127Siehe die [Git-Worktree-Dokumentation](https://git-scm.com/docs/git-worktree) für die vollständige Befehlsreferenz. Denken Sie daran, Ihre Entwicklungsumgebung in jedem neuen Worktree zu initialisieren: Installieren Sie Abhängigkeiten, richten Sie virtuelle Umgebungen ein oder führen Sie aus, was die Einrichtung Ihres Projekts erfordert.

128

129## Non-Git-Versionskontrolle

130

131Die Worktree-Isolation verwendet standardmäßig Git. Für SVN, Perforce, Mercurial oder andere Systeme konfigurieren Sie [`WorktreeCreate`- und `WorktreeRemove`-Hooks](/de/hooks#worktreecreate), um benutzerdefinierte Erstellungs- und Bereinigungslogik bereitzustellen. Da der Hook das Standard-Git-Verhalten ersetzt, wird [`.worktreeinclude`](#copy-gitignored-files-into-worktrees) nicht verarbeitet, wenn Sie `--worktree` verwenden. Kopieren Sie stattdessen alle lokalen Konfigurationsdateien in Ihr Hook-Skript.

132

133Dieser `WorktreeCreate`-Hook liest den Worktree-Namen aus stdin, checkt eine frische SVN-Arbeitskopie aus und gibt den Verzeichnispfad aus, damit Claude Code ihn als Arbeitsverzeichnis der Sitzung verwenden kann:

134

135```json theme={null}

136{

137 "hooks": {

138 "WorktreeCreate": [

139 {

140 "hooks": [

141 {

142 "type": "command",

143 "command": "bash -c 'NAME=$(jq -r .name); DIR=\"$HOME/.claude/worktrees/$NAME\"; svn checkout https://svn.example.com/repo/trunk \"$DIR\" >&2 && echo \"$DIR\"'"

144 }

145 ]

146 }

147 ]

148 }

149}

150```

151

152Kombinieren Sie es mit einem `WorktreeRemove`-Hook, um die Bereinigung durchzuführen, wenn die Sitzung endet. Siehe die [Hooks-Referenz](/de/hooks#worktreecreate) für das Eingabeschema und ein Entfernungsbeispiel.

153

154## Siehe auch

155

156Worktrees handhaben die Datei-Isolation. Die verwandten Seiten unten behandeln die Delegierung von Arbeit in diese isolierten Checkouts und das Wechseln zwischen den Sitzungen, die Sie erstellen:

157

158* [Subagents](/de/sub-agents): Delegieren Sie Arbeit an isolierte Agenten innerhalb einer Sitzung

159* [Agent-Teams](/de/agent-teams): Koordinieren Sie mehrere Claude-Sitzungen automatisch

160* [Sitzungen verwalten](/de/sessions): Benennen, fortsetzen und wechseln Sie zwischen Gesprächen

161* [Desktop-Parallelsitzungen](/de/desktop#work-in-parallel-with-sessions): Worktree-gestützte Sitzungen in der Desktop-App

Documentation 2026-05-10 23:03 UTC to 2026-05-11 23:00 UTC