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# Flux de travail courants

6 

7> Guides étape par étape pour explorer les bases de code, corriger les bogues, refactoriser, tester et autres tâches quotidiennes avec Claude Code.

8 

9Cette page couvre les flux de travail pratiques pour le développement quotidien : explorer du code inconnu, déboguer, refactoriser, écrire des tests, créer des PR et gérer les sessions. Chaque section inclut des exemples de prompts que vous pouvez adapter à vos propres projets. Pour des modèles et des conseils de plus haut niveau, consultez [Bonnes pratiques](/fr/best-practices).

10 

11## Comprendre les nouvelles bases de code

12 

13### Obtenir un aperçu rapide de la base de code

14 

15Supposons que vous venez de rejoindre un nouveau projet et que vous devez comprendre rapidement sa structure.

16 

17<Steps>

18 <Step title="Accédez au répertoire racine du projet">

19 ```bash theme={null}

20 cd /path/to/project

21 ```

22 </Step>

23 

24 <Step title="Démarrez Claude Code">

25 ```bash theme={null}

26 claude

27 ```

28 </Step>

29 

30 <Step title="Demandez un aperçu de haut niveau">

31 ```text theme={null}

32 give me an overview of this codebase

33 ```

34 </Step>

35 

36 <Step title="Approfondissez les composants spécifiques">

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 Conseils :

53 

54 * Commencez par des questions larges, puis réduisez à des domaines spécifiques

55 * Posez des questions sur les conventions de codage et les modèles utilisés dans le projet

56 * Demandez un glossaire des termes spécifiques au projet

57</Tip>

58 

59### Trouver du code pertinent

60 

61Supposons que vous ayez besoin de localiser du code lié à une fonctionnalité ou une capacité spécifique.

62 

63<Steps>

64 <Step title="Demandez à Claude de trouver les fichiers pertinents">

65 ```text theme={null}

66 find the files that handle user authentication

67 ```

68 </Step>

69 

70 <Step title="Obtenez du contexte sur la façon dont les composants interagissent">

71 ```text theme={null}

72 how do these authentication files work together?

73 ```

74 </Step>

75 

76 <Step title="Comprenez le flux d'exécution">

77 ```text theme={null}

78 trace the login process from front-end to database

79 ```

80 </Step>

81</Steps>

82 

83<Tip>

84 Conseils :

85 

86 * Soyez spécifique sur ce que vous recherchez

87 * Utilisez le langage du domaine du projet

