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.

4 

5# Häufige Workflows

6 

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

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).

10 

11## Neue Codebases verstehen

12 

13### Schnelle Codebase-Übersicht erhalten

14 

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

16 

17<Steps>

18 <Step title="Navigieren Sie zum Projektroot-Verzeichnis">

19 ```bash theme={null}

20 cd /path/to/project

21 ```

22 </Step>

23 

24 <Step title="Starten Sie Claude Code">

25 ```bash theme={null}

26 claude

27 ```

28 </Step>

29 

30 <Step title="Fragen Sie nach einer Übersicht auf hoher Ebene">

31 ```text theme={null}

32 give me an overview of this codebase

33 ```

34 </Step>

35 

36 <Step title="Tauchen Sie tiefer in spezifische Komponenten ein">

37 ```text theme={null}

38 explain the main architecture patterns used here

39 ```

40 

41 ```text theme={null}

42 what are the key data models?

43 ```

44 

45 ```text theme={null}

46 how is authentication handled?

47 ```

48 </Step>

49</Steps>

50 

51<Tip>

52 Tipps:

53 

54 * Beginnen Sie mit breiten Fragen und grenzen Sie dann auf spezifische Bereiche ein

55 * Fragen Sie nach Coding-Konventionen und Mustern, die im Projekt verwendet werden

56 * Fordern Sie ein Glossar projektspezifischer Begriffe an

57</Tip>

58 

59### Relevanten Code finden

60 

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

62 

63<Steps>

64 <Step title="Bitten Sie Claude, relevante Dateien zu finden">

65 ```text theme={null}

66 find the files that handle user authentication

67 ```

68 </Step>

69 

70 <Step title="Erhalten Sie Kontext darüber, wie Komponenten zusammenwirken">

71 ```text theme={null}

72 how do these authentication files work together?

73 ```

74 </Step>

75 

76 <Step title="Verstehen Sie den Ausführungsfluss">

77 ```text theme={null}

78 trace the login process from front-end to database

79 ```

80 </Step>

81</Steps>

82 

83<Tip>

84 Tipps:

85 

86 * Seien Sie spezifisch bei dem, was Sie suchen

87 * Verwenden Sie Domänensprache aus dem Projekt

