6 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.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 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).9Cette page rassemble de courtes recettes pour le développement quotidien. Pour des conseils de plus haut niveau sur les prompts et la gestion du contexte, consultez [Bonnes pratiques](/fr/best-practices).
10 10
11## Comprendre les nouvelles bases de code11Cette page couvre :
12 12
13### Obtenir un aperçu rapide de la base de code13* [Recettes de prompts](#prompt-recipes) pour explorer le code, corriger les bogues, refactoriser, tester, les PR et la documentation
14* [Reprendre les conversations précédentes](#resume-previous-conversations) pour qu'une tâche puisse s'étendre sur plusieurs sessions
15* [Exécuter des sessions parallèles avec worktrees](#run-parallel-sessions-with-worktrees) pour que les modifications concurrentes ne se heurtent pas
16* [Planifier avant de modifier](#plan-before-editing) pour examiner les modifications avant qu'elles ne touchent le disque
17* [Déléguer la recherche à des subagents](#delegate-research-to-subagents) pour garder votre contexte principal propre
18* [Canaliser Claude dans des scripts](#pipe-claude-into-scripts) pour CI et le traitement par lot
19
20## Recettes de prompts
21
22Ce sont des modèles de prompts pour les tâches quotidiennes comme explorer du code inconnu, déboguer, refactoriser, écrire des tests et créer des PR. Chacun fonctionne sur n'importe quelle surface Claude Code ; adaptez la formulation à votre projet.
23
24### Comprendre les nouvelles bases de code
25
26#### Obtenir un aperçu rapide de la base de code
14 27
15Supposons que vous venez de rejoindre un nouveau projet et que vous devez comprendre rapidement sa structure.28Supposons que vous venez de rejoindre un nouveau projet et que vous devez comprendre rapidement sa structure.
16 29
56 * Demandez un glossaire des termes spécifiques au projet69 * Demandez un glossaire des termes spécifiques au projet
57</Tip>70</Tip>
58 71
59### Trouver du code pertinent72#### Trouver du code pertinent
60 73
61Supposons que vous ayez besoin de localiser du code lié à une fonctionnalité ou une capacité spécifique.74Supposons que vous ayez besoin de localiser du code lié à une fonctionnalité ou une capacité spécifique.
62 75
90 103
91***104***
92 105
93## Corriger les bogues efficacement106### Corriger les bogues efficacement
94 107
95Supposons que vous ayez rencontré un message d'erreur et que vous ayez besoin de trouver et de corriger sa source.108Supposons que vous ayez rencontré un message d'erreur et que vous ayez besoin de trouver et de corriger sa source.
96 109
124 137
125***138***
126 139
127## Refactoriser le code140### Refactoriser le code
128 141
129Supposons que vous ayez besoin de mettre à jour du code ancien pour utiliser des modèles et des pratiques modernes.142Supposons que vous ayez besoin de mettre à jour du code ancien pour utiliser des modèles et des pratiques modernes.
130 143
164 177
165***178***
166 179
167## Utiliser des subagents spécialisés180### Travailler avec les tests
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 181
302Supposons que vous ayez besoin d'ajouter des tests pour du code non couvert.182Supposons que vous ayez besoin d'ajouter des tests pour du code non couvert.
303 183
333 213
334***214***
335 215
336## Créer des demandes de tirage216### Créer des demandes de tirage
337 217
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 :218Vous 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 219
357 </Step>237 </Step>
358</Steps>238</Steps>
359 239
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>`.240Lorsque vous créez une PR en utilisant `gh pr create`, la session est automatiquement liée à cette PR. Pour la reprendre plus tard, exécutez `claude --from-pr <number>` ou collez l'URL de la PR dans le sélecteur [`/resume`](/fr/sessions#use-the-session-picker).
361 241
362<Tip>242<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.243 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>244</Tip>
365 245
366## Gérer la documentation246### Gérer la documentation
367 247
368Supposons que vous ayez besoin d'ajouter ou de mettre à jour la documentation de votre code.248Supposons que vous ayez besoin d'ajouter ou de mettre à jour la documentation de votre code.
369 249
403 283
404***284***
405 285
406## Travailler dans les notes et les dossiers non-code286### Travailler dans les notes et les dossiers non-code
407 287
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.288Claude 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 289
411 291
412***292***
413 293
414## Travailler avec les images294### Travailler avec les images
415 295
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.296Supposons 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 297
471 351
472***352***
473 353
474## Référencer les fichiers et répertoires354### Référencer les fichiers et répertoires
475 355
476Utilisez @ pour inclure rapidement des fichiers ou des répertoires sans attendre que Claude les lise.356Utilisez @ pour inclure rapidement des fichiers ou des répertoires sans attendre que Claude les lise.
477 357
512 392
513***393***
514 394
515## Utiliser la réflexion étendue (mode de réflexion)395### Exécuter Claude selon un calendrier
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 396
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.397Supposons 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 398
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. |406| [`/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 407
962<Tip>408<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`. '409 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>410</Tip>
965 411
966***412***
967 413
968## Demandez à Claude ses capacités414### Demandez à Claude ses capacités
969 415
970Claude a un accès intégré à sa documentation et peut répondre à des questions sur ses propres fonctionnalités et limitations.416Claude a un accès intégré à sa documentation et peut répondre à des questions sur ses propres fonctionnalités et limitations.
971 417
972### Exemples de questions418#### Exemples de questions
973 419
974```text theme={null}420```text theme={null}
975can Claude Code create pull requests?421can Claude Code create pull requests?
1009 455
1010***456***
1011 457
458## Reprendre les conversations précédentes
459
460Quand une tâche s'étend sur plusieurs sessions, reprenez là où vous avez laissé au lieu de réexpliquer le contexte. Claude Code enregistre chaque conversation localement.
461
462```bash theme={null}
463claude --continue
464```
465
466Cela reprend la session la plus récente dans le répertoire actuel ; s'il n'y en a pas encore, il affiche `No conversation found to continue` et se termine. Utilisez `claude --resume` pour choisir dans une liste, ou `/resume` depuis une session en cours. Consultez [Gérer les sessions](/fr/sessions) pour nommer, créer des branches et la référence complète du sélecteur.
467
468## Exécuter des sessions parallèles avec worktrees
469
470Travaillez sur une fonctionnalité dans un terminal tandis que Claude corrige un bogue dans un autre, sans que les modifications ne se heurtent. Chaque worktree est un checkout séparé sur sa propre branche.
471
472```bash theme={null}
473claude --worktree feature-auth
474```
475
476Exécutez la même commande avec un nom différent dans un deuxième terminal pour démarrer une session parallèle isolée. Consultez [Worktrees](/fr/worktrees) pour le nettoyage, `.worktreeinclude` et le support VCS non-git. Pour surveiller les sessions parallèles à partir d'un seul écran au lieu de terminaux séparés, consultez [agents en arrière-plan](/fr/agent-view).
477
478## Planifier avant de modifier
479
480Pour les modifications que vous souhaitez examiner avant qu'elles ne touchent le disque, basculez en mode plan. Claude lit les fichiers et propose un plan mais ne fait aucune modification jusqu'à ce que vous approuviez.
481
482```bash theme={null}
483claude --permission-mode plan
484```
485
486Vous pouvez également appuyer sur `Shift+Tab` pendant une session pour basculer en mode plan. Consultez [Mode plan](/fr/permission-modes#analyze-before-you-edit-with-plan-mode) pour le flux d'approbation et la modification du plan dans votre éditeur de texte.
487
488## Déléguer la recherche à des subagents
489
490Explorer une grande base de code remplit votre contexte avec des lectures de fichiers. Déléguez l'exploration pour que seules les conclusions reviennent.
491
492```text theme={null}
493use a subagent to investigate how our auth system handles token refresh
494```
495
496Le subagent lit les fichiers dans sa propre fenêtre de contexte et rapporte un résumé. Consultez [Subagents](/fr/sub-agents) pour définir des agents personnalisés avec leurs propres outils et prompts.
497
498## Canaliser Claude dans des scripts
499
500Exécutez Claude de manière non-interactive pour CI, les hooks de pré-commit ou le traitement par lot. Stdin et stdout fonctionnent comme n'importe quel outil Unix.
501
502```bash theme={null}
503git log --oneline -20 | claude -p "summarize these recent commits"
504```
505
506Consultez [Mode non-interactif](/fr/headless) pour les formats de sortie, les drapeaux de permission et les modèles de fan-out.
507
1012## Étapes suivantes508## Étapes suivantes
1013 509
1014<CardGroup cols={2}>510<CardGroup cols={2}>
1016 Modèles pour tirer le meilleur parti de Claude Code512 Modèles pour tirer le meilleur parti de Claude Code
1017 </Card>513 </Card>
1018 514
1019 <Card title="Comment fonctionne Claude Code" icon="gear" href="/fr/how-claude-code-works">515 <Card title="Gérer les sessions" icon="rotate-left" href="/fr/sessions">
1020 Comprendre la boucle agentique et la gestion du contexte516 Reprendre, nommer et créer des branches de conversations
1021 </Card>517 </Card>
1022 518
1023 <Card title="Étendre Claude Code" icon="puzzle-piece" href="/fr/features-overview">519 <Card title="Worktrees" icon="code-branch" href="/fr/worktrees">
1024 Ajouter des skills, des hooks, MCP, des subagents et des plugins520 Exécuter des sessions parallèles isolées
1025 </Card>521 </Card>
1026 522
1027 <Card title="Implémentation de référence" icon="code" href="https://github.com/anthropics/claude-code/tree/main/.devcontainer">523 <Card title="Étendre Claude Code" icon="puzzle-piece" href="/fr/features-overview">
1028 Clonez l'implémentation de référence du conteneur de développement524 Ajouter des skills, des hooks, MCP, des subagents et des plugins
1029 </Card>525 </Card>
1030</CardGroup>526</CardGroup>