88 * Installez un [plugin d'intelligence de code](/fr/discover-plugins#code-intelligence) pour votre langage afin de donner à Claude une navigation précise ' aller à la définition ' et ' trouver les références '

89</Tip>

90 

91***

92 

93## Corriger les bogues efficacement

94 

95Supposons que vous ayez rencontré un message d'erreur et que vous ayez besoin de trouver et de corriger sa source.

96 

97<Steps>

98 <Step title="Partagez l'erreur avec Claude">

99 ```text theme={null}

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

101 ```

102 </Step>

103 

104 <Step title="Demandez des recommandations de correction">

105 ```text theme={null}

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

107 ```

108 </Step>

109 

110 <Step title="Appliquez la correction">

111 ```text theme={null}

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

113 ```

114 </Step>

115</Steps>

116 

117<Tip>

118 Conseils :

119 

120 * Dites à Claude la commande pour reproduire le problème et obtenir une trace de pile

121 * Mentionnez les étapes pour reproduire l'erreur

122 * Faites savoir à Claude si l'erreur est intermittente ou cohérente

123</Tip>

124 

125***

126 

127## Refactoriser le code

128 

129Supposons que vous ayez besoin de mettre à jour du code ancien pour utiliser des modèles et des pratiques modernes.

130 

131<Steps>

132 <Step title="Identifiez le code hérité pour la refactorisation">

133 ```text theme={null}

134 find deprecated API usage in our codebase

135 ```

136 </Step>

137 

138 <Step title="Obtenez des recommandations de refactorisation">

139 ```text theme={null}

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

141 ```

142 </Step>

143 

144 <Step title="Appliquez les modifications en toute sécurité">

145 ```text theme={null}

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

147 ```

148 </Step>

149 

150 <Step title="Vérifiez la refactorisation">

151 ```text theme={null}

152 run tests for the refactored code

153 ```

154 </Step>

155</Steps>

156 

157<Tip>

158 Conseils :

159 

160 * Demandez à Claude d'expliquer les avantages de l'approche moderne

161 * Demandez que les modifications maintiennent la compatibilité rétroactive si nécessaire

162 * Effectuez la refactorisation par petits incréments testables

163</Tip>

164 

165***

166 

167## Utiliser des subagents spécialisés

168 

169Supposons que vous souhaitiez utiliser des subagents IA spécialisés pour gérer des tâches spécifiques plus efficacement.

170 

171<Steps>

172 <Step title="Afficher les subagents disponibles">

173 ```text theme={null}

174 /agents

175 ```

176 

177 Cela affiche tous les subagents disponibles et vous permet d'en créer de nouveaux.

178 </Step>

179 

180 <Step title="Utiliser les subagents automatiquement">

181 Claude Code délègue automatiquement les tâches appropriées aux subagents spécialisés :

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="Demander explicitement des subagents spécifiques">

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="Créer des subagents personnalisés pour votre flux de travail">

203 ```text theme={null}

204 /agents

205 ```

206 

207 Sélectionnez ensuite « Créer un nouveau subagent » et suivez les invites pour définir :

208 

209 * Un identifiant unique qui décrit l'objectif du subagent (par exemple, `code-reviewer`, `api-designer`).

210 * Quand Claude doit utiliser cet agent

211 * Quels outils il peut accéder

212 * Une invite système décrivant le rôle et le comportement de l'agent

213 </Step>

214</Steps>

215 

216<Tip>

217 Conseils :

218 

219 * Créez des subagents spécifiques au projet dans `.claude/agents/` pour le partage en équipe

220 * Utilisez des champs `description` descriptifs pour activer la délégation automatique

221 * Limitez l'accès aux outils à ce dont chaque subagent a réellement besoin

222 * Consultez la [documentation des subagents](/fr/sub-agents) pour des exemples détaillés

223</Tip>

224 

225***

226 

227## Utiliser le Plan Mode pour une analyse de code sûre

228 

229Plan Mode demande à Claude de créer un plan en analysant la base de code avec des opérations en lecture seule, parfait pour explorer les bases de code, planifier des modifications complexes ou examiner le code en toute sécurité. En Plan Mode, Claude utilise [`AskUserQuestion`](/fr/tools-reference) pour recueillir les exigences et clarifier vos objectifs avant de proposer un plan.

230 

231### Quand utiliser Plan Mode

232 

233* **Implémentation multi-étapes** : Quand votre fonctionnalité nécessite de faire des modifications à de nombreux fichiers

234* **Exploration de code** : Quand vous souhaitez rechercher la base de code en profondeur avant de modifier quoi que ce soit

235* **Développement interactif** : Quand vous souhaitez itérer sur la direction avec Claude

236 

237### Comment utiliser Plan Mode

238 

239**Activez Plan Mode pendant une session**

240 

241Vous pouvez basculer en Plan Mode pendant une session en utilisant **Maj+Tab** pour parcourir les modes de permission.

242 

243Si vous êtes en Mode Normal, **Maj+Tab** bascule d'abord en Mode Auto-Accept, indiqué par `⏵⏵ accept edits on` en bas du terminal. Un **Maj+Tab** ultérieur basculera en Plan Mode, indiqué par `⏸ plan mode on`.

244 

245**Démarrez une nouvelle session en Plan Mode**

246 

247Pour démarrer une nouvelle session en Plan Mode, utilisez le drapeau `--permission-mode plan` :

248 

249```bash theme={null}

250claude --permission-mode plan

251```

252 

253**Exécutez des requêtes « headless » en Plan Mode**

254 

255Vous pouvez également exécuter une requête en Plan Mode directement avec `-p` (c'est-à-dire en [« mode headless »](/fr/headless)) :

256 

257```bash theme={null}

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

259```

260 

261### Exemple : Planifier une refactorisation complexe

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 analyse l'implémentation actuelle et crée un plan complet. Affinez avec des suites :

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>Appuyez sur `Ctrl+G` pour ouvrir le plan dans votre éditeur de texte par défaut, où vous pouvez le modifier directement avant que Claude ne procède.</Tip>

282 

283Lorsque vous acceptez un plan, Claude nomme automatiquement la session à partir du contenu du plan. Le nom apparaît sur la barre de prompt et dans le sélecteur de session. Si vous avez déjà défini un nom avec `--name` ou `/rename`, accepter un plan ne le remplacera pas.

284 

285### Configurer Plan Mode par défaut

286 

287```json theme={null}

288// .claude/settings.json

289{

290 "permissions": {

291 "defaultMode": "plan"

292 }

293}

294```

295 

296Consultez la [documentation des paramètres](/fr/settings#available-settings) pour plus d'options de configuration.

297 

298***

299 

300## Travailler avec les tests

301 

302Supposons que vous ayez besoin d'ajouter des tests pour du code non couvert.

303 

304<Steps>

305 <Step title="Identifiez le code non testé">

306 ```text theme={null}

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

308 ```

309 </Step>

310 

311 <Step title="Générez l'échafaudage des tests">

312 ```text theme={null}

313 add tests for the notification service

314 ```

315 </Step>

316 

317 <Step title="Ajoutez des cas de test significatifs">

318 ```text theme={null}

319 add test cases for edge conditions in the notification service

320 ```

321 </Step>

322 

323 <Step title="Exécutez et vérifiez les tests">

324 ```text theme={null}

325 run the new tests and fix any failures

326 ```

327 </Step>

328</Steps>

329 

330Claude peut générer des tests qui suivent les modèles et conventions existants de votre projet. Lorsque vous demandez des tests, soyez spécifique sur le comportement que vous souhaitez vérifier. Claude examine vos fichiers de test existants pour correspondre au style, aux frameworks et aux modèles d'assertion déjà en usage.

331 

332Pour une couverture complète, demandez à Claude d'identifier les cas limites que vous auriez pu manquer. Claude peut analyser vos chemins de code et suggérer des tests pour les conditions d'erreur, les valeurs limites et les entrées inattendues qui sont faciles à oublier.

333 

334***

335 

336## Créer des demandes de tirage

337 

338Vous pouvez créer des demandes de tirage en demandant directement à Claude (« créer une pr pour mes modifications »), ou guider Claude à travers cela étape par étape :

339 

340<Steps>

341 <Step title="Résumez vos modifications">

342 ```text theme={null}

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

344 ```

345 </Step>

346 

347 <Step title="Générez une demande de tirage">

348 ```text theme={null}

349 create a pr

350 ```

351 </Step>

352 

353 <Step title="Examinez et affinez">

354 ```text theme={null}

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

356 ```

357 </Step>

358</Steps>

359 

360Lorsque vous créez une PR en utilisant `gh pr create`, la session est automatiquement liée à cette PR. Vous pouvez la reprendre plus tard avec `claude --from-pr <number>`.

361 

362<Tip>

363 Examinez la PR générée par Claude avant de la soumettre et demandez à Claude de mettre en évidence les risques ou considérations potentiels.

364</Tip>

365 

366## Gérer la documentation

367 

368Supposons que vous ayez besoin d'ajouter ou de mettre à jour la documentation de votre code.

369 

370<Steps>

371 <Step title="Identifiez le code non documenté">

372 ```text theme={null}

373 find functions without proper JSDoc comments in the auth module

374 ```

375 </Step>

376 

377 <Step title="Générez la documentation">

378 ```text theme={null}

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

380 ```

381 </Step>

382 

383 <Step title="Examinez et améliorez">

384 ```text theme={null}

385 improve the generated documentation with more context and examples

386 ```

387 </Step>

388 

389 <Step title="Vérifiez la documentation">

390 ```text theme={null}

391 check if the documentation follows our project standards

392 ```

393 </Step>

394</Steps>

395 

396<Tip>

397 Conseils :

398 

399 * Spécifiez le style de documentation que vous souhaitez (JSDoc, docstrings, etc.)

400 * Demandez des exemples dans la documentation

401 * Demandez la documentation pour les API publiques, les interfaces et la logique complexe

402</Tip>

403 

404***

405 

406## Travailler dans les notes et les dossiers non-code

407 

408Claude Code fonctionne dans n'importe quel répertoire. Exécutez-le à l'intérieur d'un coffre-fort de notes, d'un dossier de documentation ou de toute collection de fichiers markdown pour rechercher, modifier et réorganiser le contenu de la même manière que vous le feriez pour du code.

409 

410Le répertoire `.claude/` et `CLAUDE.md` se trouvent aux côtés des répertoires de configuration d'autres outils sans conflit. Claude lit les fichiers à nouveau à chaque appel d'outil, il voit donc les modifications que vous apportez dans une autre application la prochaine fois qu'il lit ce fichier.

411 

412***

413 

414## Travailler avec les images

415 

416Supposons que vous ayez besoin de travailler avec des images dans votre base de code et que vous souhaitiez l'aide de Claude pour analyser le contenu des images.

417 

418<Steps>

419 <Step title="Ajoutez une image à la conversation">

420 Vous pouvez utiliser l'une de ces méthodes :

421 

422 1. Glissez-déposez une image dans la fenêtre Claude Code

423 2. Copiez une image et collez-la dans l'interface CLI avec ctrl+v (N'utilisez pas cmd+v)

424 3. Fournissez un chemin d'image à Claude. Par exemple, « Analyser cette image : /path/to/your/image.png »

425 </Step>

426 

427 <Step title="Demandez à Claude d'analyser l'image">

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="Utilisez les images pour le contexte">

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="Obtenez des suggestions de code à partir du contenu visuel">

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 Conseils :

464 

465 * Utilisez les images quand les descriptions textuelles seraient peu claires ou fastidieuses

466 * Incluez des captures d'écran d'erreurs, de conceptions d'interface utilisateur ou de diagrammes pour un meilleur contexte

467 * Vous pouvez travailler avec plusieurs images dans une conversation

468 * L'analyse d'images fonctionne avec les diagrammes, les captures d'écran, les maquettes et bien d'autres

469 * Quand Claude référence des images (par exemple, `[Image #1]`), `Cmd+Click` (Mac) ou `Ctrl+Click` (Windows/Linux) le lien pour ouvrir l'image dans votre visionneuse par défaut

470</Tip>

471 

472***

473 

474## Référencer les fichiers et répertoires

475 

476Utilisez @ pour inclure rapidement des fichiers ou des répertoires sans attendre que Claude les lise.

477 

478<Steps>

479 <Step title="Référencez un seul fichier">

480 ```text theme={null}

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

482 ```

483 

484 Cela inclut le contenu complet du fichier dans la conversation.

485 </Step>

486 

487 <Step title="Référencez un répertoire">

488 ```text theme={null}

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

490 ```

491 

492 Cela fournit une liste de répertoires avec les informations de fichier.

493 </Step>

494 

495 <Step title="Référencez les ressources MCP">

496 ```text theme={null}

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

498 ```

499 

500 Cela récupère les données des serveurs MCP connectés en utilisant le format @server:resource. Consultez [Ressources MCP](/fr/mcp#use-mcp-resources) pour plus de détails.

501 </Step>

502</Steps>

503 

504<Tip>

505 Conseils :

506 

507 * Les chemins de fichiers peuvent être relatifs ou absolus

508 * Les références de fichiers @ ajoutent `CLAUDE.md` dans le répertoire du fichier et les répertoires parents au contexte

509 * Les références de répertoires affichent les listes de fichiers, pas les contenus

510 * Vous pouvez référencer plusieurs fichiers dans un seul message (par exemple, « @file1.js et @file2.js »)

511</Tip>

512 

513***

514 

515## Utiliser la réflexion étendue (mode de réflexion)

516 

517[La réflexion étendue](https://platform.claude.com/docs/fr/build-with-claude/extended-thinking) est activée par défaut, donnant à Claude l'espace pour raisonner à travers des problèmes complexes étape par étape avant de répondre. Ce raisonnement est visible en mode verbeux, que vous pouvez activer avec `Ctrl+O`. Pendant la réflexion étendue, l'indicateur de progression affiche des indices de progression en ligne tels que « still thinking » et « almost done thinking » pour indiquer que Claude travaille activement.

518 

519De plus, les [modèles qui prennent en charge l'effort](/fr/model-config#adjust-effort-level) utilisent le raisonnement adaptatif : au lieu d'un budget de jetons de réflexion fixe, le modèle décide dynamiquement s'il faut penser et combien en fonction de votre paramètre de niveau d'effort et de la tâche à accomplir. Le raisonnement adaptatif permet à Claude de répondre plus rapidement aux prompts de routine et de réserver une réflexion plus profonde pour les étapes qui en bénéficient.

520 

521La réflexion étendue est particulièrement précieuse pour les décisions architecturales complexes, les bogues difficiles, la planification de l'implémentation multi-étapes et l'évaluation des compromis entre différentes approches.

522 

523<Note>

524 Les phrases comme « think », « think hard » et « think more » sont interprétées comme des instructions de prompt régulières et n'allouent pas de jetons de réflexion.

525</Note>

526 

527### Configurer le mode de réflexion

528 

529La réflexion est activée par défaut, mais vous pouvez l'ajuster ou la désactiver.

530 

531| Portée | Comment configurer | Détails |

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

533| **Niveau d'effort** | Exécutez `/effort`, ajustez dans `/model`, ou définissez [`CLAUDE_CODE_EFFORT_LEVEL`](/fr/env-vars) | Contrôlez la profondeur de la réflexion sur les [modèles pris en charge](/fr/model-config#adjust-effort-level) |

534| **Mot-clé `ultrathink`** | Incluez « ultrathink » n'importe où dans votre prompt | Ajoute une instruction en contexte indiquant au modèle de raisonner davantage sur ce tour. Ne change pas le niveau d'effort lui-même ; consultez [Ajuster le niveau d'effort](/fr/model-config#adjust-effort-level) pour cela |

535| **Raccourci de basculement** | Appuyez sur `Option+T` (macOS) ou `Alt+T` (Windows/Linux) | Basculez la réflexion activée/désactivée pour la session actuelle (tous les modèles). Peut nécessiter une [configuration du terminal](/fr/terminal-config) pour activer les raccourcis de la touche Option |

536| **Défaut global** | Utilisez `/config` pour basculer le mode de réflexion | Définit votre défaut sur tous les projets (tous les modèles).<br />Enregistré comme `alwaysThinkingEnabled` dans `~/.claude/settings.json` |

537| **Limiter le budget de jetons** | Définissez la variable d'environnement [`MAX_THINKING_TOKENS`](/fr/env-vars) | Limitez le budget de réflexion à un nombre spécifique de jetons. Sur les modèles avec raisonnement adaptatif, seul `0` s'applique sauf si le raisonnement adaptatif est désactivé. Exemple : `export MAX_THINKING_TOKENS=10000` |

538 

539Pour afficher le processus de réflexion de Claude, appuyez sur `Ctrl+O` pour basculer le mode verbeux et voir le raisonnement interne affiché en texte gris italique.

540 

541### Comment fonctionne la réflexion étendue

542 

543La réflexion étendue contrôle la quantité de raisonnement interne que Claude effectue avant de répondre. Plus de réflexion fournit plus d'espace pour explorer les solutions, analyser les cas limites et corriger les erreurs.

544 

545Sur les [modèles qui prennent en charge l'effort](/fr/model-config#adjust-effort-level), la réflexion utilise le raisonnement adaptatif : le modèle alloue dynamiquement les jetons de réflexion en fonction du niveau d'effort que vous sélectionnez. C'est la façon recommandée d'ajuster le compromis entre la vitesse et la profondeur du raisonnement. Si vous souhaitez que Claude pense plus ou moins souvent que votre niveau d'effort ne le produirait autrement, vous pouvez également le dire directement dans votre prompt ou dans `CLAUDE.md`.

546 

547Avec les modèles plus anciens, la réflexion utilise un budget fixe de jetons tiré de votre allocation de sortie. Le budget varie selon le modèle ; consultez [`MAX_THINKING_TOKENS`](/fr/env-vars) pour les plafonds par modèle. Vous pouvez limiter le budget avec cette variable d'environnement, ou désactiver complètement la réflexion via `/config` ou le basculement `Option+T`/`Alt+T`.

548 

549Sur les modèles avec raisonnement adaptatif, `MAX_THINKING_TOKENS` ne s'applique que lorsqu'il est défini à `0` pour désactiver la réflexion, ou lorsque `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1` revient à ces modèles au budget fixe. `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` s'applique à Opus 4.6 et Sonnet 4.6 uniquement. Opus 4.7 utilise toujours le raisonnement adaptatif et ne prend pas en charge un budget de réflexion fixe. Consultez [variables d'environnement](/fr/env-vars).

550 

551<Warning>

552 Vous êtes facturé pour tous les jetons de réflexion utilisés, même si les résumés de réflexion sont redactés. En mode interactif, la réflexion apparaît comme un stub réduit par défaut. Définissez `showThinkingSummaries: true` dans `settings.json` pour afficher les résumés complets.

553</Warning>

554 

555***

556 

557## Reprendre les conversations précédentes

558 

559Lors du démarrage de Claude Code, vous pouvez reprendre une session précédente :

560 

561* `claude --continue` continue la conversation la plus récente dans le répertoire actuel

562* `claude --resume` ouvre un sélecteur de conversation ou reprend par nom

563* `claude --from-pr 123` reprend les sessions liées à une demande de tirage spécifique

564 

565À partir d'une session active, utilisez `/resume` pour basculer vers une conversation différente.

566 

567Lorsque la session sélectionnée est ancienne et suffisamment volumineuse pour que sa relecture consommerait une part substantielle de vos limites d'utilisation, `--resume`, `--continue` et `/resume` proposent de reprendre à partir d'un résumé au lieu de charger la transcription complète. Cette invite n'est pas disponible sur Amazon Bedrock, Google Cloud Vertex AI ou Microsoft Foundry.

568 

569Les sessions sont stockées par répertoire de projet. Par défaut, le sélecteur `/resume` affiche les sessions interactives du worktree actuel, avec des raccourcis clavier pour élargir la liste à d'autres worktrees ou projets, rechercher, prévisualiser et renommer. Consultez [Utiliser le sélecteur de session](#use-the-session-picker) ci-dessous pour la référence complète des raccourcis.

570 

571Lorsque vous sélectionnez une session à partir d'un autre worktree du même référentiel, Claude Code la reprend directement sans vous obliger à d'abord basculer les répertoires. La sélection d'une session à partir d'un projet non lié copie une commande `cd` et de reprise dans votre presse-papiers à la place.

572 

573La reprise par nom se résout dans le référentiel actuel et ses worktrees. À la fois `claude --resume <name>` et `/resume <name>` recherchent une correspondance exacte et la reprennent directement, même si la session se trouve dans un worktree différent.

574 

575Lorsque le nom est ambigu, `claude --resume <name>` ouvre le sélecteur avec le nom pré-rempli comme terme de recherche. `/resume <name>` à partir d'une session signale une erreur à la place, donc exécutez `/resume` sans argument pour ouvrir le sélecteur et choisir.

576 

577Les sessions créées par `claude -p` ou les invocations SDK n'apparaissent pas dans le sélecteur, mais vous pouvez toujours en reprendre une en passant son ID de session directement à `claude --resume <session-id>`.

578 

579### Nommez vos sessions

580 

581Donnez aux sessions des noms descriptifs pour les trouver plus tard. C'est une bonne pratique lorsque vous travaillez sur plusieurs tâches ou fonctionnalités.

582 

583<Steps>

584 <Step title="Nommez la session">

585 Nommez une session au démarrage avec `-n` :

586 

587 ```bash theme={null}

588 claude -n auth-refactor

589 ```

590 

591 Ou utilisez `/rename` pendant une session, qui affiche également le nom sur la barre de prompt :

592 

593 ```text theme={null}

594 /rename auth-refactor

595 ```

596 

597 Vous pouvez également renommer n'importe quelle session à partir du sélecteur : exécutez `/resume`, accédez à une session et appuyez sur `Ctrl+R`.

598 </Step>

599 

600 <Step title="Reprenez par nom plus tard">

601 À partir de la ligne de commande :

602 

603 ```bash theme={null}

604 claude --resume auth-refactor

605 ```

606 

607 Ou à partir d'une session active :

608 

609 ```text theme={null}

610 /resume auth-refactor

611 ```

612 </Step>

613</Steps>

614 

615### Utilisez le sélecteur de session

616 

617La commande `/resume` (ou `claude --resume` sans arguments) ouvre un sélecteur de session interactif avec ces fonctionnalités :

618 

619**Raccourcis clavier dans le sélecteur :**

620 

621| Raccourci | Action |

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

623| `↑` / `↓` | Naviguer entre les sessions |

624| `→` / `←` | Développer ou réduire les sessions groupées |

625| `Entrée` | Sélectionner et reprendre la session en surbrillance |

626| `Espace` | Aperçu du contenu de la session. `Ctrl+V` fonctionne également sur les terminaux qui ne le capturent pas comme collage |

627| `Ctrl+R` | Renommer la session en surbrillance |

628| `/` ou tout caractère imprimable autre que `Espace` | Entrer en mode de recherche et filtrer les sessions |

629| `Ctrl+A` | Afficher les sessions de tous les projets sur cette machine. Appuyez à nouveau pour restaurer le référentiel actuel |

630| `Ctrl+W` | Afficher les sessions de tous les worktrees du référentiel actuel. Appuyez à nouveau pour restaurer le worktree actuel. Affiché uniquement dans les référentiels multi-worktrees |

631| `Ctrl+B` | Filtrer les sessions de votre branche git actuelle. Appuyez à nouveau pour afficher les sessions de toutes les branches |

632| `Échap` | Quitter le sélecteur ou le mode de recherche |

633 

634**Organisation des sessions :**

635 

636Le sélecteur affiche les sessions avec des métadonnées utiles :

637 

638* Nom de la session s'il est défini, sinon le résumé de la conversation ou le premier prompt utilisateur

639* Temps écoulé depuis la dernière activité

640* Nombre de messages

641* Branche Git (le cas échéant)

642* Chemin du projet, affiché après élargissement à tous les projets avec `Ctrl+A`

643 

644Les sessions bifurquées (créées avec `/branch`, `/rewind` ou `--fork-session`) sont groupées ensemble sous leur session racine, ce qui facilite la recherche de conversations connexes.

645 

646<Tip>

647 Conseils :

648 

649 * **Nommez les sessions tôt** : Utilisez `/rename` au démarrage du travail sur une tâche distincte — il est beaucoup plus facile de trouver « payment-integration » que « explain this function » plus tard

650 * Utilisez `--continue` pour un accès rapide à votre conversation la plus récente dans le répertoire actuel

651 * Utilisez `--resume session-name` quand vous savez quelle session vous avez besoin

652 * Utilisez `--resume` (sans nom) quand vous avez besoin de parcourir et de sélectionner

653 * Pour les scripts, utilisez `claude --continue --print "prompt"` pour reprendre en mode non interactif

654 * Appuyez sur `Espace` dans le sélecteur pour prévisualiser une session avant de la reprendre

655 * La conversation reprise démarre avec le même modèle et la même configuration que l'original

656 

657 Comment cela fonctionne :

658 

659 1. **Stockage des conversations** : Toutes les conversations sont automatiquement enregistrées localement avec leur historique complet des messages

660 2. **Désérialisation des messages** : Lors de la reprise, l'historique complet des messages est restauré pour maintenir le contexte

661 3. **État des outils** : L'utilisation des outils et les résultats de la conversation précédente sont préservés

662 4. **Restauration du contexte** : La conversation reprend avec tout le contexte précédent intact

663</Tip>

664 

665***

666 

667## Exécuter des sessions Claude Code parallèles avec Git worktrees

668 

669Lorsque vous travaillez sur plusieurs tâches à la fois, vous avez besoin que chaque session Claude ait sa propre copie de la base de code afin que les modifications ne se heurtent pas. Les worktrees Git résolvent ce problème en créant des répertoires de travail séparés qui ont chacun leurs propres fichiers et branche, tout en partageant le même historique de référentiel et les mêmes connexions distantes. Cela signifie que vous pouvez avoir Claude travaillant sur une fonctionnalité dans un worktree tout en corrigeant un bogue dans un autre, sans que l'une ou l'autre session n'interfère avec l'autre.

670 

671Utilisez le drapeau `--worktree` (`-w`) pour créer un worktree isolé et démarrer Claude dedans. La valeur que vous transmettez devient le nom du répertoire worktree et le nom de la branche :

672 

673```bash theme={null}

674# Démarrez Claude dans un worktree nommé « feature-auth »

675# Crée .claude/worktrees/feature-auth/ avec une nouvelle branche

676claude --worktree feature-auth

677 

678# Démarrez une autre session dans un worktree séparé

679claude --worktree bugfix-123

680```

681 

682Si vous omettez le nom, Claude en génère un automatiquement :

683 

684```bash theme={null}

685# Génère automatiquement un nom comme « bright-running-fox »

686claude --worktree

687```

688 

689Les worktrees sont créés à `<repo>/.claude/worktrees/<name>` et se ramifient à partir de la branche distante par défaut, qui est celle vers laquelle `origin/HEAD` pointe. La branche worktree est nommée `worktree-<name>`.

690 

691La branche de base n'est pas configurable via un drapeau ou un paramètre Claude Code. `origin/HEAD` est une référence stockée dans votre répertoire `.git` local que Git a définie une fois lorsque vous avez cloné. Si la branche par défaut du référentiel change plus tard sur GitHub ou GitLab, votre `origin/HEAD` local continue de pointer vers l'ancienne, et les worktrees se ramifieront à partir de là. Pour resynchroniser votre référence locale avec ce que le distant considère actuellement comme son défaut :

692 

693```bash theme={null}

694git remote set-head origin -a

695```

696 

697C'est une commande Git standard qui met à jour uniquement votre répertoire `.git` local. Rien sur le serveur distant ne change. Si vous souhaitez que les worktrees se basent sur une branche spécifique plutôt que sur le défaut du distant, définissez-le explicitement avec `git remote set-head origin your-branch-name`.

698 

699Pour un contrôle total sur la façon dont les worktrees sont créés, y compris le choix d'une base différente par invocation, configurez un hook [WorktreeCreate](/fr/hooks#worktreecreate). Le hook remplace complètement la logique `git worktree` par défaut de Claude Code, afin que vous puissiez récupérer et vous ramifier à partir de la ref dont vous avez besoin.

700 

701Vous pouvez également demander à Claude de « travailler dans un worktree » ou « démarrer un worktree » pendant une session, et il en créera un automatiquement.

702 

703### Worktrees des subagents

704 

705Les subagents peuvent également utiliser l'isolation worktree pour travailler en parallèle sans conflits. Demandez à Claude d'« utiliser les worktrees pour vos agents » ou configurez-le dans un [subagent personnalisé](/fr/sub-agents#supported-frontmatter-fields) en ajoutant `isolation: worktree` au frontmatter de l'agent. Chaque subagent obtient son propre worktree qui est automatiquement nettoyé quand le subagent se termine sans modifications.

706 

707### Nettoyage des worktrees

708 

709Lorsque vous quittez une session worktree, Claude gère le nettoyage en fonction de si vous avez apporté des modifications :

710 

711* **Pas de modifications** : le worktree et sa branche sont supprimés automatiquement

712* **Les modifications ou les commits existent** : Claude vous demande de conserver ou de supprimer le worktree. La conservation préserve le répertoire et la branche afin que vous puissiez revenir plus tard. La suppression supprime le répertoire worktree et sa branche, en supprimant toutes les modifications non validées et les commits

713 

714Les worktrees des subagents orphelins causés par un crash ou une exécution parallèle interrompue sont supprimés automatiquement au démarrage une fois qu'ils sont plus anciens que votre paramètre [`cleanupPeriodDays`](/fr/settings#available-settings), à condition qu'ils n'aient pas de modifications non validées, pas de fichiers non suivis et pas de commits non poussés. Les worktrees que vous créez avec `--worktree` ne sont jamais supprimés par ce balayage.

715 

716Pour nettoyer les worktrees en dehors d'une session Claude, utilisez la [gestion manuelle des worktrees](#manage-worktrees-manually).

717 

718<Tip>

719 Ajoutez `.claude/worktrees/` à votre `.gitignore` pour empêcher le contenu des worktrees d'apparaître comme des fichiers non suivis dans votre référentiel principal.

720</Tip>

721 

722### Copier les fichiers ignorés par git vers les worktrees

723 

724Les worktrees Git sont des checkouts frais, donc ils n'incluent pas les fichiers non suivis comme `.env` ou `.env.local` de votre référentiel principal. Pour copier automatiquement ces fichiers lorsque Claude crée un worktree, ajoutez un fichier `.worktreeinclude` à la racine de votre projet.

725 

726Le fichier utilise la syntaxe `.gitignore` pour lister les fichiers à copier. Seuls les fichiers qui correspondent à un modèle et qui sont également ignorés par git sont copiés, donc les fichiers suivis ne sont jamais dupliqués.

727 

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

729.env

730.env.local

731config/secrets.json

732```

733 

734Cela s'applique aux worktrees créés avec `--worktree`, aux worktrees des subagents et aux sessions parallèles dans l'[application de bureau](/fr/desktop#work-in-parallel-with-sessions).

735 

736### Gérer les worktrees manuellement

737 

738Pour plus de contrôle sur l'emplacement du worktree et la configuration de la branche, créez des worktrees directement avec Git. C'est utile quand vous avez besoin de vérifier une branche existante spécifique ou de placer le worktree en dehors du référentiel.

739 

740```bash theme={null}

741# Créez un worktree avec une nouvelle branche

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

743 

744# Créez un worktree avec une branche existante

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

746 

747# Démarrez Claude dans le worktree

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

749 

750# Nettoyez quand vous avez terminé

751git worktree list

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

753```

754 

755En savoir plus dans la [documentation officielle de Git worktree](https://git-scm.com/docs/git-worktree).

756 

757<Tip>

758 N'oubliez pas d'initialiser votre environnement de développement dans chaque nouveau worktree selon la configuration de votre projet. Selon votre pile, cela peut inclure l'exécution de l'installation des dépendances (`npm install`, `yarn`), la configuration des environnements virtuels ou le suivi du processus de configuration standard de votre projet.

759</Tip>

760 

761### Contrôle de version non-git

762 

763L'isolation worktree fonctionne avec git par défaut. Pour d'autres systèmes de contrôle de version comme SVN, Perforce ou Mercurial, configurez les hooks [WorktreeCreate et WorktreeRemove](/fr/hooks#worktreecreate) pour fournir une logique personnalisée de création et de nettoyage des worktrees. Lorsqu'ils sont configurés, ces hooks remplacent le comportement git par défaut lorsque vous utilisez `--worktree`, donc [`.worktreeinclude`](#copy-gitignored-files-to-worktrees) n'est pas traité. Copiez les fichiers de configuration locaux à l'intérieur de votre script de hook à la place.

764 

765Pour la coordination automatisée des sessions parallèles avec des tâches partagées et la messagerie, consultez [équipes d'agents](/fr/agent-teams).

766 

767***

768 

769## Recevez une notification quand Claude a besoin de votre attention

770 

771Lorsque vous lancez une tâche longue et que vous basculez vers une autre fenêtre, vous pouvez configurer des notifications de bureau afin de savoir quand Claude se termine ou a besoin de votre entrée. Cela utilise l'événement de hook `Notification` [hook event](/fr/hooks-guide#get-notified-when-claude-needs-input), qui se déclenche chaque fois que Claude attend une permission, est inactif et prêt pour un nouveau prompt, ou complète l'authentification.

772 

773<Steps>

774 <Step title="Ajoutez le hook à vos paramètres">

775 Ouvrez `~/.claude/settings.json` et ajoutez un hook `Notification` qui appelle la commande de notification native de votre plateforme :

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 Si votre fichier de paramètres a déjà une clé `hooks`, fusionnez l'entrée `Notification` dedans plutôt que de la remplacer. Vous pouvez également demander à Claude d'écrire le hook pour vous en décrivant ce que vous voulez dans l'interface CLI.

840 </Step>

841 

842 <Step title="Affinez éventuellement le matcher">

843 Par défaut, le hook se déclenche sur tous les types de notifications. Pour se déclencher uniquement pour des événements spécifiques, définissez le champ `matcher` sur l'une de ces valeurs :

844 

845 | Matcher | Se déclenche quand |

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

847 | `permission_prompt` | Claude a besoin que vous approuviez une utilisation d'outil |

848 | `idle_prompt` | Claude a terminé et attend votre prochain prompt |

849 | `auth_success` | L'authentification se termine |

850 | `elicitation_dialog` | Un serveur MCP ouvre un formulaire d'élicitation |

851 | `elicitation_complete` | Un formulaire d'élicitation MCP est soumis ou fermé |

852 | `elicitation_response` | Une réponse d'élicitation MCP est renvoyée au serveur |

853 </Step>

854 

855 <Step title="Vérifiez le hook">

856 Tapez `/hooks` et sélectionnez `Notification` pour confirmer que le hook apparaît. Le sélectionner affiche la commande qui s'exécutera. Pour le tester de bout en bout, demandez à Claude d'exécuter une commande qui nécessite une permission et éloignez-vous du terminal, ou demandez à Claude de déclencher une notification directement.

857 </Step>

858</Steps>

859 

860Pour le schéma d'événement complet et les types de notifications, consultez la [référence Notification](/fr/hooks#notification).

861 

862***

863 

864## Utiliser Claude comme un utilitaire de style unix

865 

866### Ajoutez Claude à votre processus de vérification

867 

868Supposons que vous souhaitiez utiliser Claude Code comme linter ou examinateur de code.

869 

870**Ajoutez Claude à votre script de construction :**

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 Conseils :

885 

886 * Utilisez Claude pour l'examen automatisé du code dans votre pipeline CI/CD

887 * Personnalisez le prompt pour vérifier les problèmes spécifiques pertinents pour votre projet

888 * Envisagez de créer plusieurs scripts pour différents types de vérification

889</Tip>

890 

891### Tuyau entrant, tuyau sortant

892 

893Supposons que vous souhaitiez canaliser les données dans Claude et récupérer les données dans un format structuré.

894 

895**Canalisez les données via 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 Conseils :

903 

904 * Utilisez les tuyaux pour intégrer Claude dans les scripts shell existants

905 * Combinez avec d'autres outils Unix pour des flux de travail puissants

906 * Envisagez d'utiliser `--output-format` pour une sortie structurée

907</Tip>

908 

909### Contrôler le format de sortie

910 

911Supposons que vous ayez besoin de la sortie de Claude dans un format spécifique, en particulier lors de l'intégration de Claude Code dans des scripts ou d'autres outils.

912 

913<Steps>

914 <Step title="Utilisez le format texte (par défaut)">

915 ```bash theme={null}

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

917 ```

918 

919 Cela génère uniquement la réponse en texte brut de Claude (comportement par défaut).

920 </Step>

921 

922 <Step title="Utilisez le format JSON">

923 ```bash theme={null}

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

925 ```

926 

927 Cela génère un tableau JSON de messages avec des métadonnées incluant le coût et la durée.

928 </Step>

929 

930 <Step title="Utilisez le format JSON en continu">

931 ```bash theme={null}

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

933 ```

934 

935 Cela génère une série d'objets JSON en temps réel au fur et à mesure que Claude traite la demande. Chaque message est un objet JSON valide, mais la sortie entière n'est pas un JSON valide s'il est concaténé.

936 </Step>

937</Steps>

938 

939<Tip>

940 Conseils :

941 

942 * Utilisez `--output-format text` pour les intégrations simples où vous avez juste besoin de la réponse de Claude

943 * Utilisez `--output-format json` quand vous avez besoin du journal de conversation complet

944 * Utilisez `--output-format stream-json` pour la sortie en temps réel de chaque tour de conversation

945</Tip>

946 

947***

948 

949## Exécuter Claude selon un calendrier

950 

951Supposons que vous souhaitiez que Claude gère une tâche automatiquement de manière récurrente, comme examiner les PR ouvertes chaque matin, auditer les dépendances chaque semaine ou vérifier les échecs CI pendant la nuit.

952 

953Choisissez une option de planification en fonction de l'endroit où vous souhaitez que la tâche s'exécute :

954 

955| Option | Où elle s'exécute | Idéale pour |

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

957| [Routines](/fr/routines) | Infrastructure gérée par Anthropic | Les tâches qui doivent s'exécuter même quand votre ordinateur est éteint. Peuvent également se déclencher sur les appels API ou les événements GitHub en plus d'un calendrier. Configurez sur [claude.ai/code/routines](https://claude.ai/code/routines). |

958| [Tâches planifiées sur le bureau](/fr/desktop-scheduled-tasks) | Votre machine, via l'application de bureau | Les tâches qui ont besoin d'un accès direct aux fichiers locaux, aux outils ou aux modifications non validées. |

959| [GitHub Actions](/fr/github-actions) | Votre pipeline CI | Les tâches liées aux événements du référentiel comme les PR ouvertes, ou les calendriers cron qui doivent vivre aux côtés de votre configuration de flux de travail. |

960| [`/loop`](/fr/scheduled-tasks) | La session CLI actuelle | L'interrogation rapide pendant qu'une session est ouverte. Les tâches s'arrêtent quand vous commencez une nouvelle conversation ; `--resume` et `--continue` restaurent les tâches non expirées. |

961 

962<Tip>

963 Lors de la rédaction de prompts pour les tâches planifiées, soyez explicite sur ce que signifie le succès et ce qu'il faut faire avec les résultats. La tâche s'exécute de manière autonome, elle ne peut donc pas poser de questions de clarification. Par exemple : ' Examinez les PR ouvertes étiquetées `needs-review`, laissez des commentaires en ligne sur les problèmes et publiez un résumé dans le canal Slack `#eng-reviews`. '

964</Tip>

965 

966***

967 

968## Demandez à Claude ses capacités

969 

970Claude a un accès intégré à sa documentation et peut répondre à des questions sur ses propres fonctionnalités et limitations.

971 

972### Exemples de questions

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 fournit des réponses basées sur la documentation à ces questions. Pour des démonstrations pratiques, exécutez `/powerup` pour des leçons interactives avec des démos animées, ou consultez les sections de flux de travail spécifiques ci-dessus.

1000</Note>

1001 

1002<Tip>

1003 Conseils :

1004 

1005 * Claude a toujours accès à la dernière documentation de Claude Code, quelle que soit la version que vous utilisez

1006 * Posez des questions spécifiques pour obtenir des réponses détaillées

1007 * Claude peut expliquer les fonctionnalités complexes comme l'intégration MCP, les configurations d'entreprise et les flux de travail avancés

1008</Tip>

1009 

1010***

1011 

1012## Étapes suivantes

1013 

1014<CardGroup cols={2}>

1015 <Card title="Bonnes pratiques" icon="lightbulb" href="/fr/best-practices">

1016 Modèles pour tirer le meilleur parti de Claude Code

1017 </Card>

1018 

1019 <Card title="Comment fonctionne Claude Code" icon="gear" href="/fr/how-claude-code-works">

1020 Comprendre la boucle agentique et la gestion du contexte

1021 </Card>

1022 

1023 <Card title="Étendre Claude Code" icon="puzzle-piece" href="/fr/features-overview">

1024 Ajouter des skills, des hooks, MCP, des subagents et des plugins

1025 </Card>

1026 

1027 <Card title="Implémentation de référence" icon="code" href="https://github.com/anthropics/claude-code/tree/main/.devcontainer">

1028 Clonez l'implémentation de référence du conteneur de développement

1029 </Card>

1030</CardGroup>