88 * Installieren Sie ein [Code-Intelligence-Plugin](/de/discover-plugins#code-intelligence) für Ihre Sprache, um Claude präzise 'Go to Definition"- und „Find References"-Navigation zu geben

89</Tip>

90 

91***

92 

93## Fehler effizient beheben

94 

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

96 

97<Steps>

98 <Step title="Teilen Sie den Fehler mit Claude">

99 ```text theme={null}

100 I'm seeing an error when I run npm test

101 ```

102 </Step>

103 

104 <Step title="Fragen Sie nach Behebungsempfehlungen">

105 ```text theme={null}

106 suggest a few ways to fix the @ts-ignore in user.ts

107 ```

108 </Step>

109 

110 <Step title="Wenden Sie die Behebung an">

111 ```text theme={null}

112 update user.ts to add the null check you suggested

113 ```

114 </Step>

115</Steps>

116 

117<Tip>

118 Tipps:

119 

120 * Teilen Sie Claude den Befehl mit, um das Problem zu reproduzieren und einen Stack Trace zu erhalten

121 * Erwähnen Sie alle Schritte, um den Fehler zu reproduzieren

122 * Lassen Sie Claude wissen, ob der Fehler intermittierend oder konsistent ist

123</Tip>

124 

125***

126 

127## Code refaktorieren

128 

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

130 

131<Steps>

132 <Step title="Identifizieren Sie Legacy-Code zur Refaktorierung">

133 ```text theme={null}

134 find deprecated API usage in our codebase

135 ```

136 </Step>

137 

138 <Step title="Erhalten Sie Refaktorierungsempfehlungen">

139 ```text theme={null}

140 suggest how to refactor utils.js to use modern JavaScript features

141 ```

142 </Step>

143 

144 <Step title="Wenden Sie die Änderungen sicher an">

145 ```text theme={null}

146 refactor utils.js to use ES2024 features while maintaining the same behavior

147 ```

148 </Step>

149 

150 <Step title="Überprüfen Sie die Refaktorierung">

151 ```text theme={null}

152 run tests for the refactored code

153 ```

154 </Step>

155</Steps>

156 

157<Tip>

158 Tipps:

159 

160 * Bitten Sie Claude, die Vorteile des modernen Ansatzes zu erklären

161 * Fordern Sie an, dass Änderungen die Rückwärtskompatibilität beibehalten, wenn nötig

162 * Führen Sie Refaktorierung in kleinen, testbaren Schritten durch

163</Tip>

164 

165***

166 

167## Spezialisierte Subagents verwenden

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 

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

303 

304<Steps>

305 <Step title="Identifizieren Sie nicht getesteten Code">

306 ```text theme={null}

307 find functions in NotificationsService.swift that are not covered by tests

308 ```

309 </Step>

310 

311 <Step title="Generieren Sie Test-Gerüste">

312 ```text theme={null}

313 add tests for the notification service

314 ```

315 </Step>

316 

317 <Step title="Fügen Sie aussagekräftige Testfälle hinzu">

318 ```text theme={null}

319 add test cases for edge conditions in the notification service

320 ```

321 </Step>

322 

323 <Step title="Führen Sie Tests aus und überprüfen Sie sie">

324 ```text theme={null}

325 run the new tests and fix any failures

326 ```

327 </Step>

328</Steps>

329 

330Claude kann Tests generieren, die den vorhandenen Mustern und Konventionen Ihres Projekts entsprechen. Seien Sie beim Anfordern von Tests spezifisch darüber, welches Verhalten Sie überprüfen möchten. Claude untersucht Ihre vorhandenen Testdateien, um den Stil, die Frameworks und die Assertion-Muster zu entsprechen, die bereits verwendet werden.

331 

332Für umfassende Abdeckung bitten Sie Claude, Grenzfälle zu identifizieren, die Sie möglicherweise übersehen haben. Claude kann Ihre Code-Pfade analysieren und Tests für Fehlerbedingungen, Grenzwerte und unerwartete Eingaben vorschlagen, die leicht zu übersehen sind.

333 

334***

335 

336## Pull Requests erstellen

337 

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:

339 

340<Steps>

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

342 ```text theme={null}

343 summarize the changes I've made to the authentication module

344 ```

345 </Step>

346 

347 <Step title="Generieren Sie einen Pull Request">

348 ```text theme={null}

349 create a pr

350 ```

351 </Step>

352 

353 <Step title="Überprüfen und verfeinern Sie">

354 ```text theme={null}

355 enhance the PR description with more context about the security improvements

356 ```

357 </Step>

358</Steps>

359 

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.

361 

362<Tip>

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

364</Tip>

365 

366## Dokumentation verwalten

367 

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

369 

370<Steps>

371 <Step title="Identifizieren Sie nicht dokumentierten Code">

372 ```text theme={null}

373 find functions without proper JSDoc comments in the auth module

374 ```

375 </Step>

376 

377 <Step title="Generieren Sie Dokumentation">

378 ```text theme={null}

379 add JSDoc comments to the undocumented functions in auth.js

380 ```

381 </Step>

382 

383 <Step title="Überprüfen und verbessern Sie">

384 ```text theme={null}

385 improve the generated documentation with more context and examples

386 ```

387 </Step>

388 

389 <Step title="Überprüfen Sie die Dokumentation">

390 ```text theme={null}

391 check if the documentation follows our project standards

392 ```

393 </Step>

394</Steps>

395 

396<Tip>

397 Tipps:

398 

399 * Geben Sie den Dokumentationsstil an, den Sie möchten (JSDoc, Docstrings usw.)

400 * Fordern Sie Beispiele in der Dokumentation an

401 * Fordern Sie Dokumentation für öffentliche APIs, Schnittstellen und komplexe Logik an

402</Tip>

403 

404***

405 

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

407 

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.

409 

410Das Verzeichnis `.claude/` und `CLAUDE.md` befinden sich neben den Konfigurationsverzeichnissen anderer Tools ohne Konflikte. Claude liest Dateien bei jedem Tool-Aufruf neu, daher sieht es Änderungen, die Sie in einer anderen Anwendung vornehmen, beim nächsten Lesen dieser Datei.

411 

412***

413 

414## Mit Bildern arbeiten

415 

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

417 

418<Steps>

419 <Step title="Fügen Sie ein Bild zum Gespräch hinzu">

420 Sie können eine dieser Methoden verwenden:

421 

422 1. Ziehen Sie ein Bild per Drag & Drop in das Claude Code-Fenster

423 2. Kopieren Sie ein Bild und fügen Sie es in die CLI mit Strg+V ein (verwenden Sie nicht Cmd+V)

424 3. Geben Sie Claude einen Bildpfad an. Z. B. „Analyze this image: /path/to/your/image.png"

425 </Step>

426 

427 <Step title="Bitten Sie Claude, das Bild zu analysieren">

428 ```text theme={null}

429 What does this image show?

430 ```

431 

432 ```text theme={null}

433 Describe the UI elements in this screenshot

434 ```

435 

436 ```text theme={null}

437 Are there any problematic elements in this diagram?

438 ```

439 </Step>

440 

441 <Step title="Verwenden Sie Bilder für Kontext">

442 ```text theme={null}

443 Here's a screenshot of the error. What's causing it?

444 ```

445 

446 ```text theme={null}

447 This is our current database schema. How should we modify it for the new feature?

448 ```

449 </Step>

450 

451 <Step title="Erhalten Sie Code-Vorschläge aus visuellem Inhalt">

452 ```text theme={null}

453 Generate CSS to match this design mockup

454 ```

455 

456 ```text theme={null}

457 What HTML structure would recreate this component?

458 ```

459 </Step>

460</Steps>

461 

462<Tip>

463 Tipps:

464 

465 * Verwenden Sie Bilder, wenn Textbeschreibungen unklar oder umständlich wären

466 * Fügen Sie Screenshots von Fehlern, UI-Designs oder Diagrammen für besseren Kontext ein

467 * Sie können mehrere Bilder in einem Gespräch verwenden

468 * Die Bildanalyse funktioniert mit Diagrammen, Screenshots, Mockups und mehr

469 * Wenn Claude auf Bilder verweist (z. B. `[Image #1]`), `Cmd+Click` (Mac) oder `Ctrl+Click` (Windows/Linux) den Link, um das Bild in Ihrem Standard-Viewer zu öffnen

470</Tip>

471 

472***

473 

474## Dateien und Verzeichnisse referenzieren

475 

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

477 

478<Steps>

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

480 ```text theme={null}

481 Explain the logic in @src/utils/auth.js

482 ```

483 

484 Dies fügt den vollständigen Inhalt der Datei in das Gespräch ein.

485 </Step>

486 

487 <Step title="Referenzieren Sie ein Verzeichnis">

488 ```text theme={null}

489 What's the structure of @src/components?

490 ```

491 

492 Dies bietet eine Verzeichnisauflistung mit Dateiinformationen.

493 </Step>

494 

495 <Step title="Referenzieren Sie MCP-Ressourcen">

496 ```text theme={null}

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

498 ```

499 

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).

