2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt2> 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.3> Use this file to discover all available pages before exploring further.
4 4
5# Meilleures pratiques pour Claude Code5# Bonnes pratiques pour Claude Code
6 6
7> Conseils et modèles pour tirer le meilleur parti de Claude Code, de la configuration de votre environnement à la mise à l'échelle sur plusieurs sessions parallèles.7> Tirez le meilleur parti de Claude Code : dites à Claude ce qu'il ne peut pas voir, donnez-lui une vérification à exécuter et imposez les règles qui ne tolèrent aucune exception.
8 8
9Claude Code est un environnement de codage agentique. Contrairement à un chatbot qui répond aux questions et attend, Claude Code peut lire vos fichiers, exécuter des commandes, apporter des modifications et travailler de manière autonome sur les problèmes pendant que vous regardez, redirigez ou vous éloignez complètement.9Claude Code est conçu de telle sorte que, dans la plupart des cas, votre premier prompt tout simple dans une nouvelle session fait déjà ce qu'il faut, sans aucune configuration de votre part.
10 10
11Cela change votre façon de travailler. Au lieu d'écrire du code vous-même et de demander à Claude de le réviser, vous décrivez ce que vous voulez et Claude détermine comment le construire. Claude explore, planifie et implémente.11Par exemple :
12 12
13Mais cette autonomie s'accompagne toujours d'une courbe d'apprentissage. Claude fonctionne dans certaines contraintes que vous devez comprendre.13* Pour que les commandes s'exécutent en toute sécurité sans que vous ayez à approuver chacune d'elles, les nouvelles sessions de terminal et VS Code démarrent en [mode auto](https://code.claude.com/docs/fr/permission-modes.md#eliminate-prompts-with-auto-mode), où un classifieur examine tout ce qui est risqué avant son exécution.
14* Pour que votre conversation principale reste concentrée pendant que du travail indépendant se déroule en parallèle, Claude délègue à des sous-agents et ne vous sollicite que lorsque c'est nécessaire.
15* Pour qu'une longue session se poursuive sans que vous ayez à la gérer, votre conversation est compactée automatiquement avant que la fenêtre de contexte ne se remplisse.
14 16
15Ce guide couvre les modèles qui se sont avérés efficaces dans les équipes internes d'Anthropic et pour les ingénieurs utilisant Claude Code sur diverses bases de code, langages et environnements. Pour comprendre comment la boucle agentique fonctionne sous le capot, consultez [Comment fonctionne Claude Code](https://code.claude.com/docs/fr/how-claude-code-works.md).17Cette page couvre ce qu'il faut faire lorsque les valeurs par défaut ne suffisent pas. Cela arrive généralement lorsque votre projet comporte des connaissances, des règles ou des contraintes que Claude ne peut pas voir à partir du seul code :
16 18
17***19* Un processus de déploiement qui n'existe que dans la tête de quelqu'un
20* Un fichier qui ne doit jamais être lu
21* Une vérification qui doit réussir avant que quoi que ce soit soit considéré comme terminé
22* Un budget que vous devez respecter
18 23
19La plupart des meilleures pratiques sont basées sur une contrainte : la fenêtre de contexte de Claude se remplit rapidement et les performances se dégradent à mesure qu'elle se remplit.24Aucune valeur par défaut ne peut connaître ces éléments de votre projet, et c'est donc là qu'un petit effort de configuration de votre part porte ses fruits.
20 25
21La fenêtre de contexte de Claude contient l'intégralité de votre conversation, y compris chaque message, chaque fichier que Claude lit et chaque sortie de commande. Cependant, cela peut se remplir rapidement. Une seule session de débogage ou exploration de base de code peut générer et consommer des dizaines de milliers de tokens.26Lorsqu'une session ne se déroule pas comme prévu, c'est presque toujours pour l'une de ces raisons :
22 27
23Cela importe car les performances des LLM se dégradent à mesure que le contexte se remplit. Lorsque la fenêtre de contexte est presque pleine, Claude peut commencer à « oublier » les instructions antérieures ou faire plus d'erreurs. La fenêtre de contexte est la ressource la plus importante à gérer. Pour voir comment une session se remplit en pratique, [regardez une démonstration interactive](https://code.claude.com/docs/fr/context-window.md) de ce qui se charge au démarrage et ce que chaque lecture de fichier coûte. Suivez l'utilisation du contexte en continu avec une [ligne d'état personnalisée](https://code.claude.com/docs/fr/statusline.md), et consultez [Réduire l'utilisation des tokens](https://code.claude.com/docs/fr/costs.md#reduce-token-usage) pour des stratégies de réduction de l'utilisation des tokens.28* Claude a construit quelque chose de différent de ce que vous aviez en tête, ou il doit redécouvrir le même fait au début de chaque session. Il lui manque des informations qu'il ne peut pas obtenir en lisant le dépôt. Consultez [Dites à Claude ce qu'il ne peut pas voir](#tell-claude-what-it-cant-see).
29* Claude a dit qu'il avait terminé alors que ce n'était pas tout à fait le cas, généralement parce qu'il n'avait aucun moyen de vérifier son propre travail. Consultez [Donnez à Claude une vérification à exécuter](#give-claude-a-check-to-run).
30* Claude a fait quelque chose qui ne doit jamais se produire dans ce dépôt, ou a sauté une étape qui doit toujours avoir lieu. Un prompt seul ne peut garantir ni l'un ni l'autre. Consultez [Imposez les règles qui ne tolèrent aucune exception](#enforce-the-rules-that-cant-have-exceptions).
31* Claude a bien fait les choses, mais cela a pris plus de temps, de tokens ou de demandes de permission que la tâche ne le justifiait. Consultez [Modifiez une valeur par défaut](#change-a-default).
24 32
25***33[Laissez Claude travailler sans vous](#let-claude-run-without-you) applique ces quatre mêmes points aux exécutions sans surveillance, et [Ce que vous pouvez arrêter de faire](#what-you-can-stop-doing) liste les conseils que les modèles actuels ont rendus inutiles.
26 34
27## Donnez à Claude un moyen de vérifier son travail35> [!NOTE]
28
29> [!TIP]
30>36>
31> Donnez à Claude une vérification qu'il peut exécuter : des tests, une compilation, une capture d'écran à comparer. C'est la différence entre une session que vous regardez et une session dont vous vous éloignez.37> La configuration pour toute une équipe se trouve sur une page distincte : [Configurer Claude Code pour votre organisation](https://code.claude.com/docs/fr/admin-setup.md).
32 38
33Claude s'arrête quand le travail semble terminé. Sans une vérification qu'il peut exécuter, « semble terminé » est le seul signal disponible, et vous devenez la boucle de vérification : chaque erreur attend que vous la remarquiez. Donnez à Claude quelque chose qui produit un résultat de réussite ou d'échec, et la boucle se ferme d'elle-même. Claude fait le travail, exécute la vérification, lit le résultat et itère jusqu'à ce que la vérification réussisse.39## Instructions déterministes et non déterministes
34 40
35La vérification est tout ce qui retourne un signal que Claude peut lire dans la conversation : une suite de tests, un code de sortie de compilation, un linter, un script qui compare la sortie à une fixture, ou une [capture d'écran du navigateur](https://code.claude.com/docs/fr/chrome.md) comparée à une conception. Exécutez [`/verify`](https://code.claude.com/docs/fr/skills#run-and-verify-your-app) vous-même après que la vérification de Claude réussisse pour confirmer la modification par rapport à l'application en cours d'exécution.41Chaque instruction que vous donnez à Claude Code appartient à l'une de ces catégories :
36 42
37| Stratégie | Avant | Après |431. Non déterministe : vous écrivez l'instruction, et Claude (le modèle) la lit. Il peut s'agir de votre prompt, de `CLAUDE.md` ou d'un skill. Le modèle décide ensuite quoi faire de cette information. Il suit généralement vos commandes, et les modèles actuels comprennent bien votre intention sans beaucoup de contexte, mais rien ne *garantit* qu'il suivra vos instructions. Il peut toujours décider de ne pas faire certaines choses, ou d'en faire d'autres.
38| - | - | - |442. Déterministe : vous configurez l'instruction, et Claude Code (le harnais) *doit* l'exécuter. Il peut s'agir d'un hook, d'une règle de refus ou d'un paramètre géré. Claude Code l'applique à chaque fois, quelle que soit la décision du modèle.
39| **Fournir des critères de vérification** | *« implémenter une fonction qui valide les adresses e-mail »* | *« écrire une fonction validateEmail. exemples de cas de test : [user@example.com](mailto:user@example.com) est vrai, invalid est faux, [user@.com](mailto:user@.com) est faux. exécuter les tests après l'implémentation »* |
40| **Vérifier les modifications de l'interface utilisateur visuellement** | *« rendre le tableau de bord plus beau »* | *« \[coller la capture d'écran] implémenter cette conception. prendre une capture d'écran du résultat et la comparer à l'original. lister les différences et les corriger »* |
41| **Traiter les causes profondes, pas les symptômes** | *« la compilation échoue »* | *« la compilation échoue avec cette erreur : \[coller l'erreur]. la corriger et vérifier que la compilation réussit. traiter la cause profonde, ne pas supprimer l'erreur »* |
42 45
43Une fois que la vérification existe, décidez à quel point elle contrôle l'arrêt :46La plupart des éléments de Claude Code existent sous ces deux formes :
44 47
45* **En un seul message** : demandez à Claude d'exécuter la vérification et d'itérer dans le même message, comme dans le tableau ci-dessus.48| | Non déterministe (Claude décide) | Déterministe (Claude Code impose) |
46* **Sur une session** : définissez la vérification comme une [condition `/goal`](https://code.claude.com/docs/fr/goal). Un évaluateur séparé la revérifie après chaque tour et Claude continue de travailler jusqu'à ce que l'objectif soit résolu. Si Claude stagne, Claude Code finit par arrêter l'exécution avec l'objectif toujours défini — voir [comment l'évaluation de /goal fonctionne](https://code.claude.com/docs/fr/goal.md#how-evaluation-works).49| :- | :- | :- |
47* **Comme une porte déterministe** : un [hook Stop](https://code.claude.com/docs/fr/hooks.md#stop) exécute votre vérification en tant que script et bloque la fin du tour jusqu'à ce qu'elle réussisse. [Stop input](https://code.claude.com/docs/fr/hooks.md#stop-input) couvre le plafond sur les blocages consécutifs.50| Quoi faire | Votre prompt, `CLAUDE.md`, les skills que Claude sollicite lui-même | Les hooks, et les skills que vous seul pouvez démarrer |
48* **Par un deuxième avis** : un [sous-agent de vérification](https://code.claude.com/docs/fr/sub-agents.md) ou un [flux de travail dynamique](https://code.claude.com/docs/fr/workflows.md) qui vérifie ses propres conclusions a un modèle frais qui essaie de réfuter le résultat, de sorte que l'agent qui fait le travail n'est pas celui qui le note.51| Ce qu'il peut toucher | Le classifieur du mode auto | Les règles de refus, le sandbox en [mode strict](https://code.claude.com/docs/fr/sandboxing.md#turn-off-the-retry-with-strict-sandbox-mode), les paramètres gérés |
52| Quand c'est terminé | Une demande de preuves, `/goal`, `/code-review` | Les tests, la vérification de types, un hook `Stop`, la CI |
53| Combien il dépense | Le niveau d'effort, le rythme propre de Claude | `--max-turns` ou [`--max-budget-usd`](https://code.claude.com/docs/fr/cli-reference) avec `-p`, une [limite de dépenses](https://code.claude.com/docs/fr/costs.md) que vous avez définie |
54| Qui a le dernier mot | Le résumé par Claude de ce qu'il a fait | La protection de branche, une personne qui approuve la fusion |
49 55
50Chaque étape échange la configuration pour l'attention. La version avec message fonctionne sur n'importe quelle tâche aujourd'hui. Les versions `/goal` et Stop hook sont ce qui permet à une exécution sans surveillance de se terminer correctement sans vous.56La plupart du temps, vous voulez que Claude décide. Presque toutes les directives ont des exceptions, et les modèles actuels savent bien lire le code qu'ils ont sous les yeux et juger si une directive convient à la situation. Avec le code réel sous les yeux, Claude est généralement mieux placé pour prendre cette décision qu'une règle que vous avez écrite à l'avance.
51 57
52Demandez à Claude de montrer des preuves plutôt que d'affirmer le succès : la sortie du test, la commande qu'il a exécutée et ce qu'elle a retourné, ou une capture d'écran du résultat. Examiner les preuves est plus rapide que de relancer la vérification vous-même, et cela fonctionne pour les sessions que vous n'aviez pas observées.58Le type déterministe sert lorsque vous voulez vous assurer que certaines choses se produisent *toujours* (ou jamais), quelle que soit la décision du modèle. Il n'est pas nécessaire que ce soit quelque chose de spectaculaire. Le mode auto [bloque déjà les choses spectaculaires](https://code.claude.com/docs/fr/permission-modes.md#what-the-classifier-blocks-by-default), comme un déploiement en production ou un force push par-dessus le travail de quelqu'un. Il s'agit généralement de quelque chose de propre à *votre* projet, et cela peut être aussi spécifique que vous le souhaitez :
53 59
54***60* Ne jamais modifier le client généré dans `src/gen/`
61* Toujours exécuter le script d'en-tête de licence après la création d'un fichier
55 62
56## Explorez d'abord, puis planifiez, puis codez63Vous auriez pu écrire l'une ou l'autre de ces règles sous forme de ligne dans `CLAUDE.md` ou dans votre prompt, et Claude la suivrait presque à chaque fois. Mais quelle que soit la fermeté de votre formulation, le fait que Claude suive cette ligne lors d'un tour donné reste sa décision.
57 64
58> [!TIP]65> [!TIP]
59>66>
60> Séparez la recherche et la planification de l'implémentation pour éviter de résoudre le mauvais problème.67> Si vous ne cessez d'ajouter de l'emphase à une ligne de `CLAUDE.md` et que Claude la manque toujours, c'est le signe que cette ligne a sa place dans un hook. L'inverse est également vrai : si vous avez des hooks pour des choses qui ne sont que des préférences, supprimez-les et laissez Claude décider.
61 68
62Laisser Claude sauter directement au codage peut produire du code qui résout le mauvais problème. Utilisez [plan mode](https://code.claude.com/docs/fr/permission-modes.md#analyze-before-you-edit-with-plan-mode) pour séparer l'exploration de l'exécution.69## Dites à Claude ce qu'il ne peut pas voir
63 70
64Le flux de travail recommandé comporte quatre phases :71> [!TIP]
72>
73> N'écrivez que ce que Claude ne peut pas trouver en lisant le dépôt, ou ce qu'il passerait sinon du temps à redécouvrir à chaque session.
65 74
66**1. Explorez**75Claude commence chaque tâche en lisant votre code, et les modèles actuels y excellent *vraiment*. Ils trouveront l'organisation de vos fichiers, vos conventions, votre framework de test et la façon dont les composants existants sont construits, généralement plus vite que vous ne pourriez les expliquer. Cela signifie que Claude connaît déjà l'essentiel de ce que vous pourriez être tenté d'écrire pour lui.
67 76
68Entrez en plan mode en appuyant sur `Shift+Tab` jusqu'à ce que la barre d'état affiche `⏸ plan mode on`, ou démarrez la session avec `claude --permission-mode plan`. Claude lit les fichiers et répond aux questions sans apporter de modifications.77Ce qu'il ne peut pas trouver, ce sont les informations qui n'ont jamais été dans le dépôt :
69 78
70```txt title="claude (plan mode)" wrap theme={null}79* Une décision prise par votre équipe lors d'une réunion
71read /src/auth and understand how we handle sessions and login.80* Un processus de déploiement qui n'existe que dans la tête d'une personne
72also look at how we manage environment variables for secrets.81* La variable d'environnement dont vos tests d'intégration ont besoin
73```
74 82
75**2. Planifiez**83Il y a aussi des informations qui *sont* dans le dépôt mais qui demandent quelques minutes de recherche, et Claude doit refaire cette recherche au début de chaque session.
76 84
77Demandez à Claude de créer un plan d'implémentation détaillé.85Un bon test avant d'écrire quoi que ce soit pour Claude :
78 86
79```txt title="claude (plan mode)" wrap theme={null}871. Pourrait-il trouver cela en lisant le code ?
80I want to add Google OAuth. What files need to change?882. Irait-il réellement chercher ?
81What's the session flow? Create a plan.
82```
83 89
84Appuyez sur `Ctrl+G` pour ouvrir le plan dans votre éditeur de texte pour une édition directe avant que Claude ne procède.90Si la réponse est oui aux deux, laissez-le de côté.
85 91
86**3. Implémentez**92### Écrivez un prompt précis
87 93
88Quittez le plan mode en approuvant le plan ou en appuyant sur `Shift+Tab`, puis laissez Claude coder, en vérifiant par rapport à son plan.94Un prompt précis aide pour la même raison, car il donne à Claude des informations qu'il n'a pas déjà. Si vous nommez le fichier, décrivez le symptôme et indiquez d'emblée à quoi ressemble « corrigé », vous vous épargnez généralement une série de corrections par la suite.
89 95
90```txt title="claude" wrap theme={null}96Il en va de même pour une préférence entre deux approches raisonnables : Claude ne peut pas la lire dans le code, donc si vous tenez à ce qu'il choisisse l'une plutôt que l'autre, dites-le d'emblée.
91implement the OAuth flow from your plan. write tests for the
92callback handler, run the test suite and fix any failures.
93```
94 97
95**4. Validez**98| Au lieu de | Essayez |
99| :- | :- |
100| *« corrige le bug de connexion »* | *« les utilisateurs signalent que la connexion échoue après l'expiration de la session. regarde l'actualisation des tokens dans src/auth/, écris un test qui échoue et reproduit le problème, puis corrige-le »* |
101| *« ajoute un widget calendrier »* | *« suis le modèle de HotDogWidget.php et construis un widget calendrier qui permet de choisir un mois et de naviguer entre les années. pas de nouvelles bibliothèques »* |
96 102
97Demandez à Claude de valider avec un message descriptif et de créer une PR.103Si vous disposez déjà de ce dont Claude a besoin, transmettez-le au lieu de le décrire :
98 104
99```txt title="claude" wrap theme={null}105* Un fichier : tapez `@` suivi du chemin pour [inclure le contenu du fichier](https://code.claude.com/docs/fr/common-workflows.md#reference-files-and-directories) dans votre message.
100commit with a descriptive message and open a PR106* Une image : collez la capture d'écran de la maquette ou de l'erreur dans le prompt.
101```107* La sortie d'une commande : redirigez-la depuis votre shell avec `cat error.log | claude -p "what's going on here"`.
102 108
103Plan mode est utile, mais ajoute également des frais généraux.109Des expressions comme `think step by step` ou `be thorough` sont du texte de prompt ordinaire plutôt que des mots-clés. Le principal contrôle de l'intensité de réflexion de Claude est le [niveau d'effort](https://code.claude.com/docs/fr/model-config.md#adjust-effort-level), traité dans [Changez le modèle et l'effort](#change-the-model-and-effort). Ce type de formulation peut encore orienter Claude dans les limites de son niveau d'effort, mais ne le fera pas dépasser.
104 110
105Pour les tâches où la portée est claire et la correction est petite (comme corriger une faute de frappe, ajouter une ligne de journal ou renommer une variable), demandez à Claude de le faire directement.111Une expression qui aide encore est `be ambitious`. Claude a tendance à interpréter une demande de façon conservatrice et à construire la plus petite chose qui y réponde, car il ne peut pas voir à quel point vous espériez davantage. Lorsque vous voulez la version plus complète, avec les cas limites gérés et la suite naturelle incluse, dites-le :
106 112
107La planification est plus utile lorsque vous êtes incertain de l'approche, lorsque la modification modifie plusieurs fichiers ou lorsque vous n'êtes pas familier avec le code en cours de modification. Si vous pouviez décrire le diff en une phrase, ignorez le plan.113```text theme={null}
114build the settings page from the mockup. be ambitious: empty and error states, the save flow wired up, keyboard navigation, not just the layout
115```
108 116
109***117Cela indique à Claude la portée, que vous seul connaissez, plutôt que l'intensité de sa réflexion.
110 118
111## Fournissez un contexte spécifique dans vos invites119Et lorsque vous explorez plutôt que de corriger quelque chose de précis, un prompt vague comme `what would you improve in this file?` convient parfaitement. Vous corrigerez un peu plus au fur et à mesure, c'est le compromis.
112 120
113> [!TIP]121### Faites d'abord un brainstorming avec Claude
114>
115> Plus vos instructions sont précises, moins vous aurez besoin de corrections.
116 122
117Claude peut déduire l'intention, mais il ne peut pas lire dans vos pensées. Référencez des fichiers spécifiques, mentionnez les contraintes et pointez vers des modèles d'exemple.123Lorsque vous ne savez pas encore exactement ce que vous voulez, vous n'avez pas à tout élaborer avant d'écrire votre prompt. Demandez plutôt à Claude de vous interviewer :
118 124
119| Stratégie | Avant | Après |125```text theme={null}
120| - | - | - |126I want to add rate limiting to the public API but haven't thought it through yet. Interview me until you could write the spec, then write it to SPEC.md.
121| **Délimitez la tâche.** Spécifiez quel fichier, quel scénario et les préférences de test. | *« ajouter des tests pour foo.py »* | *« écrire un test pour foo.py couvrant le cas limite où l'utilisateur est déconnecté. éviter les mocks. »* |127```
122| **Pointez vers les sources.** Dirigez Claude vers la source qui peut répondre à une question. | *« pourquoi ExecutionFactory a-t-il une API aussi bizarre ? »* | *« parcourir l'historique git d'ExecutionFactory et résumer comment son API en est venue à être »* |
123| **Référencez les modèles existants.** Pointez Claude vers les modèles de votre base de code. | *« ajouter un widget calendrier »* | *« regarder comment les widgets existants sont implémentés sur la page d'accueil pour comprendre les modèles. HotDogWidget.php est un bon exemple. suivre le modèle pour implémenter un nouveau widget calendrier qui permet à l'utilisateur de sélectionner un mois et de paginer vers l'avant/l'arrière pour choisir une année. construire à partir de zéro sans bibliothèques autres que celles déjà utilisées dans la base de code. »* |
124| **Décrivez le symptôme.** Fournissez le symptôme, l'emplacement probable et ce que « corrigé » signifie. | *« corriger le bug de connexion »* | *« les utilisateurs signalent que la connexion échoue après l'expiration de la session. vérifier le flux d'authentification dans src/auth/, en particulier l'actualisation des tokens. écrire un test défaillant qui reproduit le problème, puis le corriger »* |
125 128
126Les invites vagues peuvent être utiles lorsque vous explorez et que vous pouvez vous permettre de corriger la trajectoire. Une invite comme `« qu'amélioreriez-vous dans ce fichier ? »` peut révéler des choses auxquelles vous n'auriez pas pensé à demander.129Claude revient avec des questions à choix multiples sur les points que vous n'avez pas encore fixés : limites par utilisateur ou par clé, ce qui arrive aux requêtes au-delà de la limite, ce qui est hors périmètre. Il continue de poser des questions jusqu'à ce que les réponses forment une spécification.
127 130
128### Fournissez du contenu riche131Une fois `SPEC.md` créé, démarrez une nouvelle session pour construire à partir de celui-ci, afin que la construction commence avec un contexte propre et une définition écrite de ce qu'est « terminé ». C'est aussi le fichier vers lequel vous dirigerez le relecteur plus tard, dans [Donnez à Claude une vérification à exécuter](#give-claude-a-check-to-run).
129 132
130> [!TIP]133### Gardez CLAUDE.md court
131>
132> Utilisez `@` pour référencer des fichiers, coller des captures d'écran/images ou canaliser les données directement.
133 134
134Vous pouvez fournir des données riches à Claude de plusieurs façons :135Claude Code charge [`CLAUDE.md`](https://code.claude.com/docs/fr/memory) dans chaque session, ce qui signifie que chaque ligne qu'il contient mobilise un peu de l'attention de Claude sur *chaque* tâche, qu'elle soit pertinente ou non. C'est pourquoi le fichier fonctionne mieux lorsqu'il ne contient que ce que Claude ne pourrait pas déduire du code lui-même :
135 136
136* **Référencez les fichiers avec `@`** au lieu de décrire où le code se trouve. Claude lit le fichier avant de répondre.137* Comment valider le travail dans ce dépôt : les commandes exactes de test, de vérification de types et de lint, et comment exécuter un seul fichier de test
137* **Collez les images directement**. Copiez/collez ou glissez-déposez les images dans l'invite.138* Les endroits où le code est trompeur : un ancien modèle présent partout mais que le nouveau code ne doit pas copier, ou un répertoire qui semble inutilisé mais ne l'est pas
138* **Donnez des URL** pour la documentation et les références API. Utilisez `/permissions` pour autoriser les domaines fréquemment utilisés.139* Les décisions qui ne sont pas dans le dépôt : quel helper d'erreur l'équipe a retenu, comment fonctionnent les déploiements, ce qui nécessite une revue de migration
139* **Canalisez les données** en exécutant `cat error.log | claude -p "explain this error"` pour envoyer le contenu du fichier directement.140* Tout ce que vous avez déjà dû corriger deux fois
140* **Laissez Claude récupérer ce dont il a besoin**. Dites à Claude de tirer le contexte lui-même en utilisant des commandes Bash, des outils MCP ou en lisant des fichiers.
141 141
142***142Un `CLAUDE.md` qui passe ce test reste court :
143 143
144## Configurez votre environnement144```markdown CLAUDE.md theme={null}
145# Commands
146- Install: pnpm install
147- Run one test file: pnpm vitest run path/to/file.test.ts
148- Typecheck: pnpm tsc --noEmit
145 149
146Quelques étapes de configuration rendent Claude Code beaucoup plus efficace dans toutes vos sessions. Pour un aperçu complet des fonctionnalités d'extension et du moment d'utiliser chacune, consultez [Étendre Claude Code](https://code.claude.com/docs/fr/features-overview.md).150# Conventions
151- Use the error helpers in src/lib/errors.ts, never throw raw strings
152- src/legacy/ is still live but don't copy its patterns into new code
147 153
148### Écrivez un CLAUDE.md efficace154# Gotchas
155- Integration tests need DATABASE_URL set, see .env.example
156```
149 157
150> [!TIP]158Dans une session, exécutez `/context` pour confirmer que Claude a chargé le fichier.
151>
152> Exécutez `/init` pour générer un fichier CLAUDE.md de démarrage basé sur la structure actuelle de votre projet, puis affinez au fil du temps.
153 159
154CLAUDE.md est un fichier spécial que Claude lit au début de chaque conversation. Incluez des commandes Bash, le style de code et les règles de flux de travail. Cela donne à Claude un contexte persistant qu'il ne peut pas déduire du code seul.160Remarquez que la ligne de vérification de types ne contient que la commande. Claude a besoin de connaître la commande pour pouvoir vérifier son propre travail au fur et à mesure. Si vous voulez aussi que Claude Code *impose* une vérification de types réussie avant que Claude ne termine, c'est le rôle d'un [hook `Stop`](#enforce-the-check-with-a-stop-hook). Une ligne comme `Always typecheck before you finish` dans ce fichier fonctionne la plupart du temps, pas à chaque fois.
155 161
156Il n'y a pas de format requis pour les fichiers CLAUDE.md, mais gardez-le court et lisible par l'homme. Par exemple :162Vous n'avez pas à écrire le fichier à partir de zéro :
157 163
158```markdown CLAUDE.md theme={null}164* `/init` génère une version de départ à partir de votre base de code. Ensuite, le travail consiste surtout à supprimer des lignes. Le [guide de la mémoire](https://code.claude.com/docs/fr/memory.md#write-effective-instructions) recommande de rester sous les 200.
159# Code style165* `/doctor` suggère des suppressions pour tout ce que Claude peut [déjà déduire du code](https://code.claude.com/docs/fr/memory.md#my-claude-md-is-too-large).
160- Use ES modules (import/export) syntax, not CommonJS (require)166* `/doctor prompt-audit` signale les instructions écrites pour des modèles plus anciens, qui pointent vers des fichiers qui n'existent plus ou qui [se contredisent](https://code.claude.com/docs/fr/memory.md#audit-your-instruction-files).
161- Destructure imports when possible (eg. import { foo } from 'bar')
162 167
163# Workflow168Vos préférences personnelles vont dans `CLAUDE.local.md` plutôt que dans `CLAUDE.md`, et vous ajoutez ce fichier à `.gitignore` pour qu'il reste hors du dépôt.
164- Be sure to typecheck when you're done making a series of code changes
165- Prefer running single tests, and not the whole test suite, for performance
166```
167 169
168Exécutez `/context` pour confirmer que Claude a chargé le fichier. CLAUDE.md est chargé à chaque session, donc incluez uniquement les choses qui s'appliquent largement. Pour les connaissances de domaine ou les flux de travail qui ne sont pertinents que parfois, utilisez [skills](https://code.claude.com/docs/fr/skills.md) à la place. Claude les charge à la demande sans surcharger chaque conversation.170> [!NOTE]
171>
172> Si Claude continue d'ignorer une ligne qui *se trouve* dans `CLAUDE.md`, ajouter IMPORTANT ne résoudra probablement pas le problème. Soit le fichier est devenu assez long pour que la ligne s'y perde, soit la ligne est une règle qui ne tolère aucune exception, auquel cas elle a sa place dans un [hook](#enforce-the-rules-that-cant-have-exceptions).
169 173
170Gardez-le concis. Pour chaque ligne, demandez-vous : *« Supprimer cela causerait-il à Claude de faire des erreurs ? »* Si non, supprimez-le. Les fichiers CLAUDE.md gonflés font que Claude ignore vos instructions réelles !174### Limitez les règles à une partie de la base de code
171 175
172| ✅ Inclure | ❌ Exclure |176Si une règle ne concerne qu'une partie de la base de code, placez-la dans [`.claude/rules/`](https://code.claude.com/docs/fr/memory#path-specific-rules) avec un filtre `paths:` pour qu'elle ne se charge que lorsque Claude travaille réellement dans cette partie. Par exemple, ce `.claude/rules/api.md` se charge pour les fichiers TypeScript sous `src/api/` :
173| - | - |
174| Commandes Bash que Claude ne peut pas deviner | Tout ce que Claude peut déduire en lisant le code |
175| Règles de style de code qui diffèrent des valeurs par défaut | Conventions de langage standard que Claude connaît déjà |
176| Instructions de test et exécuteurs de test préférés | Documentation API détaillée (lien vers les docs à la place) |
177| Étiquette du référentiel (nommage des branches, conventions PR) | Informations qui changent fréquemment |
178| Décisions architecturales spécifiques à votre projet | Explications longues ou tutoriels |
179| Particularités de l'environnement de développement (variables d'env requises) | Pratiques évidentes comme « écrire du code propre » |
180| Pièges courants ou comportements non évidents | Pratiques évidentes comme « écrire du code propre » |
181 177
182Si Claude continue à faire quelque chose que vous ne voulez pas malgré une règle contre cela, le fichier est probablement trop long et la règle se perd. Si Claude vous pose des questions qui sont répondues dans CLAUDE.md, la formulation pourrait être ambiguë. Traitez CLAUDE.md comme du code : révisez-le lorsque les choses vont mal, élaguez-le régulièrement et testez les modifications en observant si le comportement de Claude change réellement. Pour un CLAUDE.md enregistré, exécutez [`/doctor`](https://code.claude.com/docs/fr/commands#all-commands) et Claude propose des suppressions pour le contenu qu'il peut dériver de la base de code.178```markdown .claude/rules/api.md theme={null}
179---
180paths:
181 - "src/api/**/*.ts"
182---
183- Validate request bodies with the zod schemas in src/api/schemas/, don't hand-roll checks
184- Every new endpoint needs an entry in openapi.yaml, CI fails without it
185```
183 186
184Si Claude continue à ignorer une instruction, ajoutez de l'emphase comme « IMPORTANT » à cette ligne uniquement. Si vous mettez l'accent sur de nombreuses lignes, aucune d'elles ne se démarque. Enregistrez CLAUDE.md dans git pour que votre équipe puisse contribuer. Le fichier augmente en valeur au fil du temps.187### Placez les procédures d'équipe dans des skills
185 188
186Les fichiers CLAUDE.md peuvent importer des fichiers supplémentaires en utilisant la syntaxe `@path/to/import`. Pour les règles d'importation et les emplacements où les fichiers CLAUDE.md peuvent vivre, consultez [fichiers CLAUDE.md](https://code.claude.com/docs/fr/memory.md#claude-md-files).189Un modèle plus performant en sait davantage sur l'ingénierie, mais pas sur la façon dont *votre* équipe réalise une release, ce que dit votre runbook d'incident ou comment vous voulez que la documentation de l'API soit rédigée. Ce type de connaissance va dans un [skill](https://code.claude.com/docs/fr/skills.md) : une procédure ou un élément de connaissance d'équipe enregistré dans `.claude/skills/<name>/SKILL.md`.
187 190
188### Configurez les permissions191Les skills sont aussi plus légers en contexte que `CLAUDE.md` pour ce genre de choses. Pour un skill que Claude peut démarrer de lui-même, il voit le nom et la description dans chaque session, mais ne [lit le fichier complet](https://code.claude.com/docs/fr/skills.md#skill-content-lifecycle) que lorsque la tâche l'exige. Une longue procédure de release placée dans un skill ne pèse pas sur votre correction de bug sans rapport, comme elle le ferait dans `CLAUDE.md`.
189 192
190> [!TIP]193> [!NOTE]
191>194>
192> Pour obtenir moins de prompts sans renoncer au contrôle, pré-approuvez les outils auxquels vous faites confiance avec `/permissions` et laissez les commandes en sandbox s'exécuter sans demander avec `/sandbox`. Basculez en mode Manuel lorsque vous souhaitez approuver les éditions et les commandes vous-même.195> La règle de `CLAUDE.md` s'applique aussi aux skills : n'écrivez que ce que Claude ne peut pas trouver seul.
193 196
194Avec Claude Code v2.1.283 ou version ultérieure, le mode auto est le [mode de permission de démarrage intégré](https://code.claude.com/docs/fr/permission-modes.md#eliminate-prompts-with-auto-mode) pour les sessions de terminal interactif et VS Code : un modèle classificateur séparé examine la plupart des actions au lieu de vous et bloque uniquement ce qui semble risqué, comme l'escalade de portée, l'infrastructure inconnue ou les actions motivées par du contenu hostile. Sur les versions antérieures, le mode auto est le mode de permission de démarrage intégré uniquement sur les plans Pro, Max et Team.197Pour un workflow avec des effets de bord, comme réaliser effectivement cette release, ajoutez `disable-model-invocation: true`. Claude [ne peut alors pas démarrer le skill de lui-même](https://code.claude.com/docs/fr/skills.md#control-who-invokes-a-skill), et celui-ci ne s'exécute que lorsque vous tapez vous-même `/release`. Enregistré sous `.claude/skills/release/SKILL.md`, il pourrait ressembler à ceci :
195 198
196En mode Manuel, Claude Code demande avant les actions qui pourraient modifier votre système : écritures de fichiers, commandes Bash, outils MCP. C'est sûr mais fastidieux. Après la dixième approbation, vous cliquez simplement plutôt que de réviser. Deux outils réduisent ces interruptions en mode Manuel et s'appliquent également en mode auto :199```markdown .claude/skills/release/SKILL.md theme={null}
200---
201name: release
202description: Cut a new release. Bumps the version, writes the changelog entry, tags it and pushes the tag so CI can publish.
203disable-model-invocation: true
204---
2051. Make sure you're on main with a clean tree. If not, stop and ask.
2062. Run `pnpm changeset version` and commit the result.
2073. Summarize the PRs merged since the last tag into CHANGELOG.md, one line each, user-facing changes only.
2084. Tag `v<new version>` and push the tag. CI publishes from there, never publish from your machine.
209```
197 210
198* **Listes blanches de permissions** : permettre des outils spécifiques que vous savez être sûrs, comme `npm run lint` ou `git commit`211### Connectez les outils dont Claude a besoin
199* **Sandboxing** : activer l'isolation au niveau du système d'exploitation qui restreint l'accès au système de fichiers et au réseau, permettant à Claude de travailler plus librement dans des limites définies
200 212
201Lisez plus sur [les modes de permission](https://code.claude.com/docs/fr/permission-modes.md), [les règles de permission](https://code.claude.com/docs/fr/permissions.md) et [le sandboxing](https://code.claude.com/docs/fr/sandboxing.md).213Une partie de ce que Claude ne peut pas voir se trouve entièrement dans un autre système, comme votre outil de suivi des tickets ou votre tableau de bord d'erreurs. Si ce système dispose d'une CLI, c'est généralement le moyen d'accès le plus simple. Avec `gh` installé et connecté, par exemple, Claude ouvrira des pull requests et lira les commentaires de revue sans aucune explication de votre part. Pour une CLI qu'il n'a jamais vue, lui indiquer `--help` suffit.
202 214
203### Utilisez les outils CLI215Pour les systèmes sans CLI, il y a [MCP](https://code.claude.com/docs/fr/mcp.md). Vous ajoutez un serveur depuis votre shell :
204 216
205> [!TIP]217```bash theme={null}
206>218claude mcp add --transport http notion https://mcp.notion.com/mcp
207> Dites à Claude Code d'utiliser les outils CLI comme `gh`, `aws`, `gcloud` et `sentry-cli` lors de l'interaction avec les services externes.219```
220
221Le serveur apparaît ensuite sous `/mcp` dans une session. Les serveurs connectés ajoutent leurs noms d'outils et leurs instructions au contexte même lorsque vous ne les utilisez pas, il vaut donc la peine d'y [désactiver ceux dont vous n'avez pas besoin](https://code.claude.com/docs/fr/mcp.md#disable-a-server-without-removing-it).
222
223Et si vous travaillez dans un langage typé, un [plugin d'intelligence de code](https://code.claude.com/docs/fr/plugins/code-intelligence.md) permet à Claude d'accéder directement à une définition au lieu de parcourir de nombreux fichiers pour la trouver.
208 224
209Les outils CLI sont le moyen le plus efficace en contexte d'interagir avec les services externes. Si vous utilisez GitHub, installez le CLI `gh`. Claude sait comment l'utiliser pour créer des problèmes, ouvrir des demandes de tirage et lire les commentaires. Sans `gh`, Claude peut toujours utiliser l'API GitHub, mais les demandes non authentifiées atteignent souvent les limites de débit.225## Donnez à Claude une vérification à exécuter
210 226
211Claude est également efficace pour apprendre les outils CLI qu'il ne connaît pas déjà. Essayez des invites comme `Utilisez 'foo-cli-tool --help' pour en savoir plus sur l'outil foo, puis utilisez-le pour résoudre A, B, C.`227Claude s'arrête lorsque le travail semble terminé. S'il n'a rien à exécuter qui lui indique si le travail *est* réellement terminé, « semble terminé » est tout ce sur quoi il peut s'appuyer. En pratique, c'est vous qui devenez la suite de tests, et chaque erreur reste là jusqu'à ce que vous la remarquiez.
212 228
213### Connectez les serveurs MCP229Si vous lui donnez quelque chose qui renvoie un résultat de réussite ou d'échec, Claude peut boucler lui-même. Il effectue la modification, exécute la vérification et, si quelque chose a cassé, il lit la sortie et corrige le problème avant de relancer la vérification.
214 230
215> [!TIP]231> [!TIP]
216>232>
217> Exécutez `claude mcp add` avec un nom de serveur et une URL ou une commande pour connecter les outils externes comme Notion, Figma ou votre base de données. Par exemple : `claude mcp add --transport http notion https://mcp.notion.com/mcp`.233> Donnez à Claude quelque chose qu'il peut exécuter et qui renvoie un résultat de réussite ou d'échec. Une fois qu'il dispose de cela, il peut continuer seul et vous n'avez pas à surveiller.
218 234
219Avec les [serveurs MCP](https://code.claude.com/docs/fr/mcp.md), vous pouvez demander à Claude d'implémenter des fonctionnalités à partir de suivi de problèmes, interroger des bases de données, analyser les données de surveillance, intégrer les conceptions de Figma et automatiser les flux de travail.235La vérification peut être presque n'importe quoi, tant que Claude peut lire le résultat :
220 236
221### Configurez les hooks237* Un fichier de test
238* Le code de sortie d'un build
239* Un linter
240* Un script qui compare la sortie à une fixture
241* Une [capture d'écran du navigateur](https://code.claude.com/docs/fr/chrome.md) à côté de la maquette
222 242
223> [!TIP]243Si votre dépôt dispose déjà de l'un de ces éléments, la ligne la plus utile de votre `CLAUDE.md` est la commande qui l'exécute.
224>
225> Utilisez les hooks pour les actions qui doivent se produire à chaque fois sans exception.
226 244
227Les [hooks](https://code.claude.com/docs/fr/hooks-guide.md) exécutent automatiquement les scripts à des points spécifiques du flux de travail de Claude. Contrairement aux instructions CLAUDE.md qui sont consultatives, les hooks sont déterministes et garantissent que l'action se produit.245Le degré de rigueur de la vérification vous appartient. Les options vont de Claude qui décide lui-même jusqu'à Claude Code qui l'impose :
228 246
229Claude peut écrire des hooks pour vous. Essayez des invites comme *« Écrire un hook qui exécute eslint après chaque édition de fichier »* ou *« Écrire un hook qui bloque les écritures dans le dossier migrations. »* Modifiez `.claude/settings.json` directement pour configurer les hooks à la main, et exécutez `/hooks` pour parcourir ce qui est configuré.247* Dans le prompt : `run the auth tests after, and keep going until they pass`. Claude décide lui-même quand il est satisfait. Cela fonctionne pour n'importe quelle tâche, dès aujourd'hui, sans configuration.
248* Comme objectif : [`/goal all tests in tests/auth pass and lint is clean`](https://code.claude.com/docs/fr/goal) définit une condition qu'un modèle distinct vérifie par rapport à la conversation après chaque tour, et Claude continue jusqu'à ce qu'elle soit remplie. Vous en avez rarement besoin vous-même dans la session. Cela compte pour les longues exécutions en arrière-plan, où Claude termine parfois un tour par un résumé de progression alors que des éléments restent ouverts, et l'objectif le renvoie au travail.
249* Comme hook Stop : un [hook `Stop`](https://code.claude.com/docs/fr/hooks#stop) exécute votre script chaque fois que Claude tente de terminer son tour, et renvoie Claude au travail si le script se termine avec le code 2. Celui-ci est imposé par Claude Code (le harnais), donc le tour ne se termine pas tant que la vérification de types n'a pas réussi ou que la [limite de blocages](https://code.claude.com/docs/fr/hooks.md#stop-input) n'est pas atteinte. Il y a un [exemple plus bas](#enforce-the-check-with-a-stop-hook).
250* Par quelqu'un qui n'a pas écrit le code : dans le terminal, [`/code-review`](https://code.claude.com/docs/fr/code-review-local) examine le diff dans un nouveau sous-agent qui n'a jamais vu votre conversation. Il n'est pas influencé par le raisonnement qui a produit le code.
230 251
231### Créez des skills252Quelle que soit l'option utilisée, demandez à Claude des *preuves* : la commande qu'il a exécutée et sa sortie, ou la capture d'écran. « Tous les tests passent » à lui seul vous en dit très peu, et lire la sortie est plus rapide que de relancer la vérification vous-même. Pour une session que vous n'avez pas surveillée, c'est aussi la seule preuve dont vous disposez.
232 253
233> [!TIP]254> [!TIP]
234>255>
235> Créez des fichiers `SKILL.md` dans `.claude/skills/` pour donner à Claude des connaissances de domaine et des flux de travail réutilisables.256> Une fois que Claude dit avoir terminé, vous pouvez aussi exécuter [`/verify`](https://code.claude.com/docs/fr/skills#run-and-verify-your-app) dans la session, ce qui amène Claude à compiler et exécuter l'application et à examiner le résultat. Cela détecte le genre de problème que les tests et la vérification de types manquent.
236 257
237Les [skills](https://code.claude.com/docs/fr/skills.md) étendent les connaissances de Claude avec des informations spécifiques à votre projet, équipe ou domaine. Claude les applique automatiquement lorsqu'elles sont pertinentes, ou vous pouvez les invoquer directement avec `/skill-name`.258### Vérifiez par rapport à votre spécification
238 259
239Créez une skill en ajoutant un répertoire avec un `SKILL.md` à `.claude/skills/` :260Si vous préférez que la revue vérifie le travail par rapport à votre plan plutôt que de chercher des bugs en général, écrivez vous-même le prompt de revue :
240 261
241```markdown .claude/skills/api-conventions/SKILL.md theme={null}262```text theme={null}
242name: api-conventions263use a subagent to review the rate limiter diff against SPEC.md, check every requirement is implemented and the listed edge cases have tests, report gaps that affect correctness and skip style
243description: REST API design conventions for our services
244# API Conventions
245- Use kebab-case for URL paths
246- Use camelCase for JSON properties
247- Always include pagination for list endpoints
248- Version APIs in the URL path (/v1/, /v2/)
249```264```
250 265
251Les skills peuvent également définir des flux de travail réutilisables que vous invoquez directement :266> [!NOTE]
252 267>
253```markdown .claude/skills/fix-issue/SKILL.md theme={null}268> Ne supprimez pas la partie `skip style` de ce prompt. Un relecteur à qui l'on demande de trouver des problèmes trouvera toujours *quelque chose*. Si vous corrigez chaque constatation, vous vous retrouvez avec des couches d'abstraction supplémentaires et des tests pour des cas qui ne peuvent pas se produire.
254name: fix-issue269
255description: Fix a GitHub issue270### Imposez la vérification avec un hook Stop
256disable-model-invocation: true271
257Analyze and fix the GitHub issue: $ARGUMENTS.272La version hook `Stop` de la règle de vérification de types tient en quelques lignes dans `.claude/settings.json`. C'est le code de sortie 2 qui bloque l'arrêt. Tout ce que la commande affiche sur stderr est renvoyé à Claude comme la raison pour laquelle il ne peut pas encore terminer, c'est pourquoi la sortie du compilateur y est redirigée :
258 273
2591. Use `gh issue view` to get the issue details274```json .claude/settings.json theme={null}
2602. Understand the problem described in the issue275{
2613. Search the codebase for relevant files276 "hooks": {
2624. Implement the necessary changes to fix the issue277 "Stop": [
2635. Write and run tests to verify the fix278 {
2646. Ensure code passes linting and type checking279 "hooks": [
2657. Create a descriptive commit message280 { "type": "command", "command": "pnpm tsc --noEmit 1>&2 || exit 2" }
2668. Push and create a PR281 ]
282 }
283 ]
284 }
285}
267```286```
268 287
269Exécutez `/fix-issue 1234` pour l'invoquer. Utilisez `disable-model-invocation: true` pour les flux de travail avec des effets secondaires que vous souhaitez déclencher manuellement.288Pour le voir fonctionner, demandez à Claude une modification qui casse un type : au lieu de terminer, il reçoit les erreurs du compilateur et continue jusqu'à ce que `tsc` réussisse. Si le hook bloque [huit arrêts d'affilée](https://code.claude.com/docs/fr/hooks.md#stop-input) sans appel d'outil entre eux, Claude Code outrepasse le blocage suivant et termine le tour. Pour augmenter ce plafond, définissez [`CLAUDE_CODE_STOP_HOOK_BLOCK_CAP`](https://code.claude.com/docs/fr/env-vars).
270 289
271### Créez des subagents personnalisés290## Imposez les règles qui ne tolèrent aucune exception
272 291
273> [!TIP]292> [!TIP]
274>293>
275> Définissez des assistants spécialisés dans `.claude/agents/` que Claude peut déléguer pour les tâches isolées.294> Si quelque chose doit se produire à chaque fois, faites-en un hook, une règle de refus ou un paramètre géré. `CLAUDE.md` est destiné aux directives, et Claude a le droit de décider qu'une directive ne s'applique pas.
276 295
277Les [subagents](https://code.claude.com/docs/fr/sub-agents.md) s'exécutent dans leur propre contexte avec leur propre ensemble d'outils autorisés. Ils sont utiles pour les tâches qui lisent de nombreux fichiers ou qui ont besoin d'une attention spécialisée sans encombrer votre conversation principale.296Prenez trois règles que vous pourriez avoir aujourd'hui dans `CLAUDE.md` : `Never read .env`, `Always run the formatter after editing`, `Don't touch the migrations folder`. Claude les suivra presque à chaque fois. Pour les quelques cas où « presque » ne suffit pas, sortez-les de `CLAUDE.md` et placez-les dans une configuration que Claude Code (le harnais) applique lui-même. Dès lors, le résultat ne dépend plus de ce dont le modèle se souvient ou de ce qu'il décide.
278 297
279```markdown .claude/agents/security-reviewer.md theme={null}298### Imposez des étapes avec des hooks
280name: security-reviewer299
281description: Reviews code for security vulnerabilities300Les [hooks](https://code.claude.com/docs/fr/hooks-guide.md) exécutent quelque chose qui vous appartient à des points fixes de la boucle de Claude : avant ou après un appel d'outil, lorsque Claude tente de s'arrêter, au démarrage d'une session, etc. Ce quelque chose peut être :
282tools: Read, Grep, Glob, Bash301
283model: opus302* Une commande shell (le cas habituel)
284You are a senior security engineer. Review code for:303* Un POST vers un endpoint HTTP
285- Injection vulnerabilities (SQL, XSS, command injection)304* Un appel d'outil sur l'un de vos serveurs MCP
286- Authentication and authorization flaws305* Un [hook `prompt` ou `agent`](https://code.claude.com/docs/fr/hooks#hook-handler-fields), qui laisse un modèle décider
287- Secrets or credentials in code306
288- Insecure data handling307Un hook `prompt` ou `agent` demande à *un autre modèle* de décider, il n'est donc pas déterministe non plus. Pour une véritable application, utilisez un hook `command` ou `http`, et ajoutez [`onFailure: "block"`](https://code.claude.com/docs/fr/hooks#block-the-action-when-a-hook-fails) si l'action doit aussi être arrêtée lorsque le hook lui-même plante ou expire. Pour un hook qui analyse les commits à la recherche de secrets, par exemple, vous préférez bloquer le commit plutôt que de le laisser passer sans analyse pendant que le scanner est en panne.
308
309Voici la règle du formateur sous forme de hook `PostToolUse`. Il s'exécute après chaque `Edit` ou `Write`, et le fait que Claude se souvienne de la règle n'a plus d'importance, car ce n'est pas Claude qui l'exécute :
289 310
290Provide specific line references and suggested fixes.311```json .claude/settings.json theme={null}
312{
313 "hooks": {
314 "PostToolUse": [
315 {
316 "matcher": "Edit|Write",
317 "hooks": [
318 { "type": "command", "command": "npx prettier --write --ignore-unknown \"$(jq -r '.tool_input.file_path')\"" }
319 ]
320 }
321 ]
322 }
323}
291```324```
292 325
293Dites à Claude d'utiliser les subagents explicitement : *« Utilisez un subagent pour réviser ce code pour les problèmes de sécurité. »*326Pour tester le hook, demandez à Claude d'ajouter une ligne mal indentée dans un fichier que Prettier formate. Le fichier enregistré revient avec l'indentation corrigée.
294 327
295### Installez les plugins328La règle des migrations devient un [hook `PreToolUse`](https://code.claude.com/docs/fr/hooks-guide#block-edits-to-protected-files) qui se termine avec le code 2 pour tout chemin sous `migrations/`. Vous n'avez pas à l'écrire vous-même : `write a hook that blocks edits to the migrations folder` fonctionne comme prompt, et `/hooks` affiche le résultat. N'en abusez pas, cependant : un hook est destiné à une règle sans *aucune* exception, et `Prefer named exports` en a beaucoup, donc celle-ci reste dans `CLAUDE.md`.
296 329
297> [!TIP]330### Limitez l'accès avec les règles de permission et le sandbox
298>
299> Exécutez `/plugin` pour parcourir la marketplace. Les plugins ajoutent des skills, des outils et des intégrations sans configuration.
300 331
301Les [plugins](https://code.claude.com/docs/fr/plugins/overview.md) regroupent les skills, les hooks, les subagents et les serveurs MCP dans une seule unité installable de la communauté et d'Anthropic. Si vous travaillez avec un langage typé, installez un [plugin d'intelligence de code](https://code.claude.com/docs/fr/plugins/code-intelligence.md) pour donner à Claude une navigation de symboles précise et une détection d'erreur automatique après les éditions.332Les [règles de permission](https://code.claude.com/docs/fr/permissions.md) déterminent ce que Claude est autorisé à exécuter, lire et récupérer. Les règles `deny` s'appliquent dans tous les modes de permission, y compris auto et `bypassPermissions`, et c'est précisément pourquoi la règle `.env` y a sa place :
302 333
303Pour des conseils sur le choix entre les skills, les subagents, les hooks et MCP, consultez [Étendre Claude Code](https://code.claude.com/docs/fr/features-overview.md#match-features-to-your-goal).334```json .claude/settings.json theme={null}
335{
336 "permissions": {
337 "allow": ["Bash(pnpm tsc --noEmit)"],
338 "ask": ["Bash(git push *)"],
339 "deny": ["Read(./.env)", "Read(./.env.local)", "Read(./secrets/**)"]
340 }
341}
342```
304 343
305***344Une fois ceci enregistré, demander à Claude ce que contient `.env` échoue, aussi bien via l'outil `Read` que via `cat .env`.
306 345
307## Communiquez efficacement346Les règles correspondent à des appels d'outils, pas à des intentions, il vaut donc la peine de savoir où se situent leurs limites :
308 347
309Posez à Claude les questions que vous poseriez à un autre ingénieur, et pour les fonctionnalités plus importantes, laissez Claude vous interviewer et rédiger une spécification avant de commencer l'implémentation.348* La règle `Read` *intercepte bien* `cat .env`, car Claude Code reconnaît les [commandes courantes de lecture de fichiers](https://code.claude.com/docs/fr/permissions.md#read-and-edit).
349* Elle n'interceptera pas un script qui ouvre le fichier.
350* Une règle de refus `WebFetch` pour un domaine n'a aucun effet sur un `curl` vers ce même domaine, sauf si le sandbox est activé.
310 351
311### Posez des questions sur la base de code352Pour une limite au niveau du système d'exploitation sur l'accès au système de fichiers ou au réseau, activez le [sandbox](https://code.claude.com/docs/fr/sandboxing.md) avec `/sandbox` dans une session. Il confine les commandes shell de Claude sur macOS, Linux et WSL2 et [reprend aussi vos règles de refus `Read` et vos règles `WebFetch(domain:...)`](https://code.claude.com/docs/fr/sandboxing#permission-rules), donc pour tout ce qui touche à la sécurité, vous voulez les deux.
312 353
313> [!TIP]354Par défaut, Claude peut toujours demander à réessayer une commande bloquée en dehors du sandbox, et cette demande passe par le flux de permission normal. Le [mode sandbox strict](https://code.claude.com/docs/fr/sandboxing.md#turn-off-the-retry-with-strict-sandbox-mode), dans l'onglet **Overrides** de `/sandbox`, désactive cette nouvelle tentative.
355
356> [!WARNING]
314>357>
315> Posez à Claude les questions que vous poseriez à un ingénieur senior.358> Le mode auto est un modèle classifieur qui juge chaque action plutôt qu'une règle stricte. Il le fait bien, mais comme tout jugement, il peut se tromper. Vous pouvez aussi ajuster ce qu'il considère comme risqué, et votre organisation peut le désactiver entièrement, donc vos règles « jamais » ont leur place dans des règles de refus ou des hooks.
359
360### Choisissez à qui s'applique une règle
316 361
317Lors de l'intégration à une nouvelle base de code, utilisez Claude Code pour l'apprentissage et l'exploration. Vous pouvez poser à Claude les mêmes types de questions que vous poseriez à un autre ingénieur :362L'emplacement d'une règle détermine à qui elle s'applique :
318 363
319* Comment fonctionne la journalisation ?364* `.claude/settings.local.json` et `~/.claude/settings.json` ne concernent que vous. Lorsque vous sélectionnez **Yes, and don't ask again** pour une commande, Claude Code enregistre cette règle dans le fichier local.
320* Comment créer un nouveau point de terminaison API ?365* `.claude/settings.json` et les hooks qu'il contient appartiennent au dépôt. Une fois que vous les avez commités, ils s'appliquent à toute personne qui travaille dans le dépôt. Ses règles de refus s'appliquent immédiatement. Ses règles `allow` attendent que chaque personne accepte la [boîte de dialogue de confiance](https://code.claude.com/docs/fr/permissions.md#what-runs-before-you-trust-a-folder) pour ce dossier, et la [confiance de l'espace de travail](https://code.claude.com/docs/fr/hooks.md#workspace-trust) détermine aussi quand ses hooks commencent à s'exécuter sur sa machine.
321* Que fait `async move { ... }` à la ligne 134 de `foo.rs` ?366* Les [paramètres gérés](https://code.claude.com/docs/fr/managed-settings.md) appartiennent à l'organisation. Ils proviennent de la console d'administration, d'un MDM ou d'un fichier `managed-settings.json`, et aucun fichier de paramètres personnel ne peut les outrepasser, ce qui en fait le seul endroit approprié pour la politique d'une équipe de sécurité. Si c'est vous qui les définissez, consultez [Configurer Claude Code pour votre organisation](https://code.claude.com/docs/fr/admin-setup.md).
322* Quels cas limites `CustomerOnboardingFlowImpl` gère-t-il ?
323* Pourquoi ce code appelle-t-il `foo()` au lieu de `bar()` à la ligne 333 ?
324 367
325Utiliser Claude Code de cette façon est un flux de travail d'intégration efficace, améliorant le temps de montée en charge et réduisant la charge sur les autres ingénieurs. Aucune invite spéciale requise : posez les questions directement.368Quelle que soit la portée, gardez l'ensemble imposé restreint. Chaque hook et chaque règle de refus se déclenchera parfois alors qu'il ne le devrait pas, et quelqu'un doit maintenir chacun d'eux. Si vous vous retrouvez un jour avec quarante d'entre eux, la plupart sont probablement des préférences que Claude aurait pu évaluer lui-même.
326 369
327### Laissez Claude vous interviewer370## Modifiez une valeur par défaut
328 371
329> [!TIP]372> [!TIP]
330>373>
331> Pour les fonctionnalités plus grandes, laissez Claude vous interviewer d'abord. Commencez par une invite minimale et demandez à Claude de vous interviewer en utilisant l'outil `AskUserQuestion`.374> Les valeurs par défaut sont assez bonnes pour ne pas y toucher jusqu'à ce qu'une tâche coûte plus de temps, de tokens ou d'interruptions qu'elle ne le devrait. Lorsque cela arrive, exécutez `/usage` dans la session pour voir où cela est passé.
332 375
333Claude pose des questions sur les choses que vous n'auriez peut-être pas considérées, y compris l'implémentation technique, l'interface utilisateur/UX, les cas limites et les compromis. Remplacez `[brief description]` par votre fonctionnalité avant d'envoyer l'invite.376Une nouvelle session prend déjà plusieurs décisions pour vous :
334 377
335```text wrap theme={null}378* Les sessions interactives de terminal et VS Code démarrent en mode auto.
336I want to build [brief description]. Interview me in detail using the AskUserQuestion tool.379* Elle exécute [Claude Opus 5.5 avec un effort moyen](https://code.claude.com/docs/fr/model-config.md#default-model-setting) sur la plupart des plans et fournisseurs.
380* Elle délègue du travail à des sous-agents lorsqu'elle voit une raison de le faire.
381* Elle compacte la conversation à mesure qu'elle grandit.
337 382
338Ask about technical implementation, UI/UX, edge cases, concerns, and tradeoffs. Don't ask obvious questions, dig into the hard parts I might not have considered.383La plupart du temps, vous n'y pensez jamais. Lorsqu'une tâche coûte plus qu'elle ne le devrait, c'est généralement à cause de l'un de ces quatre points.
339 384
340Keep interviewing until we've covered everything, then write a complete spec to SPEC.md.385### Changez le mode de permission
341```
342 386
343Une fois la spécification complète, démarrez une nouvelle session pour l'exécuter. La nouvelle session a un contexte propre entièrement axé sur l'implémentation, et vous avez une spécification écrite à référencer.387Les deux extrémités de l'éventail des permissions ont un coût :
344 388
345Les spécifications les plus utiles sont autonomes : elles nomment les fichiers et les interfaces impliqués, énoncent ce qui est hors de portée, et se terminent par une étape de vérification de bout en bout qui prouve que la fonctionnalité fonctionne. Le temps consacré à rendre la spécification précise rapporte plus que le temps passé à regarder l'implémentation.389* **Mode Manuel** : vous approuvez vous-même chaque modification et chaque commande qui n'est pas en lecture seule. C'est sûr, mais après la dixième demande vous commencez à approuver sans lire, et rien n'avance lorsque vous êtes loin du clavier.
390* **`bypassPermissions`** : approuve tout ce que vos règles de refus et de demande ne couvrent pas, ce qui n'a de sens que dans un conteneur jetable.
346 391
347***392Le [mode auto](https://code.claude.com/docs/fr/permission-modes.md#eliminate-prompts-with-auto-mode) se situe entre les deux, et c'est le mode dans lequel [démarrent](https://code.claude.com/docs/fr/permission-modes.md#which-mode-a-session-starts-in) les sessions interactives de terminal et VS Code. Claude travaille sans s'arrêter pour les approbations de routine, et un modèle classifieur distinct vérifie les actions dans [un ordre fixe](https://code.claude.com/docs/fr/permission-modes.md#how-the-classifier-evaluates-actions) avant leur exécution. Il se concentre sur [les choses qu'une personne voudrait arrêter](https://code.claude.com/docs/fr/permission-modes.md#what-the-classifier-blocks-by-default) :
348 393
349## Gérez votre session394* `curl | bash`
395* Les déploiements et migrations en production
396* Les force push par-dessus le travail d'autres personnes
397* Les données sensibles envoyées vers des endpoints externes
398* Les actions qui semblent dictées par du contenu que Claude a lu plutôt que par vous
350 399
351Les conversations sont persistantes et réversibles. Utilisez cela à votre avantage !400Lorsqu'il bloque quelque chose, vous recevez une notification et l'action apparaît sous **Recently denied** dans `/permissions`, où vous pouvez la réessayer avec une approbation manuelle. Après [trois blocages d'affilée](https://code.claude.com/docs/fr/permission-modes.md#when-auto-mode-falls-back) (ou vingt au total), le mode auto se met en pause et recommence à vous demander.
352 401
353### Corrigez la trajectoire tôt et souvent402Rien de tout cela ne remplace vos contrôles déterministes, car il s'exécute *après* eux. Les règles de refus et de demande ainsi que les hooks `PreToolUse` s'appliquent avant que le classifieur ne voie quoi que ce soit, donc une règle de refus bloque en mode auto exactement comme partout ailleurs. Le sandbox continue de confiner les [commandes shell qu'il encapsule](https://code.claude.com/docs/fr/sandboxing.md#what-runs-outside-the-sandbox).
354 403
355> [!TIP]404> [!NOTE]
356>405>
357> Corrigez Claude dès que vous remarquez qu'il s'écarte de la bonne voie.406> Vous pouvez aussi écrire `don't push until I've reviewed` dans la conversation, et le classifieur [le traite comme un signal de blocage](https://code.claude.com/docs/fr/permission-modes.md#boundaries-you-state-in-conversation). Il s'agit toujours d'un modèle qui lit la transcription, et la phrase peut se perdre lors de la compaction de la conversation, donc tout ce qui compte a sa place dans une règle de refus.
407
408Le problème inverse est celui d'un classifieur qui arrête à plusieurs reprises quelque chose de courant dans votre configuration. Plutôt que de l'approuver manuellement à chaque fois, ajoutez-le à `autoMode.allow` ou décrivez votre infrastructure de confiance dans la [configuration du mode auto](https://code.claude.com/docs/fr/auto-mode-config.md). Elle s'écrit en anglais courant plutôt qu'avec des motifs, et [`/auto-mode-setup`](https://code.claude.com/docs/fr/auto-mode-config#generate-environment-entries) peut rédiger pour vous la partie `environment` à partir de votre projet et de vos sessions récentes :
409
410```json ~/.claude/settings.json theme={null}
411{
412 "autoMode": {
413 "environment": [
414 "$defaults",
415 "Source control: github.com/example-org and every repo under it",
416 "Trusted internal domains: *.internal.example.com"
417 ],
418 "allow": [
419 "$defaults",
420 "Deploying to the staging namespace is fine, it's isolated from production and resets nightly"
421 ]
422 }
423}
424```
358 425
359Les meilleurs résultats proviennent de boucles de rétroaction serrées. Bien que Claude résolve occasionnellement les problèmes parfaitement à la première tentative, le corriger rapidement produit généralement de meilleures solutions plus rapidement.426> [!WARNING]
427>
428> Conservez `"$defaults"` dans chaque liste que vous définissez, car sans lui vos entrées *remplacent* les règles intégrées de cette liste au lieu de s'y ajouter. Pour `environment` et `allow`, vous perdriez le contexte et les exceptions intégrés, et une liste `soft_deny` sans lui supprime les blocages intégrés des force push et des déploiements en production.
429>
430> Le bloc `autoMode` doit aussi se trouver dans `~/.claude/settings.json` plutôt que dans le projet, car le classifieur ignore `autoMode` dans les paramètres du projet.
360 431
361* **`Esc`** : arrêtez Claude en pleine action avec la touche `Esc`. Le contexte est préservé, vous pouvez donc rediriger.432Si vous préférez voir chaque modification et chaque commande avant qu'elles ne se produisent, `Shift+Tab` dans la session fait défiler les modes de permission, Manuel compris, ou démarrez avec `claude --permission-mode manual` depuis votre shell. Et si le mode Manuel vous sollicite alors trop souvent, `/fewer-permission-prompts` analyse vos transcriptions récentes à la recherche d'appels Bash et MCP courants en lecture seule et les ajoute à une liste d'autorisation dans `.claude/settings.json`.
362* **`Esc + Esc` ou `/rewind`** : appuyez sur `Esc` deux fois ou exécutez `/rewind` pour ouvrir le menu de rembobinage et restaurer la conversation et l'état du code précédents, ou résumer à partir d'un message sélectionné.
363* **`« Annuler cela »`** : demandez à Claude d'annuler ses modifications.
364* **`/clear`** : réinitialiser le contexte entre les tâches non liées. Les sessions longues avec un contexte non pertinent peuvent réduire les performances.
365 433
366Si vous avez corrigé Claude plus de deux fois sur le même problème dans une session, le contexte est encombré d'approches échouées. Exécutez `/clear` et recommencez avec une invite plus spécifique qui incorpore ce que vous avez appris. Une session propre avec une meilleure invite surpasse presque toujours une session longue avec des corrections accumulées.434### Changez le modèle et l'effort
367 435
368### Gérez le contexte agressivement436L'[effort](https://code.claude.com/docs/fr/model-config.md#adjust-effort-level) est le principal contrôle de la durée de réflexion de Claude, et il remplace la plupart de ce que l'on faisait autrefois avec la formulation des prompts. Claude Opus 5.5, Sonnet 5.5 et Haiku 5.5 utilisent `medium` par défaut, ce qui suffit largement pour le développement de fonctionnalités courantes avec un périmètre clair. Les moments où vous le modifieriez, avec `/effort` dans la session :
369 437
370> [!TIP]438* Augmentez-le avec `/effort high` ou `/effort xhigh` lorsque la réussite dépend de cas faciles à négliger. Pensez à un bug dans du code que vous n'avez pas écrit, à un test instable ou à un changement de schéma où Claude doit trouver chaque lecteur de l'ancienne forme. Claude vérifie alors davantage de cas limites et une plus grande partie de son travail avant de répondre, et c'est là que passent le temps et les tokens supplémentaires.
371>439* Réduisez-le avec `/effort low` lorsque vous faites des allers-retours rapides et examinez de toute façon chaque résultat : brainstorming, première ébauche, renommage dans quelques fichiers. Claude vous donne un point de départ plus tôt, et puisque vous pilotez chaque étape, la délibération supplémentaire n'aurait pas changé grand-chose à part l'attente.
372> Exécutez `/clear` entre les tâches non liées pour réinitialiser le contexte.440* Réservez `max` à un problème difficile que vous voulez que Claude résolve sans vous, comme la recherche d'une vulnérabilité de sécurité. Sur des tâches ordinaires, il a tendance à trop réfléchir, et vous payez donc davantage pour une réponse qui n'est peut-être pas meilleure que ce que `high` vous aurait donné.
441* Lorsque seul le message suivant en a besoin, comme une question délicate au milieu d'un travail par ailleurs courant, mettez [`ultrathink`](https://code.claude.com/docs/fr/model-config#use-ultrathink-for-one-off-deep-reasoning) dans ce prompt au lieu de modifier le paramètre.
373 442
374Claude Code compacte automatiquement l'historique de conversation lorsque vous approchez des limites de contexte, ce qui préserve le code et les décisions importants tout en libérant de l'espace.443Pour le modèle lui-même, Opus 5.5 par défaut gère bien la plupart des tâches de code et Sonnet coûte moins cher sur le travail courant. [Claude Fable 5.1](https://code.claude.com/docs/fr/model-config.md#work-with-fable) est disponible lorsque vous le sélectionnez explicitement avec `/model fable`, et Haiku convient bien aux sous-agents effectuant des tâches simples. [Configuration du modèle](https://code.claude.com/docs/fr/model-config.md) présente la liste complète par plan et fournisseur.
375 444
376Pendant les sessions longues, la fenêtre de contexte de Claude peut se remplir de conversations non pertinentes, de contenu de fichiers et de commandes. Cela peut réduire les performances et parfois distraire Claude.445### Sachez ce que coûtent les sous-agents
377 446
378* Utilisez `/clear` fréquemment entre les tâches pour réinitialiser complètement la fenêtre de contexte447Claude délègue de lui-même à des [sous-agents](https://code.claude.com/docs/fr/sub-agents.md) :
379* Lorsque le compactage automatique se déclenche, Claude résume ce qui importe le plus, y compris les modèles de code, les états de fichiers et les décisions clés
380* Pour plus de contrôle, exécutez `/compact <instructions>`, comme `/compact Focus on the API changes`
381* Pour compacter uniquement une partie de la conversation, utilisez `Esc + Esc` ou `/rewind`, sélectionnez un point de contrôle de message et choisissez **Summarize from here** ou **Summarize up to here**. Le premier condense les messages à partir de ce point tout en gardant le contexte antérieur intact ; le second condense les messages antérieurs tout en gardant les messages récents en intégralité. Consultez [le menu de rembobinage options de résumé](https://code.claude.com/docs/fr/checkpointing.md#rewind-and-summarize).
382* Personnalisez le comportement de compactage dans CLAUDE.md avec des instructions comme `« Lors du compactage, toujours préserver la liste complète des fichiers modifiés et toutes les commandes de test »` pour assurer que le contexte critique survit à la résumé
383* Pour les questions qui n'ont pas besoin de rester en contexte, utilisez [`/btw`](https://code.claude.com/docs/fr/interactive-mode#side-questions-with-%2Fbtw). La réponse n'entre jamais dans l'historique de conversation, vous pouvez donc vérifier un détail sans augmenter le contexte.
384 448
385### Utilisez les subagents pour l'investigation449* Les recherches étendues dans la base de code vont à l'agent Explore intégré.
450* Les tâches annexes sont [forkées](https://code.claude.com/docs/fr/sub-agents.md#fork-the-current-conversation) lorsque le mode fork est activé (par défaut).
451* Les sous-agents qu'il démarre s'exécutent en arrière-plan par défaut, afin que votre conversation principale continue d'avancer.
386 452
387> [!TIP]453Vous avez rarement besoin de demander quoi que ce soit de cela, mais il est utile de savoir ce que vous obtenez et ce que cela coûte.
388>
389> Déléguez la recherche avec `« utiliser les subagents pour enquêter sur X »`. Ils explorent dans un contexte séparé, gardant votre conversation principale propre pour l'implémentation.
390 454
391Puisque le contexte est votre contrainte fondamentale, utilisez les subagents pour garder la recherche en dehors de celui-ci. Lorsque Claude enquête sur une base de code, il lit de nombreux fichiers, qui consomment tous votre contexte. Les subagents s'exécutent dans des fenêtres de contexte séparées et rapportent les résumés :455Les sous-agents sont rentables dans ces situations :
392 456
393```text wrap theme={null}457* Exécuter des travaux indépendants en même temps, pour que l'ensemble de la tâche se termine plus tôt
394Use subagents to investigate how our authentication system handles token458* Garder une sortie longue, comme une exécution complète des tests ou une recherche étendue, hors de votre conversation principale, où elle resterait sinon présente pour le reste de la session
395refresh, and whether we have any existing OAuth utilities I should reuse.459* Obtenir un relecteur qui n'a pas vu comment le code a été écrit
396```460* Donner à une tâche moins d'outils que n'en a la session principale, comme un relecteur qui peut lire mais pas modifier
397 461
398Vous pouvez également utiliser les subagents pour la vérification après que Claude implémente quelque chose. Consultez [Ajouter une étape d'examen contradictoire](#add-an-adversarial-review-step).462Ce qu'ils vous coûtent, ce sont surtout des tokens, puisque chaque sous-agent envoie ses propres requêtes et que celles-ci sont décomptées de la même utilisation que votre conversation principale. Parfois, c'est aussi du temps : un nouveau sous-agent doit d'abord rassembler un contexte que votre conversation avait déjà, et il peut donc finir par être *plus lent* que si vous faisiez la tâche sur place.
399 463
400### Rembobinez avec des points de contrôle464Et par défaut, c'est le même modèle (ou un plus petit) sur la même tâche. Vous en retirez du parallélisme ou un regard neuf, mais pas une réponse plus intelligente.
401 465
402> [!TIP]466Pour dépenser moins pour eux :
403>
404> Chaque invite que vous envoyez crée un point de contrôle. Vous pouvez restaurer la conversation, le code ou les deux à n'importe quel point de contrôle précédent.
405 467
406Claude crée automatiquement des instantanés de fichiers avant chaque modification afin qu'un point de contrôle puisse les restaurer. Appuyez deux fois sur `Escape` ou exécutez `/rewind` pour ouvrir le menu de rembobinage. Vous pouvez restaurer la conversation uniquement, restaurer le code uniquement, restaurer les deux ou résumer à partir d'un message sélectionné. Consultez [Checkpointing](https://code.claude.com/docs/fr/checkpointing.md) pour plus de détails.468* Définissez [`model: haiku`](https://code.claude.com/docs/fr/sub-agents#choose-a-model) dans la définition d'un sous-agent si son travail est simple, comme recenser les fichiers qui importent un module ou vérifier les liens de la documentation. Ce genre de tâche n'a pas besoin du plus grand modèle, et Haiku coûte beaucoup moins cher par requête.
469* Demandez des résumés courts en retour, pour que vingt résultats ne remplissent pas votre contexte quand même.
470* Consultez `/usage` pour voir quelle part de votre utilisation prend chaque type de sous-agent, afin de savoir lesquels justifient leur coût.
471* Donnez à un sous-agent personnalisé dans `.claude/agents/` uniquement `tools: Read, Grep, Glob`. C'est alors un relecteur qui ne peut rien modifier, et cette limite est imposée par Claude Code plutôt que demandée dans un prompt.
407 472
408Au lieu de planifier soigneusement chaque mouvement, vous pouvez dire à Claude d'essayer quelque chose de risqué. Si cela ne fonctionne pas, rembobinez et essayez une approche différente. Les points de contrôle persistent entre les sessions, vous pouvez donc fermer votre terminal et toujours rembobiner plus tard.473Ce relecteur tient en un court fichier, `.claude/agents/reviewer.md` :
409 474
410> [!WARNING]475```markdown .claude/agents/reviewer.md theme={null}
411>476---
412> Les points de contrôle ne suivent que les modifications apportées par les outils d'édition de fichiers de Claude. Les modifications apportées par des commandes Bash ou des processus externes ne sont pas capturées. Ce n'est pas un remplacement pour git.477name: reviewer
478description: Reviews changed files against the spec they were built from. Use after implementing a feature, before opening the PR.
479tools: Read, Grep, Glob
480---
481You're reviewing code you didn't write. Compare the changed files against the spec you're given,
482check that every requirement is implemented and the listed edge cases have tests,
483and report only the gaps that affect correctness. Skip style.
484```
413 485
414### Reprenez les conversations486Demandez à Claude `have the reviewer compare the rate limiter against SPEC.md` et les lacunes reviennent dans votre session, où Claude peut les corriger.
415 487
416> [!TIP]488### Maîtrisez le coût et le contexte
417>
418> Nommez les sessions avec `/rename` et traitez-les comme des branches : chaque flux de travail obtient son propre contexte persistant.
419 489
420Claude Code enregistre les conversations localement, donc lorsqu'une tâche s'étend sur plusieurs sessions, vous n'avez pas à réexpliquer le contexte. Exécutez [`claude --continue`](https://code.claude.com/docs/fr/sessions#resume-a-session) pour reprendre la session la plus récente, ou `claude --resume` pour choisir parmi une liste. Donnez aux sessions des noms descriptifs comme `oauth-migration` afin de pouvoir les trouver plus tard. Consultez [Manage sessions](https://code.claude.com/docs/fr/sessions.md) pour l'ensemble complet des contrôles de reprise, de branchement et de nommage.490Avec une fenêtre de 1M de tokens sur la plupart des modèles actuels et une compaction proche de sa limite, vous manquerez rarement de contexte. Vous pouvez cependant toujours *payer* pour du contexte dont vous n'avez pas besoin. Chaque requête envoie toute la conversation, donc une session qui a accumulé trois tâches sans rapport relit les trois à chaque tour de la quatrième. C'est [à prix réduit tant que le cache est chaud](https://code.claude.com/docs/fr/costs.md#why-usage-climbs-in-a-long-session) et à plein tarif une fois qu'il a expiré.
421 491
422***492[`/usage`](https://code.claude.com/docs/fr/costs) est le premier endroit où regarder. Sur Pro, Max, Team et Enterprise, il ventile votre utilisation par skill, sous-agent, plugin et serveur MCP. Il signale aussi des tendances comme un contexte long ou des défauts de cache fréquents dès que l'une d'elles dépasse 10 % de votre utilisation. À partir de là, les solutions habituelles :
423 493
424## Automatisez et mettez à l'échelle494* `/clear` entre des tâches sans rapport. Cela ne coûte rien, et la tâche suivante ne continue pas à payer pour l'historique de la précédente. `/clear oauth-migration` nomme la session que vous quittez, afin que vous puissiez y revenir plus tard.
495* `/compact` avec un objectif, comme `/compact keep the API changes and the test commands`. Sur une longue session, `/compact` est lui-même une grosse requête, puisqu'il lit toute la conversation pour la résumer, et plus encore une fois le cache expiré.
496* Gardez un œil sur le travail en arrière-plan : un `/loop`, la vérification d'un objectif après chaque tour et les propres sous-agents de Claude continuent tous d'envoyer des requêtes pendant que vous ne tapez pas.
425 497
426Une fois que vous êtes efficace avec un Claude, multipliez votre production avec des sessions parallèles, le mode non interactif et les modèles de fan-out.498> [!NOTE]
499>
500> Le [prompt caching](https://code.claude.com/docs/fr/prompt-caching.md) dure environ une heure avec un abonnement et cinq minutes avec une clé API, un fournisseur cloud ou des crédits d'utilisation. Les sous-agents disposent de cinq minutes sauf si vous le modifiez.
501>
502> Avec le cache d'une heure, une session de plus d'environ 200K tokens qui reste inactive est compactée peu avant l'expiration du cache, donc après le déjeuner vous reprenez à partir d'un résumé. Si vous n'avez pas du tout besoin de l'historique, une nouvelle session coûte encore moins cher.
427 503
428### Exécutez le mode non interactif504## Pilotez la session
429 505
430> [!TIP]506> [!TIP]
431>507>
432> Utilisez `claude -p "prompt"` dans CI, les hooks de pré-commit ou les scripts. Ajoutez `--output-format stream-json --verbose` pour la sortie JSON en streaming.508> Surveillez la première minute, appuyez sur `Esc` dès que Claude dévie, et après deux corrections infructueuses, exécutez `/clear` et écrivez un meilleur prompt au lieu d'une troisième correction.
433 509
434Avec `claude -p "your prompt"`, vous pouvez exécuter Claude de manière non interactive, sans prompt interactif. L'exécution crée tout de même une session pouvant être reprise, à moins que vous ne transmettiez `--no-session-persistence`. Le [mode non interactif](https://code.claude.com/docs/fr/headless.md) est la façon dont vous intégrez Claude dans les pipelines CI, les hooks de pré-commit ou tout workflow automatisé. Les formats de sortie vous permettent d'analyser les résultats par programmation : texte brut, JSON ou JSON en streaming.510Aucune configuration ne remplace le fait de surveiller la première minute et d'intervenir lorsque Claude part dans une direction que vous n'aviez pas prévue. Il n'existe que quelques contrôles pour cela, et ils valent la peine d'être connus par cœur :
435 511
436```bash theme={null}512* `Esc` arrête Claude en pleine action et conserve tout jusqu'à ce point, afin que vous puissiez le rediriger sans perdre de travail.
437# One-off queries513* `/rewind`, ou `Esc` deux fois sur un prompt vide, ouvre le [menu de retour en arrière](https://code.claude.com/docs/fr/checkpointing.md#rewind-and-summarize), où vous ramenez le code, la conversation ou les deux à un prompt antérieur. Cela rend peu risqué le fait d'essayer d'abord l'approche la plus audacieuse et de revenir en arrière si elle ne fonctionne pas. Le même menu peut aussi résumer une partie de la conversation devenue obsolète.
438claude -p "Explain what this project does"514* `/clear` repart de zéro. Si vous avez corrigé la même chose deux fois et que c'est toujours faux, une troisième correction ne fait surtout qu'alourdir une conversation qui contient déjà deux tentatives échouées que Claude continue de relire. `/clear` suivi d'un nouveau prompt qui intègre ce que vous avez appris fonctionne mieux presque à chaque fois.
439
440# Structured output for scripts
441claude -p "List all API endpoints" --output-format json
442 515
443# Streaming for real-time processing516> [!WARNING]
444claude -p "Analyze this log file" --output-format stream-json --verbose517>
445```518> Les checkpoints couvrent les fichiers que Claude a modifiés avec ses propres outils de fichiers dans votre conversation principale, donc un fichier touché uniquement par une commande Bash [n'est pas restauré](https://code.claude.com/docs/fr/checkpointing.md#bash-command-changes-not-tracked). Ils fonctionnent aux côtés de git plutôt que de le remplacer.
446 519
447La première commande imprime du texte brut. Le format `json` retourne un seul objet JSON avec un champ `result`. Le format `stream-json` imprime un objet JSON par ligne, en commençant par un événement d'initialisation.520Deux contrôles plus modestes : [`/btw`](https://code.claude.com/docs/fr/interactive-mode#side-questions-with-%2Fbtw) répond à une question rapide sans rien ajouter à l'historique. Et pour un travail qui s'étale sur plusieurs jours, `/rename oauth-migration` dans la session lui donne un nom, afin que [`claude --resume oauth-migration`](https://code.claude.com/docs/fr/sessions#resume-by-session-id-or-name) depuis votre shell le reprenne plus tard, checkpoints compris. `claude --continue` reprend la session la plus récente.
448 521
449### Exécutez plusieurs sessions Claude522## Laissez Claude travailler sans vous
450 523
451> [!TIP]524> [!TIP]
452>525>
453> Exécutez plusieurs sessions Claude en parallèle pour accélérer le développement, exécuter des expériences isolées ou démarrer des workflows complexes.526> Avant qu'une exécution ne se déroule sans surveillance, assurez-vous qu'elle sait à quoi ressemble « terminé », qu'elle peut vérifier son propre travail et qu'elle ne peut toucher que ce qu'elle doit. Donnez-lui une limite de tours ou de dépenses, et faites approuver le résultat par une personne à la fin.
454
455Choisissez l'approche parallèle qui correspond au niveau de coordination que vous souhaitez faire vous-même, et ajoutez de la messagerie lorsque les sessions doivent se transmettre les résultats :
456 527
457* [Worktrees](https://code.claude.com/docs/fr/worktrees.md) : exécutez des sessions CLI séparées dans des checkouts git isolés afin que les modifications ne se heurtent pas528Tout ce qui figure sur cette page compte un peu plus une fois que vous n'êtes plus là pour rattraper les erreurs. Tant que vous surveillez, le fait qu'il manque à Claude un élément de contexte n'est pas grave : vous le remarquez en un message ou deux et vous le lui dites. Dans une exécution lancée avant d'aller vous coucher, personne ne le lui dit, et vous découvrez le lendemain matin qu'il a passé toute la nuit à construire sur une hypothèse erronée.
458* [Messagerie inter-sessions](https://code.claude.com/docs/fr/cross-session-messaging.md) : laissez les sessions que vous exécutez vous-même se transmettre les résultats
459* [Application de bureau](https://code.claude.com/docs/fr/desktop.md#work-in-parallel-with-sessions) : gérez visuellement plusieurs sessions locales, éventuellement chacune dans son propre worktree
460* [Utiliser Claude Code dans le cloud](https://code.claude.com/docs/fr/claude-code-on-the-web.md) : exécutez des sessions sur l'infrastructure gérée par Anthropic par défaut
461* [Vue agent](https://code.claude.com/docs/fr/agent-view.md) : en research preview. Exécutez `claude agents` pour dispatcher des sessions qui continuent de s'exécuter en arrière-plan et les surveiller depuis un seul écran
462* [Équipes d'agents](https://code.claude.com/docs/fr/agent-teams.md) : expérimental et désactivé par défaut. Coordination automatisée de plusieurs sessions avec des tâches partagées, la messagerie et un chef d'équipe
463 529
464Au-delà de la parallélisation du travail, plusieurs sessions permettent des workflows axés sur la qualité. Un contexte frais améliore la revue de code puisque Claude ne sera pas biaisé vers le code qu'il vient d'écrire.530Avant de laisser une tâche s'exécuter seule, il vaut la peine de passer en revue ces cinq questions en gardant cette tâche précise à l'esprit :
465 531
466Par exemple, utilisez un modèle Writer/Reviewer :5321. Sait-elle à quoi ressemble « terminé » ? Une condition d'objectif, un fichier de spécification ou un test qui échoue et qu'elle doit faire passer au vert.
5332. Peut-elle vérifier son propre travail ? La suite de tests, un hook `Stop`, une étape de revue quelconque.
5343. Qu'est-elle autorisée à toucher ? Les règles de permission, `dontAsk`, le sandbox, un worktree, la seule branche sur laquelle elle peut pousser.
5354. Qu'est-ce qui l'arrête ? `--max-turns`, `--max-budget-usd`, une limite de dépenses.
5365. Où va le résultat, et qui le valide ? Une PR, un commentaire ou un résumé, puis une personne qui approuve la fusion, le déploiement ou toute autre action irréversible.
467 537
468| Session A (Writer) | Session B (Reviewer) |538Une fois lancé, Claude mènera seul une longue tâche à son terme. Ce qui reste de votre ressort, c'est de la démarrer, de décider ce que « terminé » signifie cette fois-ci et d'approuver la fusion à la fin.
469| - | - |
470| `Implement a rate limiter for our API endpoints` | |
471| | `Review the rate limiter implementation in @src/middleware/rateLimiter.ts. Look for edge cases, race conditions, and consistency with our existing middleware patterns.` |
472| `Here's the review feedback: [Session B output]. Address these issues.` | |
473 539
474Vous pouvez faire quelque chose de similaire avec les tests : avoir un Claude écrire des tests, puis un autre écrire du code pour les réussir.540### Exécutez Claude depuis un script
475 541
476### Fan out sur les fichiers542[`claude -p "prompt"`](https://code.claude.com/docs/fr/headless) s'exécute une fois puis se termine, et c'est ainsi que Claude Code se retrouve dans des jobs CI, des hooks git et des boucles shell.
477
478> [!TIP]
479>
480> Bouclez à travers les tâches en appelant `claude -p` pour chacune. Utilisez `--allowedTools` pour pré-approuver les outils pour les opérations par lot.
481 543
482Pour les migrations ou analyses à grande échelle, vous pouvez distribuer le travail sur de nombreuses invocations Claude parallèles. Exécutez [`/batch <instruction>`](https://code.claude.com/docs/fr/commands#all-commands) pour que Claude divise la modification sur 5 à 30 sous-agents. Chaque sous-agent travaille dans son propre worktree. Pour piloter le fan-out à partir de votre propre script à la place, bouclez sur `claude -p` :544Dans un script, vous voudrez presque toujours quelques flags supplémentaires :
483 545
484**1. Générez une liste de tâches**546* [`--bare`](https://code.claude.com/docs/fr/headless#start-faster-with-bare-mode) ignore les hooks, les skills, les plugins, les serveurs MCP et les fichiers `CLAUDE.md`, ceux du dépôt comme ceux de la machine, afin que l'exécution fasse la même chose où qu'elle s'exécute. Il ne touche jamais non plus à votre connexion claude.ai : l'authentification provient de `ANTHROPIC_API_KEY`, d'un `apiKeyHelper` dans le fichier que vous passez avec `--settings`, ou des identifiants de votre fournisseur cloud.
547* `--append-system-prompt`, `--mcp-config` et `--settings` transmettent explicitement ce dont l'exécution *a* besoin.
548* `--allowedTools` pré-approuve ses outils, et [`--permission-mode dontAsk`](https://code.claude.com/docs/fr/permission-modes#allow-only-pre-approved-tools-with-dontask-mode) refuse tout le reste qui aurait déclenché une demande.
549* `--output-format json` vous donne un objet résultat unique à analyser, et `stream-json` avec `--verbose` diffuse les événements au fur et à mesure.
485 550
486Demandez à Claude d'écrire la liste des fichiers qui doivent être migrés dans un fichier, afin que la boucle à l'étape suivante puisse la lire, avec un prompt comme `list all 2,000 Python files that need migrating and save the list to files.txt`551Assemblé, cela ressemble à ceci :
487
488**2. Écrivez un script pour boucler à travers la liste**
489 552
490```bash theme={null}553```bash theme={null}
491for file in $(cat files.txt); do554for file in $(cat files.txt); do
492 claude -p "Migrate $file from Python 2 to Python 3. Return OK or FAIL." \555 claude --bare -p "Migrate $file to the new logger API and commit. Reply OK or FAIL." \
493 --allowedTools "Edit,Bash(git commit *)" \556 --allowedTools "Read,Edit,Bash(git add *),Bash(git commit *)" \
494 --permission-mode dontAsk557 --permission-mode dontAsk \
558 --max-turns 20
495done559done
496```560```
497 561
498**3. Testez sur quelques fichiers, puis exécutez sur tous**562Lorsqu'une exécution se termine, Claude répond `OK` ou `FAIL`, et une exécution qui atteint la limite de tours se termine plutôt avec une erreur. Essayez d'abord sur trois fichiers, voyez ce qui ne va pas, corrigez le prompt, puis lancez le reste.
499
500Affinez votre prompt en fonction de ce qui se passe mal avec les 2-3 premiers fichiers, puis exécutez sur l'ensemble complet. Le flag `--allowedTools` pré-approuve les outils dont la migration a besoin. [`--permission-mode dontAsk`](https://code.claude.com/docs/fr/permission-modes#allow-only-pre-approved-tools-with-dontask-mode) refuse tout ce qui nécessiterait une approbation, ce qui importe lorsque vous exécutez sans surveillance, bien qu'un [mod](https://code.claude.com/docs/fr/plugins/mods/overview.md) que vous avez installé puisse tout de même approuver certains de ces appels.
501 563
502Vous pouvez également intégrer Claude dans les pipelines de données/traitement existants :564Le mode auto fonctionne aussi avec `-p` si vous passez `--permission-mode auto`. Dans une exécution non interactive, un blocage du classifieur refuse cette action précise et Claude continue, et des blocages répétés ne mettent pas l'exécution en pause comme ils le font dans un terminal. Lisez [comment les seuils s'y appliquent](https://code.claude.com/docs/fr/permission-modes.md#repeated-block-thresholds) avant de vous y fier.
503 565
504```bash theme={null}566### Démarrez des exécutions selon un planning ou un événement
505claude -p "<your prompt>" --output-format json | your_command
506```
507 567
508### Exécutez de manière autonome avec le mode auto568Une fois une exécution lancée, Claude peut gérer le reste seul. La seule chose qu'il ne peut pas faire, c'est décider de *démarrer*, donc quelque chose doit le faire : vous, un minuteur ou un événement comme une vérification CI échouée ou une nouvelle PR.
509 569
510Pour une exécution ininterrompue avec des vérifications de sécurité en arrière-plan, utilisez le [mode auto](https://code.claude.com/docs/fr/permission-modes.md#eliminate-prompts-with-auto-mode). Un modèle classifieur examine les commandes avant qu'elles ne s'exécutent, bloquant l'escalade de portée, l'infrastructure inconnue et les actions motivées par du contenu hostile tout en laissant le travail courant se dérouler sans demandes de permission.570Dans une session ouverte, c'est [`/loop`](https://code.claude.com/docs/fr/scheduled-tasks#run-a-prompt-repeatedly-with-%2Floop), qui répète un prompt à intervalle régulier :
511 571
512```bash theme={null}572```text theme={null}
513claude --permission-mode auto -p "fix all lint errors"573/loop 15m check CI on this branch, and if it's red pull the failing job's log, fix it and push
514```574```
515 575
516Lorsque le classifieur bloque à plusieurs reprises les actions dans une exécution non interactive avec le flag `-p`, Claude Code n'arrête pas l'exécution. Consultez [quand le mode auto se replie](https://code.claude.com/docs/fr/permission-modes.md#when-auto-mode-falls-back) pour ce qui se passe à la place et pour les seuils.576Chaque exécution est un tour supplémentaire dans la même session, donc n'en laissez pas tourner une dans une longue conversation. Pour tout ce qui doit se produire pendant que votre ordinateur portable est fermé, [`/schedule`](https://code.claude.com/docs/fr/routines#create-from-the-cli) configure une [tâche planifiée cloud](https://code.claude.com/docs/fr/routines.md) qui s'exécute selon un minuteur. Elle nécessite une connexion claude.ai plutôt qu'une clé API. Vous pouvez ajouter un déclencheur basé sur un événement GitHub en le demandant à Claude, ou un déclencheur API sur [claude.ai/code/routines](https://claude.ai/code/routines).
517
518### Ajoutez une étape d'examen contradictoire
519 577
520> [!TIP]578> [!WARNING]
521>579>
522> Avant de considérer une tâche comme terminée, demandez à un sous-agent d'examiner le diff dans un contexte frais et de signaler les lacunes.580> Avant de laisser une tâche planifiée cloud s'exécuter, protégez `main` avec une [règle de branche GitHub que la tâche ne peut pas contourner](https://code.claude.com/docs/fr/routines.md#repositories-and-branch-permissions). Et surveillez les premières exécutions de toute nouveauté avant de lui faire confiance sans surveillance.
523
524Plus Claude travaille sans surveillance, plus une vérification indépendante importe avant de compter le travail comme terminé. Un examinateur s'exécutant dans un contexte de [sous-agent](https://code.claude.com/docs/fr/sub-agents.md) frais ne voit que le diff et les critères que vous lui donnez, pas le raisonnement qui a produit le changement, donc il évalue le résultat selon ses propres termes.
525 581
526Pour une vérification de la correction, exécutez le [skill `/code-review`](https://code.claude.com/docs/fr/commands) fourni, qui examine le diff actuel à la recherche de bogues dans un sous-agent frais et retourne les résultats à la session. Pour vérifier le diff par rapport à votre plan à la place, écrivez vous-même le prompt d'examen. Nommez le travail à vérifier, le plan par rapport auquel le vérifier et ce qui compte comme une constatation :582### Exécutez des sessions en parallèle
527 583
528```text wrap theme={null}584Lorsque vous menez plusieurs travaux distincts en même temps, donnez à chacun son propre checkout afin que les modifications ne puissent pas entrer en collision. [`claude -w feature-auth`](https://code.claude.com/docs/fr/worktrees#start-claude-in-a-worktree) démarre une session dans un nouveau worktree, l'[application de bureau](https://code.claude.com/docs/fr/desktop.md#work-in-parallel-with-sessions) en exécute plusieurs côte à côte, et les [sessions cloud](https://code.claude.com/docs/fr/claude-code-on-the-web.md) les exécutent dans le cloud plutôt que sur votre machine.
529Use a subagent to review the rate limiter diff against PLAN.md. Check that
530every requirement is implemented, the listed edge cases have tests, and
531nothing outside the task's scope changed. Report gaps, not style preferences.
532```
533 585
534Parce que l'examinateur s'exécute en tant que sous-agent, la session d'implémentation reçoit les lacunes directement et peut les corriger et les réexaminer sans que vous copiiez les résultats entre les fenêtres.586Un worktree est un checkout neuf, ce qui signifie que les fichiers ignorés par git comme `.env` n'y sont pas et que les dépendances ne sont pas installées. Pour le premier point, listez les fichiers ignorés par git dont vous avez besoin dans un [`.worktreeinclude`](https://code.claude.com/docs/fr/worktrees#copy-gitignored-files-into-worktrees) à la racine du dépôt (même syntaxe que `.gitignore`) et Claude Code les copie dans chaque worktree qu'il crée :
535 587
536Un examinateur à qui l'on demande de trouver des lacunes en signalera généralement, même lorsque le travail est solide, car c'est ce qu'on lui a demandé de faire. Poursuivre chaque constatation mène à une sur-ingénierie : couches d'abstraction supplémentaires, code défensif et tests pour des cas qui ne peuvent pas se produire. Dites à l'examinateur de signaler uniquement les lacunes qui affectent la correction ou les exigences énoncées, et traitez le reste comme optionnel.588```text .worktreeinclude theme={null}
589.env
590.env.local
591config/dev-credentials.json
592```
537 593
538***594Limitez-vous à de petits fichiers : il copie plutôt que de lier, donc y mettre `node_modules` signifierait une copie complète par worktree. Pour les grands répertoires, il existe le paramètre [`worktree.symlinkDirectories`](https://code.claude.com/docs/fr/settings-reference#worktree-symlinkdirectories), ou bien gardez la commande d'installation dans `CLAUDE.md` pour que Claude l'exécute chaque fois qu'il démarre dans un nouveau checkout.
539 595
540## Évitez les modèles d'échec courants596Vous avez rarement à faire le ménage vous-même :
541 597
542Ce sont des erreurs courantes. Les reconnaître tôt économise du temps :598* Lorsque vous quittez une session de worktree sans nom, Claude Code [supprime le worktree](https://code.claude.com/docs/fr/worktrees.md#clean-up-worktrees) s'il ne contient rien. Pour une session nommée, ou une session avec des modifications, il vous demande quoi faire.
599* Les worktrees des sous-agents disparaissent lorsque le sous-agent se termine sans modifications.
600* Les worktrees de sous-agents et de sessions en arrière-plan qui restent malgré tout sont nettoyés une fois qu'ils sont plus anciens que `cleanupPeriodDays` et ne contiennent aucun travail.
543 601
544* **La session fourre-tout.** Vous commencez par une tâche, puis demandez à Claude quelque chose d'autre, puis revenez à la première tâche. Le contexte est plein d'informations non pertinentes.602> [!NOTE]
545 > **Correction** : `/clear` entre les tâches non liées.603>
546* **Corriger encore et encore.** Claude fait quelque chose de mal, vous le corrigez, c'est toujours mal, vous corrigez à nouveau. Le contexte est pollué par des approches échouées.604> Une exécution `claude -p --worktree` est à nettoyer vous-même, puisqu'elle se termine sans rien demander. Supprimez ces worktrees avec `git worktree remove <path>`, et si git refuse parce que le worktree est verrouillé, exécutez d'abord `git worktree unlock <path>`.
547 > **Correction** : Après deux corrections échouées, `/clear` et écrivez une meilleure invite initiale incorporant ce que vous avez appris.
548* **Le CLAUDE.md sur-spécifié.** Si votre CLAUDE.md est trop long, Claude ignore la moitié car les règles importantes se perdent dans le bruit.
549 > **Correction** : Élaguez impitoyablement. Si Claude fait déjà quelque chose correctement sans l'instruction, supprimez-le ou convertissez-le en hook.
550* **L'écart de confiance-puis-vérification.** Claude produit une implémentation plausible qui ne gère pas les cas limites.
551 > **Correction** : Fournissez toujours une vérification (tests, scripts, captures d'écran). Si vous ne pouvez pas la vérifier, ne la déployez pas.
552* **L'exploration infinie.** Vous demandez à Claude d'« enquêter » sur quelque chose sans le délimiter. Claude lit des centaines de fichiers, remplissant le contexte.
553 > **Correction** : Délimitez les enquêtes étroitement ou utilisez les subagents pour que l'exploration ne consomme pas votre contexte principal.
554 605
555***606Pour une grosse modification mécanique sur de nombreux fichiers, [`/batch migrate every handler to the v2 response helpers`](https://code.claude.com/docs/fr/commands) divise le travail en 5 à 30 unités et vous montre le plan. Il exécute ensuite chaque unité dans son propre worktree et ouvre une PR pour chacune. Depuis votre shell, [`claude agents`](https://code.claude.com/docs/fr/agent-view) (encore en research preview) vous donne un seul écran pour tout ce qui s'exécute en arrière-plan sur votre machine.
556 607
557## Développez votre intuition608Une deuxième session est aussi le relecteur indépendant le plus facile à obtenir. Une session écrit le limiteur de débit, une autre examine `@src/middleware/rateLimiter.ts` sans l'avoir vu s'écrire, et vous recollez les constatations dans la première. Même idée que `/code-review`, mais c'est vous qui transportez les messages.
558 609
559Les modèles de ce guide ne sont pas gravés dans le marbre. Ce sont des points de départ qui fonctionnent bien en général, mais pourraient ne pas être optimaux pour chaque situation.610## Ce que vous pouvez arrêter de faire
560 611
561Parfois, vous *devriez* laisser le contexte s'accumuler parce que vous êtes profondément dans un problème complexe et l'historique est précieux. Parfois, vous devriez ignorer la planification et laisser Claude le découvrir parce que la tâche est exploratoire. Parfois, une invite vague est exactement ce qu'il faut parce que vous voulez voir comment Claude interprète le problème avant de le contraindre.612Chacun de ces conseils était judicieux au moment où il a été écrit. La plupart étaient des contournements pour quelque chose que le modèle ne pouvait pas encore faire de manière fiable, et les modèles ont depuis rattrapé leur retard. Si certains sont encore des habitudes, voici pourquoi vous pouvez les abandonner sans risque.
562 613
563Faites attention à ce qui fonctionne. Lorsque Claude produit une excellente sortie, remarquez ce que vous avez fait : la structure de l'invite, le contexte que vous avez fourni, le mode dans lequel vous étiez. Lorsque Claude lutte, demandez-vous pourquoi. Le contexte était-il trop bruyant ? L'invite trop vague ? La tâche trop grande pour une seule passe ?614| L'ancien conseil | Pourquoi il n'a plus lieu d'être |
615| :- | :- |
616| La fenêtre de contexte est votre principale contrainte, gérez-la agressivement | La plupart des modèles actuels ont une fenêtre de 1M de tokens et la compaction se fait d'elle-même, il est donc rare d'en manquer. `/clear` entre les tâches vaut toujours la peine, car un contexte ciblé vous donne de meilleures réponses et coûte moins cher. |
617| Ajoutez IMPORTANT ou des MAJUSCULES aux instructions que Claude ne cesse de manquer | Les modèles plus anciens avaient parfois besoin de cette emphase. Les actuels suivent une ligne formulée simplement, et accumuler l'emphase pousse surtout Claude à sur-appliquer la règle. S'il s'agit d'une règle qui ne peut pas fléchir, transformez-la en hook ou en règle de refus. Si la ligne se perd dans un long fichier, c'est le fichier qui doit être raccourci. |
618| Utilisez des sous-agents pour protéger votre fenêtre de contexte | Manquer de contexte est rarement le problème désormais. Les sous-agents restent excellents pour le travail en parallèle, pour tenir les sorties bruyantes à l'écart et pour la revue indépendante, mais chacun de ces usages coûte des tokens supplémentaires. |
619| Déléguez à un sous-agent pour obtenir une meilleure réponse | Confier la même tâche à un sous-agent ne rend pas la réponse meilleure. Un relecteur neuf aide bien, parce qu'il n'a pas vu votre raisonnement, mais c'est autre chose que déléguer. |
620| `think hard`, `think harder`, `be thorough` dans le prompt | L'effort est le contrôle prévu pour cela. Ces expressions sont du texte de prompt ordinaire qui oriente Claude dans les limites de son niveau d'effort, plutôt que des mots-clés qui l'augmentent. `ultrathink` fonctionne toujours : il demande un raisonnement plus approfondi pour ce seul tour sans toucher à votre paramètre d'effort. |
621| Dites à Claude de continuer, de boucler jusqu'à ce que ce soit fini, de ne pas être paresseux | Les modèles actuels mènent généralement une tâche convenue à son terme sans qu'on le leur dise, et ce genre de ligne risque davantage de provoquer un excès de travail que de résoudre un blocage. Donner à Claude une vérification à réussir est différent, et vaut toujours la peine. Si une exécution s'arrête trop tôt, dites `continue`, et pour les exécutions que personne ne surveille, `/goal` ou un hook `Stop` l'impose. |
622| Décrivez votre architecture et l'organisation de vos fichiers dans `CLAUDE.md` | Claude lit lui-même le dépôt. N'écrivez que ce qui ne s'y trouve pas. |
564 623
565Au fil du temps, vous développerez une intuition qu'aucun guide ne peut capturer. Vous saurez quand être spécifique et quand être ouvert, quand planifier et quand explorer, quand effacer le contexte et quand le laisser s'accumuler.624Si un autre conseil de cette page commence un jour à ressembler à une corvée, c'est probablement le signe qu'il a lui aussi sa place dans ce tableau.
566 625
567## Ressources connexes626## Ressources connexes
568 627
569* [Comment fonctionne Claude Code](https://code.claude.com/docs/fr/how-claude-code-works.md) : la boucle agentique, les outils et la gestion du contexte628* [Comment fonctionne Claude Code](https://code.claude.com/docs/fr/how-claude-code-works.md) : la boucle, les outils et ce qui se charge au démarrage
570* [Étendre Claude Code](https://code.claude.com/docs/fr/features-overview.md) : skills, hooks, MCP, subagents et plugins629* [Explorer la fenêtre de contexte](https://code.claude.com/docs/fr/context-window.md) : ce qui occupe de l'espace dans une session et quand cela se charge
571* [Flux de travail courants](https://code.claude.com/docs/fr/common-workflows.md) : recettes étape par étape pour le débogage, les tests, les PR et plus630* [Étendre Claude Code](https://code.claude.com/docs/fr/features-overview.md) : le choix entre skills, hooks, MCP, sous-agents et plugins
572* [CLAUDE.md](https://code.claude.com/docs/fr/memory.md) : stocker les conventions de projet et le contexte persistant631* [Choisir un mode de permission](https://code.claude.com/docs/fr/permission-modes.md) et [Configurer les permissions](https://code.claude.com/docs/fr/permissions.md)
632* [Gérer les coûts efficacement](https://code.claude.com/docs/fr/costs.md)
633* [Exécuter Claude Code de manière programmatique](https://code.claude.com/docs/fr/headless.md) et [Automatiser le travail avec des tâches planifiées cloud](https://code.claude.com/docs/fr/routines.md)
634* Pour les responsables d'équipe et les administrateurs : [Configurer Claude Code pour votre organisation](https://code.claude.com/docs/fr/admin-setup.md)
