gilles/claude-code-best-practice
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

traduction

Browse Source
This commit is contained in:
gilles soulier
2026-06-02 23:24:21 +02:00
parent 89ed5d7f86
commit e8f2b1a034
114 changed files with 17211 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
fr/tips/claude-boris-10-tips-01-feb-26.md
+153
View File
@@ -0,0 +1,153 @@
# 10 astuces pour utiliser Claude Code — par l'équipe Claude Code
Une synthèse d'astuces de l'équipe partagées par Boris Cherny ([@bcherny](https://x.com/bcherny)), créateur de Claude Code, le 1er février 2026.
<table width="100%">
<tr>
<td><a href="../">← Retour à Claude Code Best Practice</a></td>
<td align="right"><img src="../../!/claude-jumping.svg" alt="Claude" width="60" /></td>
</tr>
</table>
---
## Contexte
Boris a partagé des astuces pour utiliser Claude Code, directement issues de l'équipe Claude Code. La façon dont l'équipe utilise Claude diffère de celle de Boris à titre personnel. Rappelle-toi : il n'y a pas une seule bonne manière d'utiliser Claude Code — la configuration de chacun est différente. Tu devrais expérimenter pour voir ce qui marche pour toi !
<a href="https://x.com/bcherny/status/2017742741636321619"><img src="../../tips/assets/boris-26-2-1/0.png" alt="Tweet d'intro de Boris Cherny" width="50%" /></a>
---
## 1/ Fais-en plus en parallèle
Crée 3 à 5 worktrees git à la fois, chacun faisant tourner sa propre session Claude en parallèle. C'est le plus grand gain de productivité à lui seul, et la première astuce de l'équipe. Personnellement, Boris utilise plusieurs checkouts git, mais la plupart de l'équipe Claude Code préfère les worktrees — c'est la raison pour laquelle `@amorisscode` en a construit le support natif dans l'application Claude Desktop !
Certains nomment aussi leurs worktrees et configurent des alias shell (`2a`, `2b`, `2c`) pour sauter de l'un à l'autre en une frappe. D'autres ont un worktree « analyse » dédié, uniquement pour lire les logs et lancer BigQuery.
Voir : [Documentation des worktrees](https://code.claude.com/docs/en/common...)
<a href="https://x.com/bcherny/status/2017742743125299476"><img src="../../tips/assets/boris-26-2-1/1.png" alt="Faire plus en parallèle" width="50%" /></a>
---
## 2/ Démarre chaque tâche complexe en mode Plan
Mets ton énergie dans le plan pour que Claude puisse réussir l'implémentation du premier coup.
Une personne fait écrire le plan par un premier Claude, puis lance un second Claude pour le relire comme un staff engineer.
Une autre dit qu'au moment où quelque chose dérape, elle repasse en mode Plan et re-planifie. Ne force pas en continuant. Elle demande aussi explicitement à Claude d'entrer en mode Plan pour les étapes de vérification, pas seulement pour la construction.
<a href="https://x.com/bcherny/status/2017742745365057733"><img src="../../tips/assets/boris-26-2-1/2.png" alt="Démarrer chaque tâche complexe en mode plan" width="50%" /></a>
---
## 3/ Investis dans ton CLAUDE.md
Après chaque correction, termine par : « Mets à jour ton CLAUDE.md pour ne plus refaire cette erreur. » Claude est étrangement doué pour écrire ses propres règles.
Édite ton `CLAUDE.md` sans pitié au fil du temps. Continue d'itérer jusqu'à ce que le taux d'erreur de Claude baisse de manière mesurable.
Un ingénieur demande à Claude de maintenir un dossier de notes pour chaque tâche/projet, mis à jour après chaque PR. Il pointe ensuite le `CLAUDE.md` vers ce dossier.
<a href="https://x.com/bcherny/status/2017742747067945390"><img src="../../tips/assets/boris-26-2-1/3.png" alt="Investir dans ton CLAUDE.md" width="50%" /></a>
---
## 4/ Crée tes propres skills et versionne-les dans git
Réutilise-les sur chaque projet. Astuces de l'équipe :
- Si tu fais quelque chose plus d'une fois par jour, transforme-le en skill ou en commande
- Construis une commande slash `/techdebt` et lance-la à la fin de chaque session pour trouver et éliminer le code dupliqué
- Mets en place une commande slash qui synchronise 7 jours de Slack, GDrive, Asana et GitHub en un seul dump de contexte
- Construis des agents de type analytics-engineer qui écrivent des modèles dbt, relisent le code et testent les changements en dev
Voir : [Étendre Claude avec les skills — Documentation Claude Code](https://code.claude.com/docs/en/skills)
<a href="https://x.com/bcherny/status/2017742748984742078"><img src="../../tips/assets/boris-26-2-1/4.png" alt="Crée tes propres skills" width="50%" /></a>
---
## 5/ Claude corrige la plupart des bugs tout seul
Voici comment l'équipe procède :
Active le MCP Slack, puis colle un fil de bug Slack dans Claude et dis simplement « corrige ». Zéro changement de contexte requis.
Ou bien, dis simplement « Va corriger les tests CI qui échouent ». Ne micro-gère pas le comment.
Pointe Claude vers les logs docker pour diagnostiquer les systèmes distribués — il est étonnamment compétent pour ça.
<a href="https://x.com/bcherny/status/2017742750473720121"><img src="../../tips/assets/boris-26-2-1/5.png" alt="Claude corrige la plupart des bugs tout seul" width="50%" /></a>
---
## 6/ Améliore ton prompting
a. **Défie Claude.** Dis « Cuisine-moi sur ces changements et ne fais pas de PR tant que je n'ai pas réussi ton test ». Fais de Claude ton relecteur. Ou dis « Prouve-moi que ça marche » et fais comparer à Claude le comportement entre main et ta branche de fonctionnalité.
b. **Après un correctif médiocre,** dis : « Avec tout ce que tu sais maintenant, jette ça et implémente la solution élégante. »
c. **Écris des specs détaillées** et réduis l'ambiguïté avant de déléguer le travail. Plus tu es précis, meilleur est le résultat.
<a href="https://x.com/bcherny/status/2017742752566632544"><img src="../../tips/assets/boris-26-2-1/6.png" alt="Améliorer ton prompting" width="50%" /></a>
---
## 7/ Configuration du terminal & de l'environnement
L'équipe adore Ghostty ! Plusieurs personnes apprécient son rendu synchronisé, sa couleur 24 bits et son support unicode correct.
Pour jongler plus facilement entre les Claude, utilise `/statusline` pour personnaliser ta barre d'état afin qu'elle affiche toujours l'usage de contexte et la branche git courante. Beaucoup colorent et nomment aussi leurs onglets de terminal, parfois avec tmux — un onglet par tâche/worktree.
Utilise la dictée vocale. Tu parles 3× plus vite que tu ne tapes, et tes prompts deviennent bien plus détaillés en conséquence. (appuie sur fn x2 sous macOS)
Voir : [Documentation de configuration du terminal](https://code.claude.com/docs/en/termin...)
<a href="https://x.com/bcherny/status/2017742753971769626"><img src="../../tips/assets/boris-26-2-1/7.png" alt="Configuration du terminal et de l'environnement" width="50%" /></a>
---
## 8/ Utilise les sous-agents
a. Ajoute « use subagents » à toute requête où tu veux que Claude alloue plus de calcul au problème.
b. Délègue des tâches individuelles à des sous-agents pour garder la fenêtre de contexte de ton agent principal propre et focalisée.
c. Route les demandes de permission vers Opus 4.5 via un hook — laisse-le détecter les attaques et auto-approuver les commandes sûres. Voir : [Documentation des hooks](https://code.claude.com/docs/en/hooks#...)
<a href="https://x.com/bcherny/status/2017742755737555434"><img src="../../tips/assets/boris-26-2-1/8.png" alt="Utiliser les sous-agents" width="50%" /></a>
---
## 9/ Utilise Claude pour les données & l'analytique
Demande à Claude Code d'utiliser le CLI « bq » pour extraire et analyser des métriques à la volée. L'équipe a un skill BigQuery versionné dans le codebase, et tout le monde l'utilise pour les requêtes analytiques directement dans Claude Code. Personnellement, Boris n'a pas écrit une ligne de SQL depuis plus de 6 mois.
Cela fonctionne pour n'importe quelle base de données disposant d'un CLI, d'un MCP ou d'une API.
<a href="https://x.com/bcherny/status/2017742757666902374"><img src="../../tips/assets/boris-26-2-1/9.png" alt="Utiliser Claude pour les données et l'analytique" width="50%" /></a>
---
## 10/ Apprendre avec Claude
Quelques astuces de l'équipe pour utiliser Claude Code afin d'apprendre :
a. Active le style de sortie « Explanatory » ou « Learning » dans `/config` pour que Claude explique le « pourquoi » de ses changements.
b. Fais générer à Claude une présentation HTML visuelle expliquant du code peu familier. Il fait des slides étonnamment bonnes !
c. Demande à Claude de dessiner des diagrammes ASCII de nouveaux protocoles et codebases pour t'aider à les comprendre.
d. Construis un skill d'apprentissage par répétition espacée : tu expliques ta compréhension, Claude pose des questions de suivi pour combler les lacunes, et stocke le résultat.
<a href="https://x.com/bcherny/status/2017742759218794768"><img src="../../tips/assets/boris-26-2-1/10.png" alt="Apprendre avec Claude" width="50%" /></a>
---
## Sources
- [Boris Cherny (@bcherny) sur X — 1er février 2026](https://x.com/bcherny/status/2017742741636321619)
fr/tips/claude-boris-12-tips-12-feb-26.md
+174
View File
@@ -0,0 +1,174 @@
# 12 façons de personnaliser Claude Code — Astuces de Boris Cherny
Une synthèse d'astuces de personnalisation partagées par Boris Cherny ([@bcherny](https://x.com/bcherny)), créateur de Claude Code, le 12 février 2026.
<table width="100%">
<tr>
<td><a href="../">← Retour à Claude Code Best Practice</a></td>
<td align="right"><img src="../../!/claude-jumping.svg" alt="Claude" width="60" /></td>
</tr>
</table>
---
## Contexte
Boris Cherny a souligné que la personnalisation est l'une des choses que les ingénieurs préfèrent dans Claude Code — hooks, plugins, LSP, MCP, skills, effort, agents personnalisés, barres d'état, styles de sortie, et plus encore. Il a partagé 12 façons concrètes dont développeurs et équipes personnalisent leur configuration.
<a href="https://x.com/bcherny/status/2021699851499798911"><img src="../../tips/assets/boris-26-2-12/0.webp" alt="Tweet d'intro de Boris Cherny" width="50%" /></a>
---
## 1/ Configure ton terminal
Configure ton terminal pour la meilleure expérience Claude Code :
- **Thème** : lance `/config` pour choisir le mode clair/sombre
- **Notifications** : active les notifications pour iTerm2, ou utilise un hook de notification personnalisé
- **Sauts de ligne** : si tu utilises Claude Code dans le terminal d'un IDE, Apple Terminal, Warp ou Alacritty, lance `/terminal-setup` pour activer shift+entrée pour les sauts de ligne (afin de ne pas avoir à taper `\`)
- **Mode Vim** : lance `/vim`
<a href="https://x.com/bcherny/status/2021699859359883608"><img src="../../tips/assets/boris-26-2-12/1.webp" alt="Configure ton terminal" width="50%" /></a>
---
## 2/ Ajuste le niveau d'effort
Lance `/model` pour choisir ton niveau d'effort préféré :
- **Low** — moins de tokens, réponses plus rapides
- **Medium** — comportement équilibré
- **High** — plus de tokens, plus d'intelligence
La préférence de Boris : High pour tout.
<a href="https://x.com/bcherny/status/2021699860869902424"><img src="../../tips/assets/boris-26-2-12/2.webp" alt="Ajuste le niveau d'effort" width="50%" /></a>
---
## 3/ Installe des plugins, MCP et skills
Les plugins te permettent d'installer des LSP (disponibles pour tous les langages majeurs), des MCP, des skills, des agents et des hooks personnalisés.
Installe depuis la marketplace de plugins officielle d'Anthropic, ou crée ta propre marketplace pour ton entreprise. Versionne le `settings.json` dans ton codebase pour ajouter automatiquement les marketplaces à ton équipe.
Lance `/plugin` pour commencer.
<a href="https://x.com/bcherny/status/2021699862522364149"><img src="../../tips/assets/boris-26-2-12/3.webp" alt="Installe des plugins, MCP et skills" width="50%" /></a>
---
## 4/ Crée des agents personnalisés
Dépose des fichiers `.md` dans `.claude/agents` pour créer des agents personnalisés. Chaque agent peut avoir un nom, une couleur, un jeu d'outils, des outils pré-autorisés et pré-interdits, un mode de permissions et un modèle qui lui sont propres.
Tu peux aussi définir l'agent par défaut de la conversation principale via le champ `"agent"` dans `settings.json` ou le drapeau `--agent`.
Lance `/agents` pour commencer.
<a href="https://x.com/bcherny/status/2021700144039903699"><img src="../../tips/assets/boris-26-2-12/4.webp" alt="Crée des agents personnalisés" width="50%" /></a>
---
## 5/ Pré-approuve les permissions courantes
Claude Code utilise un système de permissions combinant détection d'injection de prompt, analyse statique, sandboxing et supervision humaine.
D'origine, un petit ensemble de commandes sûres est pré-approuvé. Pour en pré-approuver davantage, lance `/permissions` et ajoute aux listes d'autorisation et de blocage. Versionne-les dans le `settings.json` de ton équipe.
La syntaxe complète à jokers est supportée — par ex. `Bash(bun run *)` ou `Edit(/docs/**)`.
<a href="https://x.com/bcherny/status/2021700332292911228"><img src="../../tips/assets/boris-26-2-12/5.webp" alt="Pré-approuve les permissions courantes" width="50%" /></a>
---
## 6/ Active le sandboxing
Opte pour le runtime de sandbox open source de Claude Code pour améliorer la sécurité tout en réduisant les demandes de permission.
Lance `/sandbox` pour l'activer. Le sandboxing tourne sur ta machine et supporte l'isolation des fichiers comme du réseau.
<a href="https://x.com/bcherny/status/2021700506465579443"><img src="../../tips/assets/boris-26-2-12/6.webp" alt="Active le sandboxing" width="50%" /></a>
---
## 7/ Ajoute une barre d'état (status line)
Les barres d'état personnalisées s'affichent juste sous la zone de saisie, montrant le modèle, le répertoire, le contexte restant, le coût et tout ce que tu veux voir pendant que tu travailles.
Chaque membre de l'équipe peut avoir une barre d'état différente. Utilise `/statusline` pour que Claude en génère une à partir de ton `.bashrc`/`.zshrc`.
<a href="https://x.com/bcherny/status/2021700784019452195"><img src="../../tips/assets/boris-26-2-12/7.webp" alt="Ajoute une barre d'état" width="50%" /></a>
---
## 8/ Personnalise tes raccourcis clavier
Chaque raccourci clavier de Claude Code est personnalisable. Lance `/keybindings` pour réassigner n'importe quelle touche. Les réglages se rechargent à chaud pour que tu ressentes l'effet immédiatement.
<a href="https://x.com/bcherny/status/2021700883873165435"><img src="../../tips/assets/boris-26-2-12/8.webp" alt="Personnalise tes raccourcis clavier" width="50%" /></a>
---
## 9/ Mets en place des hooks
Les hooks te permettent de t'accrocher de manière déterministe au cycle de vie de Claude :
- Router automatiquement les demandes de permission vers Slack ou Opus
- Inciter Claude à continuer quand il atteint la fin d'un tour (tu peux même lancer un agent ou utiliser un prompt pour décider si Claude doit continuer)
- Pré-traiter ou post-traiter les appels d'outils, par ex. pour ajouter ta propre journalisation
Demande à Claude d'ajouter un hook pour commencer.
<a href="https://x.com/bcherny/status/2021701059253874861"><img src="../../tips/assets/boris-26-2-12/9.webp" alt="Mets en place des hooks" width="50%" /></a>
---
## 10/ Personnalise les verbes de ton spinner
Personnalise les verbes de ton spinner pour compléter ou remplacer la liste par défaut par tes propres verbes. Versionne le `settings.json` pour partager les verbes avec ton équipe.
<a href="https://x.com/bcherny/status/2021701145023197516"><img src="../../tips/assets/boris-26-2-12/10.webp" alt="Personnalise les verbes de ton spinner" width="50%" /></a>
---
## 11/ Utilise les styles de sortie
Lance `/config` et définis un style de sortie pour que Claude réponde avec un ton ou un format différent.
- **Explanatory** — recommandé pour te familiariser avec un nouveau codebase, afin que Claude explique frameworks et patterns de code au fil de son travail
- **Learning** — pour que Claude t'accompagne dans la réalisation de changements de code
- **Custom** — crée des styles de sortie personnalisés pour ajuster la voix de Claude
<a href="https://x.com/bcherny/status/2021701379409273093"><img src="../../tips/assets/boris-26-2-12/11.webp" alt="Utilise les styles de sortie" width="50%" /></a>
---
## 12/ Personnalise tout !
Claude Code fonctionne très bien d'origine, mais quand tu personnalises, versionne ton `settings.json` dans git pour que ton équipe en profite aussi. La configuration est supportée à plusieurs niveaux :
- Pour ton codebase
- Pour un sous-dossier
- Pour toi seul
- Via des politiques à l'échelle de l'entreprise
Avec 37 paramètres et 84 variables d'environnement (utilise le champ `"env"` de ton `settings.json` pour éviter les scripts wrapper), il y a de bonnes chances que tout comportement que tu souhaites soit configurable.
<a href="https://x.com/bcherny/status/2021701636075458648"><img src="../../tips/assets/boris-26-2-12/12.webp" alt="Personnalise tout" width="50%" /></a>
---
## Sources
- [Boris Cherny (@bcherny) sur X — 12 février 2026](https://x.com/bcherny)
- [Documentation de configuration du terminal Claude Code](https://code.claude.com/docs/en/terminal)
- [Documentation Plugins & Découverte Claude Code](https://code.claude.com/docs/en/discover-plugins)
- [Documentation des sous-agents Claude Code](https://code.claude.com/docs/en/sub-agents)
- [Documentation des permissions Claude Code](https://code.claude.com/docs/en/permissions)
- [Documentation du sandbox Claude Code](https://code.claude.com/docs/en/sandbox)
- [Documentation de la barre d'état Claude Code](https://code.claude.com/docs/en/statusline)
- [Documentation des raccourcis clavier Claude Code](https://code.claude.com/docs/en/keybindings)
- [Référence des hooks Claude Code](https://code.claude.com/docs/en/hooks)
- [Documentation des styles de sortie Claude Code](https://code.claude.com/docs/en/output-styles)
- [Documentation des paramètres Claude Code](https://code.claude.com/docs/en/settings)
fr/tips/claude-boris-13-tips-03-jan-26.md
+150
View File
@@ -0,0 +1,150 @@
# Comment j'utilise Claude Code — 13 astuces de Boris Cherny
Une synthèse d'astuces de configuration partagées par Boris Cherny ([@bcherny](https://x.com/bcherny)), créateur de Claude Code, le 3 janvier 2026.
<table width="100%">
<tr>
<td><a href="../">← Retour à Claude Code Best Practice</a></td>
<td align="right"><img src="../../!/claude-jumping.svg" alt="Claude" width="60" /></td>
</tr>
</table>
---
## Contexte
Boris a partagé sa configuration personnelle de Claude Code, en notant qu'elle est « étonnamment standard » — Claude Code fonctionne très bien d'origine, donc il ne le personnalise pas beaucoup. Il n'y a pas une seule bonne manière de l'utiliser : l'équipe le construit intentionnellement pour que tu puisses l'utiliser, le personnaliser et le bricoler à ta guise. Chaque personne de l'équipe Claude Code l'utilise très différemment.
<a href="https://x.com/bcherny/status/2007179832300581177"><img src="../../tips/assets/boris-26-1-3/0.png" alt="Tweet d'intro de Boris Cherny" width="50%" /></a>
---
## 1/ Fais tourner 5 Claude en parallèle
Fais tourner 5 Claude en parallèle dans ton terminal. Numérote tes onglets de 1 à 5, et utilise les notifications système pour savoir quand un Claude a besoin d'une intervention.
Voir : [Documentation de configuration du terminal](https://code.claude.com/docs/en/terminal)
<a href="https://x.com/bcherny/status/2007179833990885678"><img src="../../tips/assets/boris-26-1-3/1.png" alt="Faire tourner 5 Claude en parallèle" width="50%" /></a>
---
## 2/ Utilise claude.ai/code pour encore plus de parallélisme
Fais tourner 5 à 10 Claude sur claude.ai/code en parallèle de tes Claude locaux. Passe le relais des sessions locales aux sessions web avec `claude.ai/code`, lance manuellement des sessions dans Chrome, et téléporte-toi d'un côté à l'autre.
<a href="https://x.com/bcherny/status/2007179836704600237"><img src="../../tips/assets/boris-26-1-3/2.png" alt="Parallélisme avec claude.ai/code" width="50%" /></a>
---
## 3/ Utilise Opus avec la réflexion pour tout
Utilise Opus 4.5 avec la réflexion pour tout. C'est le meilleur modèle de code que Boris ait jamais utilisé — même s'il est plus gros et plus lent que Sonnet, comme tu as moins à le guider et qu'il est meilleur en usage d'outils, il est presque toujours plus rapide au final que l'usage d'un modèle plus petit.
<a href="https://x.com/bcherny/status/2007179838864666847"><img src="../../tips/assets/boris-26-1-3/3.png" alt="Opus avec la réflexion" width="50%" /></a>
---
## 4/ Partage un seul CLAUDE.md avec ton équipe
Partage un seul `CLAUDE.md` pour le dépôt. Versionne-le dans git, et fais en sorte que toute l'équipe y contribue plusieurs fois par semaine. À chaque fois que Claude fait quelque chose d'incorrect, ajoute-le au `CLAUDE.md` pour que Claude sache ne pas le refaire la prochaine fois.
<a href="https://x.com/bcherny/status/2007179840848597422"><img src="../../tips/assets/boris-26-1-3/4.png" alt="CLAUDE.md partagé" width="50%" /></a>
---
## 5/ Mentionne @claude sur les PR pour mettre à jour le CLAUDE.md
Pendant la revue de code, mentionne `@claude` sur les PR de tes collègues pour ajouter quelque chose au `CLAUDE.md` dans le cadre de la PR. Utilise la GitHub action de Claude Code ([install-@hub-action](https://github.com/apps/claude)) pour cela — c'est la version de Boris du Compounding Engineering.
<a href="https://x.com/bcherny/status/2007179842928947333"><img src="../../tips/assets/boris-26-1-3/5.png" alt="Mentionner @claude sur les PR" width="50%" /></a>
---
## 6/ Démarre la plupart des sessions en mode Plan
Démarre la plupart des sessions en mode Plan (shift+tab deux fois). Si l'objectif est d'écrire une Pull Request, utilise le mode Plan et fais des allers-retours avec Claude jusqu'à ce que son plan te convienne. À partir de là, passe en mode auto-accept des modifications et Claude peut généralement le réussir du premier coup. Un bon plan est vraiment important.
<a href="https://x.com/bcherny/status/2007179845336527000"><img src="../../tips/assets/boris-26-1-3/6.png" alt="Mode Plan" width="50%" /></a>
---
## 7/ Utilise les commandes slash pour les workflows de boucle courte
Utilise les commandes slash pour chaque workflow de « boucle interne » (inner loop) que tu fais plusieurs fois par jour. Cela t'évite de re-prompter sans cesse, et permet à Claude d'utiliser ces workflows lui aussi. Les commandes sont versionnées dans git et vivent dans `.claude/commands/`.
Exemple : `/commit-push-pr` — Commit, push et ouverture d'une PR.
<a href="https://x.com/bcherny/status/2007179847949500714"><img src="../../tips/assets/boris-26-1-3/7.png" alt="Commandes slash" width="50%" /></a>
---
## 8/ Utilise les sous-agents pour automatiser les workflows courants
Utilise quelques sous-agents régulièrement : `code-simplifier` simplifie le code une fois que Claude a terminé, `verify-app` contient des instructions détaillées pour tester Claude Code de bout en bout, et ainsi de suite. Vois les sous-agents comme l'automatisation des workflows les plus courants — à l'image des commandes slash.
Les sous-agents vivent dans `.claude/agents/`.
<a href="https://x.com/bcherny/status/2007179850139000872"><img src="../../tips/assets/boris-26-1-3/8.png" alt="Sous-agents" width="50%" /></a>
---
## 9/ Utilise un hook PostToolUse pour auto-formater le code
Utilise un hook `PostToolUse` pour formater le code de Claude. Claude génère généralement un code bien formaté d'origine, et le hook gère les 10 % restants pour éviter des erreurs de formatage en CI plus tard.
```json
"PostToolUse": [
{
"matcher": "Write|Edit",
"hooks": [
{
"type": "command",
"command": "bun run format || true"
}
]
}
]
```
<a href="https://x.com/bcherny/status/2007179852047335529"><img src="../../tips/assets/boris-26-1-3/9.png" alt="Hook PostToolUse pour le formatage" width="50%" /></a>
---
## 10/ Pré-autorise les permissions au lieu de --dangerously-skip-permissions
N'utilise pas `--dangerously-skip-permissions`. À la place, utilise `/permissions` pour pré-autoriser les commandes bash courantes que tu sais sûres dans ton environnement, afin d'éviter les demandes de permission inutiles. La plupart sont versionnées dans `.claude/settings.json` et partagées avec l'équipe.
<a href="https://x.com/bcherny/status/2007179854077407667"><img src="../../tips/assets/boris-26-1-3/10.png" alt="Pré-autoriser les permissions" width="50%" /></a>
---
## 11/ Laisse Claude utiliser tous tes outils via MCP
Claude Code utilise tous tes outils. Il cherche et publie souvent sur Slack (via le serveur MCP), lance des requêtes BigQuery pour répondre à des questions analytiques (avec le CLI `bq`), récupère les logs d'erreur depuis Sentry, etc. La configuration MCP de Slack est versionnée dans `.mcp.json` et partagée avec l'équipe.
<a href="https://x.com/bcherny/status/2007179856266789204"><img src="../../tips/assets/boris-26-1-3/11.png" alt="Outils MCP" width="50%" /></a>
---
## 12/ Vérifie les tâches de longue haleine avec des agents en arrière-plan
Pour les tâches très longues, soit (a) demande à Claude de vérifier son travail avec un agent en arrière-plan une fois terminé, soit (b) utilise un hook Stop d'agent pour le faire de façon plus déterministe, soit (c) utilise le plugin ralph-wiggum (imaginé à l'origine par @GeoffreyHuntley).
<a href="https://x.com/bcherny/status/2007179858435281082"><img src="../../tips/assets/boris-26-1-3/12.png" alt="Vérification des tâches de longue haleine" width="50%" /></a>
---
## 13/ Donne à Claude un moyen de vérifier son travail
Probablement la chose la plus importante pour obtenir d'excellents résultats avec Claude Code — donne à Claude un moyen de vérifier son travail. Si Claude dispose de cette boucle de rétroaction, il multipliera par 2 à 3 la qualité du résultat final.
Claude teste chaque modification que Boris intègre.
<a href="https://x.com/bcherny/status/2007179861115511237"><img src="../../tips/assets/boris-26-1-3/13.png" alt="Donner à Claude un moyen de vérifier" width="50%" /></a>
---
## Sources
- [Boris Cherny (@bcherny) sur X — 3 janvier 2026](https://x.com/bcherny/status/2007179832300581177)
fr/tips/claude-boris-15-tips-30-mar-26.md
+220
View File
@@ -0,0 +1,220 @@
# 15 fonctionnalités cachées & sous-exploitées de Claude Code — par Boris Cherny
Une synthèse d'astuces partagées par Boris Cherny ([@bcherny](https://x.com/bcherny)), créateur de Claude Code, le 30 mars 2026.
<table width="100%">
<tr>
<td><a href="../">← Retour à Claude Code Best Practice</a></td>
<td align="right"><img src="../../!/claude-jumping.svg" alt="Claude" width="60" /></td>
</tr>
</table>
---
## Contexte
Boris a partagé une série de ses fonctionnalités cachées et sous-exploitées préférées dans Claude Code, en se concentrant sur celles qu'il utilise le plus.
<a href="https://x.com/bcherny/status/2038454336355999749"><img src="../../tips/assets/boris-26-3-30/0.png" alt="Tweet d'intro de Boris Cherny" width="50%" /></a>
---
## 1/ Claude Code a une application mobile
Savais-tu que Claude Code a une application mobile ? Boris écrit beaucoup de son code depuis l'app iOS — c'est un moyen pratique de faire des changements sans ouvrir un ordinateur portable.
- Télécharge l'app Claude pour iOS/Android
- Va dans l'onglet **Code** sur la gauche
- Tu peux relire des changements, approuver des PR et écrire du code directement depuis ton téléphone
<a href="https://x.com/bcherny/status/2038454337811386436"><img src="../../tips/assets/boris-26-3-30/1.png" alt="Application mobile Claude Code" width="50%" /></a>
---
## 2/ Déplace des sessions entre mobile/web/desktop et terminal
Lance `claude --teleport` ou `/teleport` pour continuer une session cloud sur ta machine. Ou lance `/remote-control` pour piloter une session locale depuis ton téléphone/web.
- **Teleport** : rapatrie une session cloud vers ton terminal local
- **Remote Control** : te permet de piloter une session locale depuis n'importe quel appareil
- Boris a activé **« Enable Remote Control for all sessions »** dans son `/config`
<a href="https://x.com/bcherny/status/2038454339933548804"><img src="../../tips/assets/boris-26-3-30/2.png" alt="Teleport et Remote Control" width="50%" /></a>
---
## 3/ /loop et /schedule — deux des fonctionnalités les plus puissantes
Utilise-les pour planifier l'exécution automatique de Claude à intervalle fixe, jusqu'à une semaine d'affilée. Boris a tout un tas de boucles qui tournent localement :
- `/loop 5m /babysit` — traiter automatiquement la revue de code, rebaser automatiquement, et accompagner les PR jusqu'en production
- `/loop 30m /slack-feedback` — ouvrir automatiquement des PR pour les retours Slack toutes les 30 min
- `/loop /post-merge-sweeper` — ouvrir des PR pour traiter les commentaires de revue de code qu'il a manqués
- `/loop 1h /pr-pruner` — fermer les PR obsolètes et désormais inutiles
- ...et bien d'autres !
Expérimente en transformant des workflows en skills + boucles. C'est puissant.
<a href="https://x.com/bcherny/status/2038454341884154269"><img src="../../tips/assets/boris-26-3-30/3.png" alt="/loop et /schedule" width="50%" /></a>
---
## 4/ Utilise les hooks pour exécuter de la logique de façon déterministe
Utilise les hooks pour exécuter de la logique dans le cadre du cycle de vie de l'agent. Par exemple :
- **Charger dynamiquement** du contexte à chaque démarrage de Claude (`SessionStart`)
- **Journaliser chaque commande bash** que le modèle exécute (`PreToolUse`)
- **Router les demandes de permission** vers WhatsApp pour que tu approuves/refuses (`PermissionRequest`)
- **Relancer Claude** pour qu'il continue chaque fois qu'il s'arrête (`Stop`)
<a href="https://x.com/bcherny/status/2038454343519932844"><img src="../../tips/assets/boris-26-3-30/4.png" alt="Utilise les hooks" width="50%" /></a>
---
## 5/ Cowork Dispatch
Boris utilise Dispatch tous les jours pour rattraper Slack et ses e-mails, gérer des fichiers et faire des choses sur son portable quand il n'est pas devant un ordinateur. Quand il ne code pas, il dispatche.
- Dispatch est un **contrôle à distance sécurisé** pour l'application Claude Desktop
- Il peut utiliser tes MCP, ton navigateur et ton ordinateur, avec ta permission
- Vois-le comme un moyen de déléguer des tâches non liées au code à Claude depuis n'importe où
<a href="https://x.com/bcherny/status/2038454345419936040"><img src="../../tips/assets/boris-26-3-30/5.png" alt="Cowork Dispatch" width="50%" /></a>
---
## 6/ Utilise l'extension Chrome pour le travail frontend
L'astuce la plus importante pour utiliser Claude Code : **donne à Claude un moyen de vérifier sa sortie.** Une fois que tu fais cela, Claude itérera jusqu'à ce que le résultat soit excellent.
- Vois ça comme demander à quelqu'un de construire un site web sans l'autoriser à utiliser un navigateur — le résultat ne sera probablement pas beau
- Donne un navigateur à Claude et il écrira du code et itérera jusqu'à ce que ce soit beau
- Boris utilise l'extension Chrome chaque fois qu'il travaille sur du code web — elle a tendance à fonctionner plus fiablement que d'autres MCP similaires
<a href="https://x.com/bcherny/status/2038454347156398333"><img src="../../tips/assets/boris-26-3-30/6.png" alt="Extension Chrome pour le frontend" width="50%" /></a>
---
## 7/ Utilise l'app Claude Desktop pour démarrer et tester automatiquement des serveurs web
Dans la même veine, l'app Desktop intègre la capacité pour Claude de **lancer automatiquement ton serveur web et même de le tester dans un navigateur intégré.**
- Tu peux mettre en place quelque chose de similaire en CLI ou VS Code avec l'extension Chrome
- Ou utilise simplement l'app Desktop pour l'expérience intégrée
<a href="https://x.com/bcherny/status/2038454348804714642"><img src="../../tips/assets/boris-26-3-30/7.png" alt="Test de serveur web par l'app Desktop" width="50%" /></a>
---
## 8/ Forke ta session
On demande souvent comment forker une session existante. Deux façons :
1. Lance `/branch` depuis ta session
2. Depuis le CLI, lance `claude --resume <session-id> --fork-session`
`/branch` crée une conversation dérivée — tu es maintenant dans la branche. Pour reprendre l'originale, utilise `claude -r <original-session-id>`.
<a href="https://x.com/bcherny/status/2038454350214041740"><img src="../../tips/assets/boris-26-3-30/8.png" alt="Forke ta session" width="50%" /></a>
---
## 9/ Utilise /btw pour les questions annexes
Boris l'utilise tout le temps pour répondre à des questions rapides pendant que l'agent travaille. `/btw` te permet de poser une question annexe sans interrompre la tâche en cours de l'agent.
Exemple :
```
/btw how do I spell dachshund?
> dachshund — German for "badger dog" (dachs + badger, hund + dog).
↑/↓ to scroll · Space, Enter, or Escape to dismiss
```
<a href="https://x.com/bcherny/status/2038454351849787485"><img src="../../tips/assets/boris-26-3-30/9.png" alt="/btw pour les questions annexes" width="50%" /></a>
---
## 10/ Utilise les worktrees git
Claude Code embarque un support poussé des worktrees git. Les worktrees sont essentiels pour faire beaucoup de travail en parallèle dans le même dépôt. Boris a **des dizaines de Claude qui tournent en permanence**, et c'est comme ça qu'il s'y prend.
- Utilise `claude -w` pour démarrer une nouvelle session dans un worktree
- Ou coche la **case « worktree »** dans l'app Claude Desktop
- Pour les utilisateurs d'un VCS non-git, utilise le hook `WorktreeCreate` pour ajouter ta propre logique de création de worktree
<a href="https://x.com/bcherny/status/2038454353787519164"><img src="../../tips/assets/boris-26-3-30/10.png" alt="Worktrees git" width="50%" /></a>
---
## 11/ Utilise /batch pour déployer d'énormes lots de changements
`/batch` t'interroge, puis fait répartir le travail par Claude vers autant d'**agents worktree** que nécessaire (des dizaines, des centaines, voire des milliers) pour le mener à bien.
- Utilise-le pour les grosses migrations de code et autres travaux parallélisables
- Chaque agent worktree travaille indépendamment sur sa propre copie du codebase
<a href="https://x.com/bcherny/status/2038454355469484142"><img src="../../tips/assets/boris-26-3-30/11.png" alt="/batch pour d'énormes lots de changements" width="50%" /></a>
---
## 12/ Utilise --bare pour accélérer le démarrage du SDK jusqu'à 10×
Par défaut, quand tu lances `claude -p` (ou les SDK TypeScript ou Python), Claude recherche les CLAUDE.md, paramètres et MCP locaux. Mais pour un usage non interactif, la plupart du temps tu veux spécifier explicitement ce qui est chargé via `--system-prompt`, `--mcp-config`, `--settings`, etc.
- C'était une erreur de conception lors de la première version du SDK
- Dans une version future, le défaut basculera sur `--bare`
- Pour l'instant, opte pour ce comportement avec le drapeau afin d'obtenir un démarrage **jusqu'à 10× plus rapide**
```bash
claude -p "summarize this codebase" \
--output-format=stream-json \
--verbose \
--bare
```
<a href="https://x.com/bcherny/status/2038454357088457168"><img src="../../tips/assets/boris-26-3-30/12.png" alt="Drapeau --bare pour le démarrage du SDK" width="50%" /></a>
---
## 13/ Utilise --add-dir pour donner à Claude l'accès à plus de dossiers
Quand il travaille sur plusieurs dépôts, Boris démarre généralement Claude dans un dépôt et utilise `--add-dir` (ou `/add-dir`) pour que Claude voie l'autre dépôt.
- Cela informe non seulement Claude sur le dépôt, mais lui **donne aussi les permissions** d'y travailler
- Ou ajoute `"additionalDirectories"` au `settings.json` de ton équipe pour toujours charger des dossiers supplémentaires au démarrage de Claude Code
<a href="https://x.com/bcherny/status/2038454359047156203"><img src="../../tips/assets/boris-26-3-30/13.png" alt="--add-dir pour plusieurs dépôts" width="50%" /></a>
---
## 14/ Utilise --agent pour donner à Claude Code un system prompt & des outils personnalisés
Les agents personnalisés sont une primitive puissante souvent négligée. Pour l'utiliser, définis simplement un nouvel agent dans `.claude/agents/`, puis lance :
```bash
claude --agent=<nom de ton agent>
```
- Les agents peuvent avoir des outils restreints, des descriptions personnalisées et des modèles spécifiques
- Ils sont parfaits pour créer des agents en lecture seule, des agents de revue spécialisés ou des outils propres à un domaine
<a href="https://x.com/bcherny/status/2038454360418787764"><img src="../../tips/assets/boris-26-3-30/14.png" alt="--agent pour des system prompts personnalisés" width="50%" /></a>
---
## 15/ Utilise /voice pour activer la saisie vocale
Anecdote : Boris fait l'essentiel de son code en parlant à Claude, plutôt qu'en tapant.
- Lance `/voice` en CLI puis maintiens la barre d'espace pour parler
- Appuie sur le bouton vocal sur Desktop
- Ou active la dictée dans les réglages de ton iOS
<a href="https://x.com/bcherny/status/2038454362226467112"><img src="../../tips/assets/boris-26-3-30/15.png" alt="/voice pour la saisie vocale" width="50%" /></a>
---
## Sources
- [Boris Cherny (@bcherny) sur X — 30 mars 2026](https://x.com/bcherny/status/2038454336355999749)
fr/tips/claude-boris-2-tips-10-mar-26.md
+40
View File
@@ -0,0 +1,40 @@
# Revue de code & calcul à l'inférence — Astuces de Boris Cherny
Une synthèse des observations partagées par Boris Cherny ([@bcherny](https://x.com/bcherny)), créateur de Claude Code, le 10 mars 2026.
<table width="100%">
<tr>
<td><a href="../">← Retour à Claude Code Best Practice</a></td>
<td align="right"><img src="../../!/claude-jumping.svg" alt="Claude" width="60" /></td>
</tr>
</table>
---
## 1/ Présentation de la revue de code (Code Review)
Nouveauté dans Claude Code : **Code Review**. Une équipe d'agents effectue une revue approfondie sur chaque PR.
- Conçu d'abord pour l'équipe d'Anthropic elle-même — la production de code par ingénieur a augmenté de **200 % cette année**, et les revues étaient le goulot d'étranglement
- Boris l'utilise depuis quelques semaines et constate qu'il détecte de nombreux bugs réels qu'il n'aurait pas remarqués autrement
- À l'ouverture d'une PR, Claude dépêche une équipe d'agents pour traquer les bugs
<a href="https://x.com/bcherny/status/2031089411820228645"><img src="../../tips/assets/boris-26-3-10/0.png" alt="Boris Cherny annonçant Code Review" width="50%" /></a>
---
## 2/ Calcul à l'inférence & fenêtres de contexte multiples
En gros, plus on alloue de tokens à un problème de code, meilleur est le résultat. Boris appelle cela le **calcul à l'inférence** (test time compute).
- Utiliser des **fenêtres de contexte distinctes** améliore encore le résultat — c'est ce qui fait fonctionner les sous-agents, et la raison pour laquelle un agent peut introduire des bugs qu'un autre (utilisant exactement le même modèle) saura détecter
- Comparable aux équipes d'ingénierie : si Boris introduit un bug, son collègue qui relit le code a plus de chances de le repérer que lui
- À la limite, les agents écriront probablement un code parfait, sans bug — d'ici là, **plusieurs fenêtres de contexte non corrélées** reste une bonne approche
<a href="https://x.com/bcherny/status/2031151689219321886"><img src="../../tips/assets/boris-26-3-10/1.png" alt="Boris Cherny à propos du calcul à l'inférence" width="50%" /></a>
---
## Sources
- [Boris Cherny (@bcherny) sur X — 10 mars 2026](https://x.com/bcherny)
fr/tips/claude-boris-2-tips-25-mar-26.md
+48
View File
@@ -0,0 +1,48 @@
# Squash merge & distribution de la taille des PR — Astuces de Boris Cherny
Une synthèse des observations partagées par Boris Cherny ([@bcherny](https://x.com/bcherny)), créateur de Claude Code, le 25 mars 2026.
<table width="100%">
<tr>
<td><a href="../">← Retour à Claude Code Best Practice</a></td>
<td align="right"><img src="../../!/claude-jumping.svg" alt="Claude" width="60" /></td>
</tr>
</table>
---
## 1/ 266 contributions en une seule journée — toujours squasher
Boris a partagé son graphe de contributions GitHub montrant **266 contributions le 24 mars** — issues de **141 PR, toujours squashées**, avec une médiane de **118 lignes** par PR.
- Le squash merge fusionne tous les commits d'une branche en un seul commit sur la branche cible — l'historique reste propre et linéaire
- Une PR = un commit : il devient facile d'annuler des fonctionnalités entières et `git bisect` est simplifié
- Dans des workflows assistés par IA à haute vélocité (141 PR/jour), le squash est le choix pragmatique — les commits individuels « fix lint », « try this » au sein d'une branche ne sont que du bruit
<a href="https://x.com/bcherny/status/2038552880018538749"><img src="../../tips/assets/boris-26-3-25/1.png" alt="Boris Cherny — 266 contributions, toujours squashées" width="50%" /></a>
---
## 2/ Distribution de la taille des PR — garde des PR petites
Boris a partagé la distribution des tailles sur ces 141 PR, totalisant **45 032 lignes modifiées** (ajouts + suppressions) :
| Métrique | Lignes (ajout+supp) | Signification |
|--------|---------------:|---------|
| **p50** | **118** | Taille médiane d'une PR — la moitié des PR faisaient 118 lignes ou moins |
| p90 | 498 | 90 % des PR faisaient moins de 500 lignes |
| **p99** | **2 978** | Seule ~1 PR dépassait ~3 000 lignes |
| min | 2 | Plus petite PR — un correctif rapide de 2 lignes |
| max | 10 459 | Plus grosse PR unique — probablement une migration ou du code généré |
- Une **médiane de 118 lignes** signifie que la plupart des PR sont ciblées et relisables, même à 141 PR/jour
- La distribution est fortement asymétrique à droite — la grosse PR occasionnelle est inévitable (renommages massifs, migrations), mais la norme reste serrée
- Les petites PR réduisent le risque de conflit de merge, sont plus faciles à relire et se marient parfaitement avec le squash merge pour des annulations propres
<a href="https://x.com/bcherny/status/2038552880018538749"><img src="../../tips/assets/boris-26-3-25/2.png" alt="Boris Cherny — tableau de distribution de la taille des PR" width="50%" /></a>
---
## Sources
- [Boris Cherny (@bcherny) sur X — 25 mars 2026](https://x.com/bcherny)
fr/tips/claude-boris-6-tips-16-apr-26.md
+117
View File
@@ -0,0 +1,117 @@
# 6 astuces pour tirer le meilleur d'Opus 4.7 — par Boris Cherny
Un fil d'astuces partagé par Boris Cherny ([@bcherny](https://x.com/bcherny)), créateur de Claude Code, le 16 avril 2026 — après avoir utilisé Opus 4.7 en interne (dogfooding) ces dernières semaines.
<table width="100%">
<tr>
<td><a href="../">← Retour à Claude Code Best Practice</a></td>
<td align="right"><img src="../../!/claude-jumping.svg" alt="Claude" width="60" /></td>
</tr>
</table>
---
## Contexte
Après avoir utilisé Opus 4.7 en interne pendant quelques semaines, Boris se sent « incroyablement productif » et partage six façons de tirer davantage du nouveau modèle — de l'automatisation des permissions au réglage de l'effort, en passant par les schémas de vérification.
<a href="https://x.com/bcherny"><img src="../../tips/assets/boris-26-4-16/0.png" alt="Tweet d'intro de Boris Cherny — dogfooding d'Opus 4.7" width="50%" /></a>
---
## 1/ Mode Auto — fini les demandes de permission
Opus 4.7 adore les tâches complexes et de longue haleine : recherche approfondie, refactorisation de code, construction de fonctionnalités complexes, itération jusqu'à atteindre un benchmark de performance. Auparavant, il fallait soit surveiller le modèle pendant ces longues tâches, soit utiliser `--dangerously-skip-permissions`.
Anthropic a récemment déployé le **mode auto** comme alternative plus sûre. Dans ce mode, les demandes de permission sont routées vers un classifieur fondé sur un modèle qui décide si la commande est sûre à exécuter :
- Si c'est sûr, approbation automatique
- Si c'est risqué, pause et demande
Plus besoin de surveiller pendant que le modèle tourne. Mieux encore : tu peux faire tourner plus de Claude en parallèle — si c'est sûr, tu peux passer ton attention au Claude suivant.
Le mode auto est désormais disponible pour Opus 4.7 pour les utilisateurs Max, Teams et Enterprise. **Shift+Tab** pour faire défiler `Ask permissions` → `Plan mode` → `Auto mode` dans le CLI, ou choisis-le dans le menu déroulant sur Desktop ou VS Code.
<a href="https://x.com/bcherny"><img src="../../tips/assets/boris-26-4-16/1.png" alt="Boris Cherny à propos du mode auto" width="50%" /></a>
---
## 2/ Le nouveau skill /fewer-permission-prompts
Anthropic a publié un nouveau skill `/fewer-permission-prompts`. Il parcourt l'historique de ta session pour trouver les commandes bash et MCP courantes qui sont sûres mais demandent répétitivement une permission. Il recommande ensuite une liste de commandes à ajouter à ta liste d'autorisations (allowlist).
Utilise-le pour ajuster tes permissions et éviter les demandes inutiles, surtout si tu n'utilises pas le mode auto.
<a href="https://x.com/bcherny"><img src="../../tips/assets/boris-26-4-16/2.png" alt="Boris Cherny à propos du skill /fewer-permission-prompts" width="50%" /></a>
---
## 3/ Récapitulatifs (Recaps)
Anthropic a livré les **récapitulatifs** plus tôt cette semaine, en préparation d'Opus 4.7. Les récapitulatifs sont de courts résumés de ce qu'un agent a fait et de ce qui vient ensuite.
Très utile quand tu reviens sur une session de longue haleine après quelques minutes ou quelques heures :
```
* Cogitated for 6m 27s
* recap: Fixing the post-submit transcript shift bug. The styling-flash
part is shipped as PR #29869 (auto-merge on, posted to stamps). Next:
I need a screen recording of the remaining horizontal rewrap on `cc -c`
to target that separate cause. (disable recaps in /config)
```
Désactive les récapitulatifs dans `/config` si tu n'en veux pas.
<a href="https://x.com/bcherny"><img src="../../tips/assets/boris-26-4-16/3.png" alt="Boris Cherny à propos des récapitulatifs" width="50%" /></a>
---
## 4/ Mode Focus
Boris adore le nouveau **mode focus** du CLI, qui masque tout le travail intermédiaire pour se concentrer uniquement sur le résultat final. Le modèle a atteint un point où il lui fait globalement confiance pour lancer les bonnes commandes et faire les bonnes modifications. Il ne regarde que le résultat final.
Utilise `/focus` pour l'activer/désactiver.
<a href="https://x.com/bcherny"><img src="../../tips/assets/boris-26-4-16/4.png" alt="Boris Cherny à propos du mode focus" width="50%" /></a>
---
## 5/ Configure ton niveau d'effort
Opus 4.7 utilise la **réflexion adaptative** au lieu de budgets de réflexion. Pour régler le modèle afin qu'il réfléchisse plus ou moins, ajuste l'effort.
- **Effort plus faible** — réponses plus rapides et usage de tokens réduit
- **Effort plus élevé** — le maximum d'intelligence et de capacité
Le curseur présente cinq niveaux : `low` · `medium` · `high` · `xhigh` · `max` — Vitesse à gauche, Intelligence à droite.
<a href="https://x.com/bcherny"><img src="../../tips/assets/boris-26-4-16/5.png" alt="Boris Cherny à propos des niveaux d'effort" width="50%" /></a>
---
## 6/ Donne à Claude un moyen de vérifier son travail
Enfin, assure-toi que Claude a un moyen de vérifier son travail. Cela a toujours été important — maintenant que 4.7 donne 2 à 3× plus que ce que tu tirais de Claude auparavant, c'est plus important que jamais.
La vérification prend différentes formes selon la tâche :
- **Travail backend** — fais lancer ton serveur/service par Claude pour tester de bout en bout
- **Travail frontend** — utilise l'[extension Chromium de Claude](https://code.claude.com/docs/en/chrome) pour donner à Claude un moyen de contrôler ton navigateur
- **Applications desktop** — utilise Computer Use
Ces temps-ci, les prompts de Boris ressemblent à `Claude fais blah blah /go`, où `/go` est un skill qui :
1. Se teste de bout en bout via bash, navigateur ou computer use
2. Lance `/simplify`
3. Ouvre une PR
Pour le travail de longue haleine, la vérification compte encore plus — quand tu reviens sur une tâche, tu sais que le code fonctionne.
<a href="https://x.com/bcherny"><img src="../../tips/assets/boris-26-4-16/6.png" alt="Boris Cherny à propos de la vérification" width="50%" /></a>
---
## Sources
- [Boris Cherny (@bcherny) sur X — 16 avril 2026](https://x.com/bcherny)
fr/tips/claude-thariq-tips-16-apr-26.md
+177
View File
@@ -0,0 +1,177 @@
# Utiliser Claude Code : gestion des sessions & contexte de 1M — Thariq
Un guide sur la gestion des sessions, des fenêtres de contexte et de la compaction dans Claude Code, partagé par Thariq ([@trq212](https://x.com/trq212)) le 16 avril 2026.
<table width="100%">
<tr>
<td><a href="../">← Retour à Claude Code Best Practice</a></td>
<td align="right"><img src="../../!/claude-jumping.svg" alt="Claude" width="60" /></td>
</tr>
</table>
---
## Contexte
Avec la fenêtre de contexte de 1M de tokens, Claude Code peut gérer des tâches plus longues de façon plus fiable — mais cela ouvre aussi la porte à la pollution de contexte si tu ne gères pas tes sessions avec intention. La gestion des sessions compte plus que jamais : quand repartir de zéro, quand compacter, quand revenir en arrière, et quand déléguer à des sous-agents.
<img src="../../tips/assets/thariq-26-4-16/1.png" alt="Tweet d'intro de Thariq" width="50%" />
<img src="../../tips/assets/thariq-26-4-16/2.png" alt="Introduction à la gestion des sessions" width="50%" />
---
## Petit rappel sur le contexte, la compaction & le context rot
La fenêtre de contexte est tout ce que le modèle peut « voir » d'un coup au moment de générer sa prochaine réponse. Elle inclut ton system prompt, la conversation jusqu'ici, chaque appel d'outil et sa sortie, et chaque fichier lu. Claude Code a une fenêtre de contexte d'**un million de tokens**.
Malheureusement, utiliser du contexte a un léger coût — le **context rot** (dégradation du contexte). Les performances du modèle se dégradent à mesure que le contexte grossit, car l'attention se répartit sur davantage de tokens, et le contenu ancien et non pertinent commence à détourner de la tâche en cours. Pour le modèle à 1M de contexte, un certain niveau de context rot survient autour de **~300-400k tokens**, mais cela dépend fortement de la tâche — ce n'est pas une règle stricte.
Les fenêtres de contexte sont une limite franche. Quand tu approches de la fin, tu dois résumer la tâche et continuer dans une nouvelle fenêtre de contexte — c'est la **compaction**. Tu peux aussi déclencher la compaction toi-même.
<img src="../../tips/assets/thariq-26-4-16/3.png" alt="Schéma de la fenêtre de contexte" width="50%" />
<img src="../../tips/assets/thariq-26-4-16/4.png" alt="Explication du context rot" width="50%" />
---
## Chaque tour est un point de branchement
Une fois que Claude termine un tour, tu disposes d'un nombre étonnant d'options pour la suite :
- **Continuer** — envoyer un autre message dans la même session
- **/rewind (esc esc)** — revenir à un message précédent et réessayer à partir de là
- **/clear** — démarrer une nouvelle session, généralement avec un brief distillé de ce que tu viens d'apprendre
- **Compacter** — résumer la session jusqu'ici et continuer par-dessus le résumé
- **Sous-agents** — déléguer le prochain bloc de travail à un agent doté de son propre contexte propre, et n'en récupérer que le résultat
Si la voie la plus naturelle est simplement de continuer, les quatre autres options existent pour t'aider à gérer ton contexte.
<img src="../../tips/assets/thariq-26-4-16/5.png" alt="Schéma de compaction et de branchement" width="50%" />
<img src="../../tips/assets/thariq-26-4-16/6.png" alt="Cinq options après un tour" width="50%" />
Chaque option reporte une quantité différente de contexte existant :
| Nouvelle session | Compacter | Sous-agent | Rewind | Continuer |
|:---:|:---:|:---:|:---:|:---:|
| ton brief seul | résumé avec perte | tout + résultat | préfixe gardé, fin coupée | tout reste |
| *rien* | | | | *tout* |
<img src="../../tips/assets/thariq-26-4-16/7.png" alt="Spectre de report du contexte" width="50%" />
---
## Quand démarrer une nouvelle session
Les nouvelles fenêtres de contexte de 1M signifient que tu peux désormais faire des tâches plus longues de façon plus fiable — par exemple, construire une app full-stack de zéro. Mais ce n'est pas parce que ton modèle n'est pas à court de contexte que tu ne devrais pas démarrer une nouvelle session.
**Règle générale : quand tu commences une nouvelle tâche, tu devrais aussi démarrer une nouvelle session.**
Une zone grise apparaît quand tu veux faire des tâches connexes où une partie du contexte reste nécessaire, mais pas tout. Par exemple, écrire la documentation d'une fonctionnalité que tu viens d'implémenter. Tu pourrais démarrer une nouvelle session, mais Claude devrait relire les fichiers, ce qui serait plus lent et plus coûteux. Comme la documentation n'est peut-être pas une tâche très sensible à l'intelligence, le contexte supplémentaire vaut probablement le gain d'efficacité.
<img src="../../tips/assets/thariq-26-4-16/8.png" alt="Quand démarrer une nouvelle session" width="50%" />
---
## Revenir en arrière (rewind) plutôt que corriger
Si Thariq devait choisir une seule habitude qui signale une bonne gestion du contexte, ce serait le **rewind**.
Dans Claude Code, double-taper Échap (ou lancer `/rewind`) te permet de revenir à n'importe quel message précédent et de re-prompter à partir de là. Les messages postérieurs à ce point sont retirés du contexte.
**Corriger** (dire « non, essaie B » après une tentative A ratée) laisse la tentative ratée dans le contexte :
> contexte = lectures + 2 tentatives ratées + 2 corrections + le correctif
**Revenir en arrière** (remonter avant la tentative ratée et re-prompter avec ce que tu as appris) est plus propre :
> contexte = lectures + un prompt informé + le correctif
Le rewind est souvent la meilleure approche. Par exemple, Claude lit cinq fichiers, tente une approche, et ça ne marche pas. Ton instinct pourrait être de taper « ça n'a pas marché, essaie X à la place ». Mais le meilleur geste est de revenir juste après les lectures de fichiers, et de re-prompter avec ce que tu as appris : « N'utilise pas l'approche A, le module foo ne l'expose pas — va directement vers B. »
Tu peux aussi utiliser **« summarize from here »** (résumer à partir d'ici) pour que Claude résume ses apprentissages et crée un message de passation, un peu comme un message à l'itération précédente de Claude de la part de son futur lui qui a essayé quelque chose qui n'a pas marché.
<img src="../../tips/assets/thariq-26-4-16/9.png" alt="Schéma corriger vs revenir en arrière" width="50%" />
<img src="../../tips/assets/thariq-26-4-16/10.png" alt="Rewind avec summarize from here" width="50%" />
---
## Compacter vs. nouvelles sessions
Une fois qu'une session s'allonge, tu as deux façons de t'alléger : `/compact` ou `/clear` (et repartir de zéro). Elles semblent similaires mais se comportent très différemment.
**Compacter** demande au modèle de résumer la conversation jusqu'ici, puis remplace l'historique par ce résumé. C'est avec perte — tu fais confiance à Claude pour décider de ce qui comptait, mais tu n'as rien eu à écrire toi-même. Claude pourrait être plus exhaustif en incluant des apprentissages ou fichiers importants. Tu peux aussi l'orienter en passant des instructions (`/compact concentre-toi sur le refactor d'auth, laisse tomber le débogage des tests`).
- **En cours de tâche**, garde l'élan — les détails peuvent rester flous
- Pas cher, continue
**Nouvelle session + brief** (`/clear`) signifie que *toi* tu notes ce qui compte (« on refactore le middleware d'auth, la contrainte est X, les fichiers qui comptent sont A et B, on a écarté l'approche Y ») et tu repars propre. C'est plus de travail, mais le contexte obtenu est ce que *toi* tu as jugé pertinent.
- **Étape suivante à fort enjeu** — un seul fait trouvé dans 100K d'exploration
- Plus de travail, plus exact
<img src="../../tips/assets/thariq-26-4-16/11.png" alt="Compacter vs nouvelles sessions" width="50%" />
<img src="../../tips/assets/thariq-26-4-16/12.png" alt="Schéma compacter vs nouvelle session" width="50%" />
---
## Qu'est-ce qui cause une mauvaise compaction ?
Si tu lances beaucoup de sessions de longue haleine, tu as peut-être remarqué des moments où la compaction peut être particulièrement mauvaise. Les mauvaises compactions surviennent quand le modèle ne peut pas prédire la direction que prend ton travail.
Par exemple, l'autocompaction se déclenche après une longue session de débogage et résume l'investigation. Ton message suivant est « maintenant corrige cet autre avertissement qu'on a vu dans bar.ts ». Mais comme la session était centrée sur le débogage, l'autre avertissement a peut-être été retiré du résumé.
C'est particulièrement délicat, car à cause du context rot, le modèle est à son point le moins intelligent au moment de compacter. Avec un million de contexte, tu as plus de temps pour `/compact` de façon proactive avec une description de ce que tu veux faire.
<img src="../../tips/assets/thariq-26-4-16/13.png" alt="Schéma de mauvaise compaction" width="50%" />
<img src="../../tips/assets/thariq-26-4-16/14.png" alt="Explication de la mauvaise compaction" width="50%" />
---
## Sous-agents & fenêtres de contexte neuves
Les sous-agents sont une forme de gestion du contexte, utiles quand tu sais à l'avance qu'un bloc de travail produira beaucoup de sortie intermédiaire dont tu n'auras plus besoin.
Quand Claude crée un sous-agent via l'outil Agent, ce sous-agent obtient sa propre fenêtre de contexte neuve. Il peut faire autant de travail que nécessaire, puis synthétiser ses résultats pour que seul le rapport final revienne au parent.
Le test mental : **aurai-je encore besoin de cette sortie d'outil, ou seulement de la conclusion ?**
Le bruit d'exploration est nettoyé (garbage-collected) à la sortie du sous-agent — 20 lectures de fichiers, 12 greps, 3 impasses — seul le rapport final revient au contexte parent.
Bien que Claude Code appelle automatiquement des sous-agents, tu voudras peut-être le lui demander explicitement. Par exemple :
- « Crée un sous-agent pour vérifier le résultat de ce travail selon le fichier de spec suivant »
- « Crée un sous-agent pour parcourir cet autre codebase et résumer comment il a implémenté le flux d'auth, puis implémente-le toi-même de la même façon »
- « Crée un sous-agent pour écrire la doc de cette fonctionnalité à partir de mes changements git »
<img src="../../tips/assets/thariq-26-4-16/15.png" alt="Schéma de contexte des sous-agents" width="50%" />
<img src="../../tips/assets/thariq-26-4-16/16.png" alt="Explication des sous-agents" width="50%" />
<img src="../../tips/assets/thariq-26-4-16/17.png" alt="Quand utiliser des sous-agents" width="50%" />
---
## Synthèse
Quand Claude a terminé un tour et que tu t'apprêtes à envoyer un nouveau message, tu es à un point de décision. Avec le temps, Claude gérera cela tout seul, mais pour l'instant c'est l'un des moyens dont tu disposes pour guider la sortie de Claude.
| Situation | Recours | Pourquoi |
|-----------|-----------|-----|
| Même tâche, le contexte est encore pertinent | **Continuer** | Tout dans la fenêtre est encore porteur — ne paie pas pour le reconstruire |
| Claude a pris une mauvaise voie | **Rewind** (double-Échap) | Garde les lectures de fichiers utiles, jette la tentative ratée, re-prompte avec ce que tu as appris |
| En cours de tâche mais session encombrée de débogage/exploration périmés | **/compact \<indice\>** | Peu d'effort ; Claude décide de ce qui comptait. Oriente-le avec un indice si besoin |
| Démarrage d'une tâche véritablement nouvelle | **/clear** | Zéro rot ; tu contrôles exactement ce qui est reporté |
| L'étape suivante générera beaucoup de sortie dont tu ne veux que la conclusion | **Sous-agent** | Le bruit d'outil intermédiaire reste dans le contexte de l'enfant ; seul le résultat revient |
<img src="../../tips/assets/thariq-26-4-16/18.png" alt="Synthèse" width="50%" />
<img src="../../tips/assets/thariq-26-4-16/19.png" alt="Table de décision" width="50%" />
---
## Sources
- [Thariq (@trq212) sur X — 16 avril 2026](https://x.com/trq212)
fr/tips/claude-thariq-tips-17-mar-26.md
+260
View File
@@ -0,0 +1,260 @@
# Leçons de la construction de Claude Code : comment nous utilisons les skills — Thariq
Un guide complet sur la façon dont Anthropic utilise les skills en interne, partagé par Thariq ([@trq212](https://x.com/trq212)) le 17 mars 2026.
<table width="100%">
<tr>
<td><a href="../">← Retour à Claude Code Best Practice</a></td>
<td align="right"><img src="../../!/claude-jumping.svg" alt="Claude" width="60" /></td>
</tr>
</table>
---
## Contexte
Les skills sont devenus l'un des points d'extension les plus utilisés dans Claude Code. Ils sont flexibles, faciles à créer et simples à distribuer. Mais cette flexibilité rend aussi difficile de savoir ce qui marche le mieux. Thariq partage les leçons tirées d'un usage intensif des skills chez Anthropic, avec des centaines d'entre eux en service actif.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/1.png" alt="Tweet d'intro de Thariq" width="50%" /></a>
---
## Que sont les skills ?
Une idée reçue courante est que les skills sont « juste des fichiers markdown », mais le plus intéressant est qu'il s'agit de **dossiers** pouvant inclure des scripts, des assets, des données, etc. — des choses que l'agent peut découvrir, explorer et manipuler. Les skills offrent aussi une grande variété d'options de configuration, dont l'enregistrement de hooks dynamiques.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/2.png" alt="Que sont les skills ?" width="50%" /></a>
---
## Types de skills
Après avoir catalogué tous leurs skills, l'équipe a remarqué qu'ils se regroupent en 9 catégories récurrentes. Les meilleurs skills s'inscrivent proprement dans une seule ; les plus confus chevauchent plusieurs catégories.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/3.png" alt="Grille des types de skills" width="50%" /></a>
---
### 1/ Référence de bibliothèque & d'API
Des skills qui expliquent comment utiliser correctement une bibliothèque, un CLI ou des SDK. Ils peuvent concerner des bibliothèques internes ou des bibliothèques courantes avec lesquelles Claude Code a parfois des difficultés. Ils incluent souvent un dossier d'extraits de code de référence et une liste de pièges à éviter lors de l'écriture d'un script.
**Exemples :** billing-lib, internal-platform-cli, frontend-design
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/4.png" alt="Référence de bibliothèque & d'API" width="50%" /></a>
---
### 2/ Vérification produit
Des skills qui décrivent comment tester ou vérifier que ton code fonctionne. Ils sont souvent associés à un outil externe comme Playwright, tmux, etc. Les skills de vérification sont extrêmement utiles pour s'assurer que la sortie de Claude est correcte. Cela peut valoir le coup qu'un ingénieur passe une semaine entière à rendre tes skills de vérification excellents.
**Exemples :** signup-flow-driver, checkout-verifier, tmux-cli-driver
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/5.png" alt="Vérification produit" width="50%" /></a>
---
### 3/ Récupération & analyse de données
Des skills qui se connectent à tes stacks de données et de monitoring. Ils peuvent inclure des bibliothèques pour récupérer tes données avec des identifiants, des IDs de dashboard spécifiques, etc., ainsi que des instructions sur les workflows courants ou les moyens d'obtenir des données.
**Exemples :** funnel-query, cohort-compare, grafana
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/6.png" alt="Récupération & analyse de données" width="50%" /></a>
---
### 4/ Processus métier & automatisation d'équipe
Des skills qui automatisent des workflows répétitifs en une seule commande. Ce sont généralement des instructions assez simples, mais qui peuvent avoir des dépendances plus complexes vers d'autres skills ou MCP. Sauvegarder les résultats précédents dans des fichiers de log peut aider le modèle à rester cohérent et à réfléchir aux exécutions précédentes du workflow.
**Exemples :** standup-post, create-\<ticket-system\>-ticket, weekly-recap
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/7.png" alt="Processus métier & automatisation d'équipe" width="50%" /></a>
---
### 5/ Échafaudage de code & templates
Des skills qui génèrent du boilerplate de framework pour une fonction spécifique du codebase. Tu peux combiner ces skills avec des scripts composables. Ils sont particulièrement utiles quand ton échafaudage a des exigences en langage naturel qui ne peuvent pas être couvertes purement par du code.
**Exemples :** new-\<framework\>-workflow, new-migration, create-app
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/8.png" alt="Échafaudage de code & templates" width="50%" /></a>
---
### 6/ Qualité & revue de code
Des skills qui font respecter la qualité du code au sein de ton organisation et aident à relire le code. Ils peuvent inclure des scripts ou outils déterministes pour une robustesse maximale. Tu voudras peut-être lancer ces skills automatiquement via des hooks ou à l'intérieur d'une GitHub Action.
**Exemples :** adversarial-review, code-style, testing-practices
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/9.png" alt="Qualité & revue de code" width="50%" /></a>
---
### 7/ CI/CD & déploiement
Des skills qui t'aident à récupérer, pousser et déployer du code dans ton codebase. Ces skills peuvent référencer d'autres skills pour collecter des données.
**Exemples :** babysit-pr, deploy-\<service\>, cherry-pick-prod
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/10.png" alt="CI/CD & déploiement" width="50%" /></a>
---
### 8/ Runbooks
Des skills qui partent d'un symptôme (comme un fil Slack, une alerte ou une signature d'erreur), déroulent une investigation multi-outils et produisent un rapport structuré.
**Exemples :** \<service\>-debugging, oncall-runner, log-correlator
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/11.png" alt="Runbooks" width="50%" /></a>
---
### 9/ Opérations d'infrastructure
Des skills qui effectuent de la maintenance routinière et des procédures opérationnelles — dont certaines impliquent des actions destructrices qui bénéficient de garde-fous. Ils permettent aux ingénieurs de suivre plus facilement les bonnes pratiques dans les opérations critiques.
**Exemples :** \<resource\>-orphans, dependency-management, cost-investigation
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/12.png" alt="Opérations d'infrastructure" width="50%" /></a>
---
## Astuces pour créer des skills
9 bonnes pratiques pour écrire des skills efficaces, plus des conseils sur la distribution et la mesure.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/13.png" alt="Grille des astuces pour créer des skills" width="50%" /></a>
---
### Astuce 1 : N'énonce pas l'évidence
Claude Code en sait beaucoup sur ton codebase, et Claude en sait beaucoup sur le code, y compris de nombreuses opinions par défaut. Si tu publies un skill qui porte avant tout sur de la connaissance, essaie de te concentrer sur l'information qui pousse Claude hors de son mode de pensée habituel. Le skill de design frontend en est un excellent exemple — il a été construit en itérant avec des clients pour améliorer le goût de Claude en matière de design, en évitant les patterns classiques comme la police Inter et les dégradés violets.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/14.png" alt="N'énonce pas l'évidence" width="50%" /></a>
---
### Astuce 2 : Construis une section Gotchas (pièges)
Le contenu à plus fort signal dans n'importe quel skill est la section Gotchas. Ces sections doivent être bâties à partir des points d'échec courants que Claude rencontre en utilisant ton skill. Idéalement, tu mettras ton skill à jour au fil du temps pour capturer ces pièges.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/15.png" alt="Construis une section Gotchas" width="50%" /></a>
---
### Astuce 3 : Utilise le système de fichiers & la divulgation progressive
Un skill est un dossier, pas seulement un fichier markdown. Tu devrais penser l'ensemble du système de fichiers comme une forme d'ingénierie de contexte et de divulgation progressive. Dis à Claude quels fichiers se trouvent dans ton skill, et il les lira au moment opportun. La forme la plus simple est de pointer vers d'autres fichiers markdown — par ex. répartir les signatures de fonctions détaillées et les exemples d'usage dans `references/api.md`. Tu peux avoir des dossiers de références, de scripts, d'exemples, etc.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/16.png" alt="Divulgation progressive" width="50%" /></a>
---
### Astuce 4 : Évite de mettre Claude sur des rails
Claude essaiera généralement de s'en tenir à tes instructions, et comme les skills sont très réutilisables, tu voudras éviter d'être trop spécifique. Donne à Claude l'information dont il a besoin, mais laisse-lui la flexibilité de s'adapter à la situation. Plutôt que des instructions prescriptives étape par étape, donne l'objectif et les contraintes.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/17.png" alt="Évite de mettre Claude sur des rails" width="50%" /></a>
---
### Astuce 5 : Réfléchis à la configuration (setup)
Certains skills peuvent nécessiter d'être configurés avec du contexte de la part de l'utilisateur. Un bon pattern est de stocker ces informations de setup dans un fichier `config.json` dans le répertoire du skill. Si la config n'est pas en place, l'agent peut alors demander l'information à l'utilisateur. Tu peux instruire Claude d'utiliser l'outil AskUserQuestion pour des questions à choix multiples structurées.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/18.png" alt="Réfléchis à la configuration" width="50%" /></a>
---
### Astuce 6 : Le champ Description est destiné au modèle
Quand Claude Code démarre une session, il construit une liste de chaque skill disponible avec sa description. C'est cette liste que Claude parcourt pour décider « y a-t-il un skill pour cette requête ? ». Ce qui signifie que le champ description n'est pas un résumé — c'est une description de **quand déclencher** ce skill. Écris-le pour le modèle.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/19.png" alt="Description = Déclencheur" width="50%" /></a>
---
### Astuce 7 : Mémoire & stockage de données
Certains skills peuvent inclure une forme de mémoire en stockant des données en leur sein. Tu pourrais stocker des données dans quelque chose d'aussi simple qu'un fichier texte en append-only ou des fichiers JSON, ou d'aussi complexe qu'une base SQLite. Les données stockées dans le répertoire du skill peuvent être supprimées lors d'une mise à jour du skill, alors utilise `${CLAUDE_PLUGIN_DATA}` comme dossier stable par plugin pour y stocker des données.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/20.png" alt="Mémoire & stockage de données" width="50%" /></a>
---
### Astuce 8 : Stocke des scripts & génère du code
L'un des outils les plus puissants que tu puisses donner à Claude, c'est du code. Donner à Claude des scripts et des bibliothèques lui permet de consacrer ses tours à la composition, en décidant quoi faire ensuite plutôt qu'à reconstruire du boilerplate. Claude peut alors générer des scripts à la volée pour composer cette fonctionnalité en vue d'analyses plus avancées.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/21.png" alt="Stocke des scripts & génère du code" width="50%" /></a>
---
### Astuce 9 : Hooks à la demande
Les skills peuvent inclure des hooks qui ne s'activent que lorsque le skill est appelé, et qui durent le temps de la session. Utilise cela pour des hooks plus opinionés que tu ne veux pas exécuter en permanence mais qui sont extrêmement utiles parfois.
**Exemples :**
- `/careful` — bloque rm -rf, DROP TABLE, force-push, kubectl delete via un matcher PreToolUse sur Bash
- `/freeze` — bloque tout Edit/Write qui n'est pas dans un répertoire spécifique
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/22.png" alt="Hooks à la demande" width="50%" /></a>
---
## Distribuer des skills
Deux façons de partager des skills avec ton équipe :
- **Versionner dans ton dépôt** (sous `.claude/skills`) — idéal pour les petites équipes travaillant sur relativement peu de dépôts
- **Créer un plugin** et disposer d'une marketplace de plugins Claude Code où les utilisateurs peuvent uploader et installer des plugins
Chaque skill versionné ajoute aussi un petit peu au contexte du modèle. À mesure que tu passes à l'échelle, une marketplace de plugins interne te permet de distribuer des skills et de laisser ton équipe décider lesquels installer.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/23.png" alt="Distribuer des skills" width="50%" /></a>
---
## Gérer une marketplace
Il n'y a pas d'équipe centralisée qui décide quels skills entrent dans une marketplace. Au lieu de cela, essaie de trouver les skills les plus utiles de façon organique. Uploade-les dans un dossier bac à sable sur GitHub et oriente les gens vers lui sur Slack ou d'autres forums. Une fois qu'un skill a pris de l'ampleur (ce qu'il revient à son propriétaire de décider), il peut ouvrir une PR pour le déplacer dans la marketplace. La curation avant publication est importante pour éviter les skills redondants.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/24.png" alt="Gérer une marketplace" width="50%" /></a>
---
## Composer des skills
Tu voudras peut-être avoir des skills qui dépendent les uns des autres. Par exemple, un skill d'upload de fichier qui uploade un fichier, et un skill de génération de CSV qui crée un CSV et l'uploade. Ce type de gestion de dépendances n'est pas encore intégré nativement aux marketplaces ni aux skills, mais tu peux simplement référencer d'autres skills par leur nom, et le modèle les invoquera s'ils sont installés.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/25.png" alt="Composer des skills" width="50%" /></a>
---
## Mesurer les skills
Pour comprendre comment un skill se comporte, utilise un hook PreToolUse qui te permet de journaliser l'usage des skills au sein de l'entreprise. Ainsi, tu peux repérer les skills populaires ou ceux qui se déclenchent moins que prévu.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/26.png" alt="Mesurer les skills" width="50%" /></a>
---
## Conclusion
Les skills sont des outils incroyablement puissants et flexibles pour les agents, mais c'est encore le début et nous découvrons tous comment les utiliser au mieux. Vois ceci davantage comme un sac d'astuces utiles que nous avons vues fonctionner que comme un guide définitif. La meilleure façon de comprendre les skills est de te lancer, d'expérimenter et de voir ce qui marche pour toi. La plupart des nôtres ont commencé par quelques lignes et un seul piège, et se sont améliorés parce que les gens continuaient de les enrichir à mesure que Claude rencontrait de nouveaux cas limites.
<a href="https://x.com/trq212/status/2033949937936085378"><img src="../../tips/assets/thariq-26-3-17/27.png" alt="Conclusion" width="50%" /></a>
---
## Sources
- [Thariq (@trq212) sur X — 17 mars 2026](https://x.com/trq212/status/2033949937936085378)
- [Skilljar — Cours Agent Skills](https://code.claude.com/docs/en/skills)
- [Skill Creator](https://code.claude.com/docs/en/skills)