501 </Step>

502</Steps>

503 

504<Tip>

505 Tipps:

506 

507 * Dateipfade können relativ oder absolut sein

508 * @ Dateireferenzen fügen `CLAUDE.md` im Verzeichnis der Datei und übergeordneten Verzeichnissen zum Kontext hinzu

509 * Verzeichnisreferenzen zeigen Dateiauflistungen, keine Inhalte

510 * Sie können mehrere Dateien in einer einzelnen Nachricht referenzieren (z. B. „@file1.js and @file2.js")

511</Tip>

512 

513***

514 

515## Verwenden Sie erweitertes Denken (Thinking Mode)

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 

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.

952 

953Wählen Sie eine Planungsoption basierend darauf, wo Sie die Aufgabe ausführen möchten:

954 

955| Option | Wo es ausgeführt wird | Am besten für |

956| :------------------------------------------------------- | :------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

957| [Routines](/de/routines) | Von Anthropic verwaltete Infrastruktur | Aufgaben, die auch dann ausgeführt werden sollten, wenn Ihr Computer ausgeschaltet ist. Können auch durch API-Aufrufe oder GitHub-Ereignisse zusätzlich zu einem Zeitplan ausgelöst werden. Konfigurieren Sie unter [claude.ai/code/routines](https://claude.ai/code/routines). |

958| [Desktop-geplante Aufgaben](/de/desktop-scheduled-tasks) | Ihr Computer, über die Desktop-App | Aufgaben, die direkten Zugriff auf lokale Dateien, Tools oder nicht committete Änderungen benötigen. |

959| [GitHub Actions](/de/github-actions) | Ihre CI-Pipeline | Aufgaben, die an Repository-Ereignisse wie geöffnete PRs gebunden sind, oder Cron-Zeitpläne, die neben Ihrer Workflow-Konfiguration leben sollten. |

960| [`/loop`](/de/scheduled-tasks) | Die aktuelle CLI-Sitzung | Schnelle Abfragen während eine Sitzung offen ist. Aufgaben werden abgebrochen, wenn Sie beenden. |

961 

962<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."

964</Tip>

965 

966***

967 

968## Fragen Sie Claude nach seinen Fähigkeiten

969 

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

971 

972### Beispielfragen

973 

974```text theme={null}

975can Claude Code create pull requests?

976```

977 

978```text theme={null}

979how does Claude Code handle permissions?

980```

981 

982```text theme={null}

983what skills are available?

984```

985 

986```text theme={null}

987how do I use MCP with Claude Code?

988```

989 

990```text theme={null}

991how do I configure Claude Code for Amazon Bedrock?

992```

993 

994```text theme={null}

995what are the limitations of Claude Code?

996```

997 

998<Note>

999 Claude bietet dokumentationsgestützte Antworten auf diese Fragen. Für praktische Demonstrationen führen Sie `/powerup` für interaktive Lektionen mit animierten Demos aus, oder beziehen Sie sich auf die spezifischen Workflow-Abschnitte oben.

1000</Note>

1001 

1002<Tip>

1003 Tipps:

1004 

1005 * Claude hat immer Zugriff auf die neueste Claude Code-Dokumentation, unabhängig von der Version, die Sie verwenden

1006 * Stellen Sie spezifische Fragen, um detaillierte Antworten zu erhalten

1007 * Claude kann komplexe Funktionen wie MCP-Integration, Enterprise-Konfigurationen und erweiterte Workflows erklären

1008</Tip>

1009 

1010***

1011 

1012## Nächste Schritte

1013 

1014<CardGroup cols={2}>

1015 <Card title="Best Practices" icon="lightbulb" href="/de/best-practices">

1016 Muster zum Herausholen des Besten aus Claude Code

1017 </Card>

1018 

1019 <Card title="Wie Claude Code funktioniert" icon="gear" href="/de/how-claude-code-works">

1020 Verstehen Sie die agentic Loop und Kontextverwaltung

1021 </Card>

1022 

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

1024 Fügen Sie Skills, Hooks, MCP, Subagents und Plugins hinzu

1025 </Card>

1026 

1027 <Card title="Referenzimplementierung" icon="code" href="https://github.com/anthropics/claude-code/tree/main/.devcontainer">

1028 Klonen Sie die Referenzimplementierung des Development Containers

1029 </Card>

1030</CardGroup>