Open · gratuit

Claude Code : guide pratique

Utiliser un agent de codage en ligne de commande sans perdre le contrôle

Intermedio10 chapitres2 heures de lectureattestation inclusemis à jour le

Un cours écrit complet sur Claude Code, l’agent de développement en terminal : ce qu’il voit de votre projet, comment l’installer, comment rédiger des instructions qu’il suit vraiment, comment configurer les permissions et la sécurité, comment planifier une tâche d’envergure, comment l’étendre avec des commandes, des hooks et des serveurs MCP, comment travailler en parallèle et comment l’intégrer à la CI et à une équipe. Un seul fil conducteur : obtenir du code que vous valideriez en revue, en sachant où l’agent se trompe de façon prévisible. La réussite de l’épreuve finale donne lieu à une attestation de suivi avec un Open Badge vérifiable.

Ce que vous apprendrez7 objectifs
  • Expliquer en quoi un agent de codage diffère de l’autocomplétion et d’un assistant conversationnel
  • Comprendre ce qui entre dans le contexte de Claude Code et le gérer avec /context, /clear et /compact
  • Installer Claude Code, le lancer sur un projet et rédiger un CLAUDE.md court, précis et vérifiable
  • Configurer les modes et les règles de permission en partant de la distinction entre opérations réversibles et irréversibles
  • Utiliser le mode plan pour décomposer une tâche d’envergure en étapes vérifiables
  • Étendre l’agent avec des skills, des hooks, des serveurs MCP et des sous-agents, en choisissant entre instructions et mécanismes imposés
  • Mettre en place un usage headless et en CI avec des permissions minimales, des limites explicites et une revue humaine

Prérequis

  • Usage quotidien du terminal et de git : clone, branch, commit, diff
  • Une expérience de développement dans au moins un langage : les exemples utilisent des outils JavaScript, mais les concepts valent pour n’importe quelle stack
  • Rien d’autre n’est nécessaire pour lire le cours et passer l’épreuve ; pour le mettre en pratique, il faut un compte Claude avec accès à Claude Code, qui est payant

Chapitre 01

Qu’est-ce qu’un agent de codage

Si vous avez déjà utilisé un assistant de programmation, vous le connaissez sans doute sous l’une de ces deux formes. La première est l’autocomplétion : pendant que vous tapez, l’éditeur propose les lignes suivantes dans le fichier ouvert, et vous acceptez ou refusez une suggestion à la fois. La seconde est l’assistant conversationnel : vous collez un morceau de code dans un chat, vous recevez une réponse textuelle, et c’est à vous de la reporter dans le projet, de l’exécuter et de découvrir si elle fonctionne. Dans les deux cas, le vrai travail — décider quels fichiers modifier, lancer les commandes, vérifier le résultat — reste entièrement entre vos mains.

Un agent de codage comme Claude Code change la répartition des tâches. Vous ne lui demandez pas une ligne ou une réponse : vous lui confiez un objectif, et il travaille selon une boucle que la documentation officielle décrit en trois phases qui s’entremêlent — rassembler le contexte, agir, vérifier le résultat. Pour cela, il utilise des outils : il lit les fichiers et y fait des recherches, les modifie, exécute des commandes dans le terminal, consulte le web. Chaque résultat d’outil est une information nouvelle qui oriente l’étape suivante. Si vous lui demandez de corriger les tests qui échouent, il lancera typiquement la suite, lira l’erreur, cherchera les fichiers concernés, les modifiera et relancera les tests pour vérifier. Il ne voit pas seulement le fichier ouvert dans l’éditeur, mais l’ensemble du projet dans lequel vous l’avez lancé.

Il est utile de distinguer les deux éléments qui composent l’agent. Le modèle est la partie qui raisonne : il comprend le code, décide quoi faire, écrit les modifications. Claude Code est la couche qui entoure le modèle — la documentation l’appelle le harness — et qui fournit les outils, gère ce qui entre dans le contexte et applique les règles que vous configurez, comme les permissions. Cette distinction reviendra tout au long du cours : certaines choses sont décidées par le modèle et peuvent varier d’une fois à l’autre, d’autres sont imposées par le harness et se produisent toujours.

Il vaut aussi la peine de dire ce qu’il n’est pas. Ce n’est pas un oracle : il produit du code plausible avec la même assurance, qu’il ait raison ou tort. Il ne se souvient pas des sessions précédentes : chaque nouvelle session démarre avec un contexte vide, hormis les instructions persistantes que nous verrons dans le chapitre consacré à CLAUDE.md et les notes que Claude Code peut enregistrer de lui-même (ce qu’on appelle l’auto memory). Il n’est pas déterministe : la même demande, répétée, peut suivre des chemins différents. Et il ne remplace pas la revue : il déplace votre travail de l’écriture de chaque ligne vers la définition précise de l’objectif et le contrôle du résultat.

Deux choses encore avant de commencer. La première : vous faites partie de la boucle. Vous pouvez interrompre l’agent à tout moment avec Esc, ou taper une correction pendant qu’il travaille, et il en tiendra compte avant l’étape suivante. La seconde : Claude Code ne vit pas seulement dans le terminal. Il existe sous forme d’extension pour VS Code et les IDE JetBrains, d’application de bureau et sur le web, et il peut tourner dans les pipelines de CI. La boucle et les outils sont les mêmes partout ; ce cours utilise le terminal parce que c’est là que chaque mécanisme est le plus visible.

Chapitre 02

Ce que l’agent voit de votre projet

Un agent de codage n’a pas l’ensemble du dépôt sous les yeux comme vous l’auriez. Au démarrage d’une session, Claude Code charge de lui-même quelques éléments — ses propres instructions système, les fichiers CLAUDE.md, l’état de git (branche courante, modifications non commitées, commits récents), les noms des outils disponibles — et, à partir de là, il lit les fichiers qu’il décide de lire, quand il décide de les lire. Tout ce qu’il lit, chaque sortie de commande et chaque message de la conversation aboutit dans la fenêtre de contexte, qui a une limite. La qualité du résultat se joue ici : si l’agent n’a pas lu le bon fichier, il produira du code plausible mais faux.

Cela explique un comportement qui déroute les débutants : l’agent réinvente une fonction qui existe déjà, ou introduit une bibliothèque alors que le projet en utilise une autre pour le même usage. Ce n’est pas une ignorance du modèle, c’est du contexte manquant. La différence est essentielle, car elle indique la solution : lui donner les bonnes références au lieu d’espérer qu’il devine. En pratique, cela veut dire nommer le fichier ou le dossier d’où partir, décrire le symptôme plutôt que la solution supposée, et dire ce que signifie « résolu ». Si vous avez déjà ce qu’il faut, transmettez-le directement : @ suivi d’un chemin inclut un fichier dans votre message, vous pouvez coller la capture d’écran d’une erreur, et vous pouvez lui envoyer la sortie d’une commande depuis le shell, par exemple avec cat error.log | claude -p 'que se passe-t-il ici ?'.

Les projets qui fonctionnent bien avec les agents ont un point commun : ils sont navigables. Des noms de fichiers cohérents, une structure prévisible, des conventions écrites quelque part plutôt que dans la tête de l’équipe. Ce sont les mêmes propriétés qui rendent un projet compréhensible pour un nouveau collègue — l’agent ne fait qu’amplifier un problème qui existait déjà. Claude lit très bien le code tout seul, et il en déduit la structure, les conventions et le framework de test ; ce qu’il ne peut pas trouver, c’est ce qui n’est jamais entré dans le dépôt : une décision prise en réunion, une procédure de déploiement qui n’existe que dans la tête d’une personne, la variable d’environnement dont les tests d’intégration ont besoin.

La fenêtre de contexte se remplit à mesure que la session avance. Lorsqu’elle approche de la limite, Claude Code compacte la conversation en un résumé : les demandes et les extraits de code importants survivent, mais des instructions détaillées données au début peuvent se perdre. C’est pourquoi les règles qui doivent toujours s’appliquer vont dans CLAUDE.md, qui est rechargé depuis le disque, et ne doivent pas être confiées à la mémoire de la conversation. Les fenêtres des modèles actuels sont vastes et manquer de place est devenu moins fréquent, mais un contexte rempli de travail ancien a tout de même deux coûts : il dilue l’attention sur ce qui compte maintenant, et il est renvoyé — et facturé — à chaque nouveau message.

Les trois commandes de gestion du contexte, à taper dans une session.text
/context
/compact focus on the API changes and the test commands
/clear

/context montre ce qui occupe de la place et confirme quels fichiers d’instructions ont été chargés. /compact résume immédiatement la conversation et accepte une indication sur ce qu’il faut conserver, ce qui est utile avant de commencer une tâche longue. /clear repart de zéro, et c’est le bon choix quand vous passez à un travail sans rapport : la tâche suivante ne traîne pas l’historique de la précédente. Rappelez-vous enfin que les sessions sont indépendantes : une nouvelle session ne sait rien des précédentes, à moins que vous n’en repreniez une avec claude --continue, qui rouvre la dernière conversation du dossier courant, ou avec claude --resume, qui vous laisse la choisir.

Chapitre 03

Installation, premier lancement et premières commandes

Pour utiliser Claude Code, il faut trois choses : un terminal, un projet sur lequel travailler et un compte qui donne accès aux modèles. Ce dernier point mérite d’être clarifié d’emblée, car il prête à confusion : ce cours est gratuit, l’outil ne l’est pas. Claude Code nécessite un abonnement Claude payant, un compte sur la Claude Console avec du crédit API, ou un accès via l’un des fournisseurs cloud pris en charge. Les offres et les tarifs changent : vérifiez-les sur les pages officielles avant de choisir.

La méthode recommandée par la documentation est l’installateur natif. Sur macOS, Linux et WSL, il tient en une ligne ; sous Windows, il existe un équivalent pour PowerShell. Les alternatives sont Homebrew, WinGet, les gestionnaires de paquets des principales distributions Linux et npm. La différence pratique concerne les mises à jour : l’installation native se met à jour toute seule en arrière-plan, alors que celles faites avec Homebrew et WinGet doivent être mises à jour à la main. Avec npm, la documentation recommande explicitement de ne pas utiliser sudo.

Installation native et vérification. Les commandes exactes pour chaque système figurent dans le guide de démarrage rapide officiel.bash
# macOS, Linux, WSL
curl -fsSL https://claude.ai/install.sh | bash

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex

# check the installation (open a new terminal first)
claude --version

Une remarque de praticien : la première ligne télécharge un script et l’exécute. C’est la procédure officielle, mais le bon réflexe reste de vérifier l’adresse exacte dans la documentation plutôt que de la copier depuis un tutoriel quelconque — celui-ci compris. Si, après l’installation, le shell ne trouve pas la commande claude, c’est que le dossier d’installation n’est pas encore dans le PATH : ouvrez un nouveau terminal et, si cela ne suffit pas, claude doctor et la page consacrée aux problèmes d’installation vous aideront à comprendre pourquoi.

Le premier lancement se fait depuis le dossier du projet : vous vous y placez avec cd et vous lancez claude. À la première exécution, on vous demande de vous authentifier dans le navigateur. Si vous ouvrez Claude Code dans un dossier que vous n’avez jamais utilisé, la boîte de dialogue de confiance (workspace trust) apparaît également : lisez-la, car c’est de ce choix que dépend la prise en compte d’une partie de la configuration présente dans le dépôt — règles de permission, hooks —, et les serveurs MCP du projet font l’objet d’une approbation distincte. Sur un projet cloné depuis une source que vous ne connaissez pas, c’est le moment de regarder ce que contient le dossier .claude avant d’accepter.

Pour vous repérer, commencez par des questions qui ne modifient rien : que fait ce projet, où se trouve le point d’entrée, comment l’arborescence des dossiers est-elle organisée. Viennent ensuite les commandes que vous utiliserez tous les jours. Dans la session, celles qui commencent par / pilotent Claude Code lui-même : /help les liste, /init génère un premier CLAUDE.md, /clear et /compact gèrent le contexte, /permissions affiche les règles actives, /usage indique la consommation et les limites, /rewind revient à un point antérieur. Un message qui commence par ! exécute directement une commande shell et ajoute sa sortie à la conversation. Shift+Tab change le mode de permission, Esc interrompt. Depuis le shell, claude suivi d’une demande entre guillemets ouvre une session avec cette tâche, tandis que claude -p exécute une demande unique puis se termine. Choisissez une première vraie tâche petite et réversible, dans un dépôt git à l’état propre : ainsi, chaque modification de l’agent est visible avec git diff et annulable en une commande. Ce n’est pas un excès de prudence : c’est le moyen le plus rapide d’apprendre comment l’agent raisonne sur votre code, avant de lui confier quelque chose qui compte.

Chapitre 04

CLAUDE.md : des instructions de projet qui fonctionnent

Au démarrage de chaque session, Claude Code lit les fichiers CLAUDE.md et les place dans le contexte. C’est là qu’on écrit ce qu’un nouveau collègue devrait savoir avant de toucher au code et qu’il ne peut pas déduire en le lisant. Ces fichiers peuvent se trouver à plusieurs endroits, avec des portées différentes : CLAUDE.md (ou .claude/CLAUDE.md) à la racine du projet est partagé avec l’équipe via git ; ~/.claude/CLAUDE.md contient vos préférences personnelles pour tous les projets ; CLAUDE.local.md à la racine du projet sert à vos notes personnelles sur ce projet, et doit être exclu du contrôle de version. Une organisation peut aussi déployer un fichier géré de façon centralisée. Les fichiers ne s’écrasent pas les uns les autres : ils sont concaténés, du plus général au plus spécifique. Si le dépôt contient déjà un AGENTS.md écrit pour d’autres agents, Claude Code peut lire celui-là.

Inutile de partir d’une page blanche : /init analyse le code et génère une première version avec les commandes de build et de test et les conventions qu’il parvient à découvrir. À partir de là, le travail consiste surtout à retirer. L’erreur la plus courante est de remplir le fichier de bonnes intentions génériques, du genre « écris du code propre et bien testé » : elles n’ont aucun effet mesurable. La deuxième erreur, plus subtile, est de décrire ce que l’agent découvre tout seul — l’architecture, l’arborescence des dossiers —, ce qui coûte du contexte à chaque session sans apporter d’information.

Les instructions utiles sont précises et vérifiables. La documentation officielle propose un test simple avant d’écrire la moindre ligne : l’agent pourrait-il le trouver en lisant le code ? Et irait-il vraiment le chercher ? Si la réponse est oui aux deux questions, la ligne est inutile. Restent les commandes exactes pour vérifier le travail — tests, typecheck, lint, comment lancer un seul fichier de test —, les endroits où le code est trompeur, comme un vieux module encore utilisé qu’il ne faut pas prendre pour modèle, les décisions prises en dehors du dépôt, et tout ce que vous avez dû corriger deux fois.

Un CLAUDE.md court : commandes, conventions non évidentes, pièges. Rien qui se lise déjà dans le code.markdown
# Commands
- Install: pnpm install
- Run one test file: pnpm vitest run path/to/file.test.ts
- Typecheck: pnpm tsc --noEmit

# Conventions
- Use the error helpers in src/lib/errors.ts, never throw raw strings
- src/legacy/ is still live: do not copy its patterns into new code

# Gotchas
- Integration tests need DATABASE_URL, see .env.example

La règle est l’inverse de celle de la documentation traditionnelle : quelques lignes sur des décisions non évidentes valent mieux que des pages redondantes. La documentation fixe comme objectif de rester sous les 200 lignes par fichier, parce que chaque ligne consomme du contexte à chaque session et qu’un fichier long réduit le respect des instructions. Quand une partie ne concerne qu’une zone du code, on peut la déplacer dans un fichier du dossier .claude/rules/, limité à certains chemins, qui ne se charge que lorsque l’agent travaille sur ces fichiers ; quand elle devient une procédure en plusieurs étapes, mieux vaut en faire un skill, comme nous le verrons au chapitre 7. Les imports avec la syntaxe @chemin aident à organiser, mais ne réduisent pas le coût : les fichiers importés se chargent en même temps que celui qui les importe.

Deux choses, enfin, à ne pas oublier. CLAUDE.md est du contexte, pas une configuration imposée : l’agent le suit presque toujours, mais cela reste sa décision. Si une règle n’admet aucune exception — ne jamais lire .env, ne pas toucher au dossier des migrations —, l’écrire en majuscules ou ajouter « IMPORTANT » ne règle rien : il faut la transformer en règle de permission ou en hook, que nous verrons aux chapitres 5 et 7. Et les instructions se traitent comme du code : elles vivent dans git, passent en revue, se mettent à jour quand les conventions changent. Un fichier obsolète est pire que pas de fichier du tout, car l’agent le suit avec la même application.

Chapitre 05

Permissions et sécurité opérationnelle

Un agent en terminal exécute des commandes : il installe des paquets, modifie des fichiers, lance des tests, peut faire des commits. C’est ce qui fait son utilité, et c’est aussi ce qui fait son risque. La bonne question n’est pas « puis-je lui faire confiance ? » mais « quel dommage puis-je me permettre s’il se trompe ? ». La distinction pratique passe entre opérations réversibles et irréversibles. Modifier un fichier suivi par git est réversible : vous pouvez toujours revenir en arrière. Supprimer des fichiers non suivis, réécrire l’historique, faire un push sur une branche partagée, toucher à une base de données ou à un environnement de production ne l’est pas. La première catégorie peut avancer sans demander ; la seconde exige une confirmation explicite, à chaque fois. Claude Code vous aide du côté réversible. Avant de modifier un fichier avec ses propres outils, il en enregistre un instantané, un point de contrôle (checkpoint) : en appuyant deux fois sur Esc, ou avec /rewind, vous pouvez ramener le code, la conversation ou les deux à un point antérieur. Mais les points de contrôle ont des limites précises : ils ne couvrent pas les fichiers modifiés par des commandes shell, et ils ne peuvent rien annuler de ce qui est sorti de la machine — une requête sur une base de données, un appel d’API, un déploiement. Ils ne remplacent pas git : ils le complètent.

Le deuxième mécanisme, ce sont les modes de permission, qui déterminent ce que l’agent peut faire sans demander. En mode Manual (la valeur de configuration est default), les lectures sont libres et presque chaque modification ou commande demande une confirmation. acceptEdits approuve d’office les modifications de fichiers et certaines commandes courantes sur le système de fichiers dans le dossier de travail. plan permet d’explorer mais pas de modifier le code (chapitre 6). auto confie l’évaluation des actions à un second modèle, un classificateur, qui bloque celles qu’il juge risquées. dontAsk refuse tout ce qui n’a pas été pré-approuvé, et il est conçu pour la CI et les scripts. bypassPermissions saute les contrôles, et la documentation le réserve aux conteneurs et aux machines virtuelles isolés. Shift+Tab fait passer d’un mode à l’autre ; le mode de départ dépend de la version et de la configuration, et il a changé au fil du temps : vérifiez-le dans la documentation.

Aux modes s’ajoutent les règles : allow (continuer sans demander), ask (toujours demander), deny (interdit). On les écrit dans les fichiers de paramètres — .claude/settings.json pour l’équipe, .claude/settings.local.json pour vous — et on les gère avec /permissions. L’ordre d’évaluation est deny, puis ask, puis allow : un deny ne peut pas être contourné par un allow plus spécifique, et il s’applique dans tous les modes, y compris bypassPermissions. La différence avec CLAUDE.md est fondamentale : les règles sont appliquées par Claude Code, pas par le modèle. C’est pourquoi les « jamais » ont leur place ici et non dans les instructions ; même le mode auto, puisqu’il repose sur le jugement d’un modèle, peut se tromper.

Règles dans .claude/settings.json : tests et lint sans confirmation, push toujours avec confirmation, secrets jamais.json
{
  "permissions": {
    "allow": [
      "Bash(npm run test *)",
      "Bash(npm run lint)"
    ],
    "ask": [
      "Bash(git push *)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./secrets/**)"
    ]
  }
}

Les règles ont des limites qu’il faut connaître : elles portent sur les appels d’outils, pas sur l’intention. Le deny sur Read(./.env) bloque aussi cat .env, parce que Claude Code reconnaît les commandes de lecture courantes, mais pas un script qui ouvre le fichier de son côté. Pour une limite imposée au niveau du système d’exploitation, il existe la sandbox des commandes shell, qui s’active avec /sandbox sous macOS, Linux et WSL2.

Reste le risque qui ne dépend pas de vous. L’agent lit des contenus que vous n’avez pas écrits — issues, commentaires, pages web, documentation des dépendances, réponses de serveurs externes —, et un texte malveillant peut contenir des instructions conçues pour le manipuler : c’est l’injection de prompt. Claude Code dispose de défenses : par exemple, il n’approuve pas automatiquement les commandes qui récupèrent du contenu sur le réseau, comme curl, et il demande une confiance explicite avant d’utiliser la configuration d’un dépôt inconnu. Mais aucune défense n’est complète, et c’est pourquoi les opérations destructrices ne devraient jamais être automatiques, aussi fiable que paraisse l’agent dans la pratique quotidienne.

Chapitre 06

Planifier avant d’écrire : le mode plan

Face à une tâche d’envergure — une migration, une fonctionnalité qui traverse plusieurs modules, un refactoring —, l’agent a tendance à faire ce qu’il fait toujours : commencer. Le problème, c’est qu’une hypothèse erronée découverte après vingt fichiers modifiés coûte bien plus cher que la même hypothèse discutée avant d’écrire une ligne. Planifier avant d’écrire n’est pas de la bureaucratie : c’est déplacer la correction des erreurs là où elle coûte le moins.

Le mode plan sert exactement à cela. Dans ce mode, Claude lit les fichiers, exécute des commandes pour explorer et rédige un plan, mais il ne modifie pas le code source tant que vous ne l’avez pas approuvé. Vous y entrez avec Shift+Tab, en faisant précéder une demande unique de /plan, ou en lançant directement la session dans ce mode. Quand le plan est prêt, Claude vous le présente et vous demande comment procéder : vous pouvez l’approuver et le laisser travailler avec moins de confirmations, l’approuver mais confirmer une à une les modifications, ou rester en planification et dire ce qu’il faut changer. Avec Ctrl+G, vous ouvrez le plan dans votre éditeur pour le corriger directement.

Lancer une session en mode plan, ou y entrer pour une seule demande.bash
# start the whole session in plan mode
claude --permission-mode plan

# inside a session: plan mode for one request
/plan migrate the session store to the new cache API

Un plan se lit comme la proposition d’un collègue, en y cherchant trois choses. Les hypothèses : le plan tient-il pour acquis quelque chose de faux, par exemple qu’une fonction n’est utilisée qu’à un seul endroit ? Le périmètre : quels fichiers touche-t-il, et y en a-t-il qu’il ne devrait pas toucher ? Et surtout la vérification : pour chaque étape, comment saura-t-on qu’elle a réussi ? Une étape sans contrôle objectif — un test qui passe, un typecheck propre, un build qui aboutit — est une étape dont on ne découvrira l’issue qu’à la fin, en même temps que toutes les autres.

Décomposer le travail en étapes vérifiables a un effet pratique immédiat : chaque étape devient une unité que l’agent peut boucler seul, en exécutant le contrôle et en corrigeant jusqu’à ce qu’il passe, et que vous pouvez relire et committer séparément. Une bonne étape laisse le projet dans un état fonctionnel ; une mauvaise le laisse à mi-chemin entre deux versions. Si le plan propose « mets à jour tous les modules, puis corrige les tests », demandez-lui de l’inverser : d’abord les tests qui décrivent le comportement attendu, puis un module à la fois, avec des tests au vert à la fin de chacun.

Quand vous ne savez pas encore précisément ce que vous voulez, vous pouvez faire précéder le plan d’un entretien : demandez à Claude de vous poser des questions jusqu’à disposer d’assez d’éléments pour rédiger une spécification, et de l’enregistrer dans un fichier. La documentation suggère ensuite d’ouvrir une nouvelle session pour l’implémenter : le travail part ainsi d’un contexte propre et d’une définition écrite de « terminé », qui servira aussi lors de la revue. Pour les modifications petites et évidentes, en revanche, la planification explicite est un coût sans contrepartie : la correction d’une ligne n’a pas besoin d’un plan. Un détail utile dans les longues sessions : le plan rédigé en mode plan est rechargé depuis le disque même après un compactage du contexte ; il reste donc une référence stable pendant que le reste de la conversation est résumé.

Chapitre 07

Étendre l’agent : commandes, hooks et serveurs MCP

Tout ce que vous avez vu jusqu’ici se répartit en deux familles, qu’il vaut mieux garder distinctes. Il y a les instructions que le modèle lit et décide de suivre ou non : la demande, CLAUDE.md, les skills. Et il y a les mécanismes que Claude Code applique toujours, quoi qu’ait décidé le modèle : les règles de permission, les hooks. Les extensions de ce chapitre appartiennent à l’une ou à l’autre, et choisir la mauvaise est l’erreur la plus courante : une préférence transformée en hook devient un obstacle, une règle intangible laissée dans un texte devient un vœu pieux.

Les commandes personnalisées évitent de réécrire chaque fois la même procédure. Un fichier Markdown dans .claude/commands/, par exemple deploy.md, crée la commande /deploy : son contenu est le prompt exécuté, et l’espace réservé $ARGUMENTS recueille ce que vous tapez après le nom. Dans les versions récentes, les commandes ont été fusionnées avec les skills : un dossier .claude/skills/deploy/ contenant un fichier SKILL.md produit la même commande, et permet en plus d’y joindre des fichiers annexes et de laisser l’agent charger le skill de lui-même quand sa description correspond à la demande. Les anciens fichiers de .claude/commands/ continuent de fonctionner. Le corps d’un skill n’entre dans le contexte que lorsqu’il est utilisé : c’est donc le bon endroit pour les procédures longues qui alourdiraient CLAUDE.md. Pour un skill qui ne doit démarrer qu’à votre demande, comme un déploiement, l’option disable-model-invocation: true dans le frontmatter empêche l’agent de le lancer de lui-même.

Les hooks sont des commandes shell que Claude Code exécute à des moments précis de son cycle de vie : avant d’utiliser un outil (PreToolUse, qui peut le bloquer), après l’avoir utilisé (PostToolUse), quand l’agent s’apprête à terminer sa réponse (Stop), au démarrage de la session (SessionStart), quand votre attention est requise (Notification), et à plusieurs autres moments. Ils se configurent dans les fichiers de paramètres sous la clé hooks, avec un matcher qui sélectionne les outils auxquels réagir, et /hooks affiche ceux qui sont actifs. Un hook PreToolUse qui se termine avec le code de sortie 2 bloque l’action et renvoie son message d’erreur à l’agent, qui peut ainsi se corriger ; un hook PostToolUse, en revanche, intervient quand l’action a déjà eu lieu et ne peut pas l’annuler. Le cas typique est le formatage, comme dans l’exemple ci-dessous : au lieu d’écrire dans CLAUDE.md « formate toujours un fichier après l’avoir modifié », un hook le fait à chaque fois, et peu importe désormais que l’agent s’en souvienne. Deux précautions. Les hooks s’exécutent avec les permissions de votre utilisateur : ceux d’un dépôt cloné doivent donc être lus avant d’accorder votre confiance au dossier. Et il faut en garder peu : tout hook finit tôt ou tard par se déclencher quand il ne le devrait pas, et quelqu’un doit le maintenir.

Un hook PostToolUse : après chaque modification ou écriture de fichier, Prettier formate le fichier concerné.json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
          }
        ]
      }
    ]
  }
}

Le troisième mécanisme relie l’agent à des systèmes externes — gestionnaires de tickets, bases de données, services internes — au moyen du Model Context Protocol. Le fonctionnement du protocole fait l’objet de notre cours consacré à MCP ; ici, ce qui compte, c’est la façon de l’utiliser dans Claude Code. Un serveur s’ajoute avec claude mcp add, se gère avec /mcp dans la session et peut avoir trois portées : local, la portée par défaut (vous seul, dans ce projet seulement) ; projet, dans le fichier .mcp.json à committer pour l’équipe ; utilisateur (vous, dans tous vos projets). Les serveurs de .mcp.json requièrent une approbation explicite dans les sessions interactives.

Ajouter un serveur distant et un serveur local partagé avec l’équipe. Les adresses sont des exemples.bash
# remote server over HTTP, local scope (the default)
claude mcp add --transport http tracker https://mcp.example.com/mcp

# local stdio server, shared with the team through .mcp.json
claude mcp add --scope project --transport stdio db -- npx -y @example/mcp-server

claude mcp list

La règle de sécurité est celle du chapitre 5 : un serveur qui fait entrer des contenus externes dans la conversation est une porte ouverte à l’injection de prompt, on ne connecte donc que des serveurs de confiance. Enfin, skills, hooks, sous-agents et serveurs MCP peuvent être réunis dans un plugin, pour les distribuer entre plusieurs dépôts ou à toute l’équipe.

Chapitre 08

Travailler en parallèle : sous-agents et worktrees

Un sous-agent est une instance séparée qui travaille dans sa propre fenêtre de contexte, avec son propre prompt système et, si vous le décidez, un ensemble d’outils restreint. Il reçoit une tâche, l’accomplit de son côté et ne renvoie qu’un résumé à la conversation principale. Claude Code en inclut quelques-uns par défaut, parmi lesquels Explore, en lecture seule, pour chercher dans le code et l’analyser, et Plan, utilisé en mode plan pour recueillir des informations avant de proposer un plan. Claude délègue à un sous-agent quand la tâche correspond à sa description ; vous pouvez aussi le demander explicitement, en le nommant dans votre demande ou en le mentionnant avec @.

Un sous-agent personnalisé est un fichier Markdown doté d’un frontmatter : name et description sont obligatoires, tools restreint les outils, model choisit le modèle. Le corps du fichier devient son prompt système. Dans le dossier .claude/agents/ du projet, il est partagé avec l’équipe via git ; dans ~/.claude/agents/, il est personnel et vaut pour tous vos projets. La description compte plus qu’il n’y paraît, car c’est ce que Claude lit pour décider quand déléguer.

Un relecteur qui peut lire mais pas modifier : la limite est imposée par Claude Code, pas par le prompt.markdown
---
name: reviewer
description: Reviews changed files against the spec they were built from. Use after implementing a feature, before opening the PR.
tools: Read, Grep, Glob
---
You are reviewing code you did not write. Compare the changed files
with the spec you are given, check that every requirement is
implemented and tested, and report only gaps that affect correctness.

Les sous-agents sont utiles dans quatre situations : des travaux indépendants à mener en parallèle ; des sorties longues — une suite de tests complète, une recherche dans tout le dépôt — qui, sinon, resteraient dans le contexte principal pour le reste de la session ; une revue faite par quelqu’un qui n’a pas vu le raisonnement ayant produit le code ; une tâche avec moins de permissions que la session principale. En revanche, ils ne servent pas à obtenir une réponse plus intelligente : le même modèle sur la même tâche donne un résultat équivalent. Et ils ont un coût : chaque sous-agent envoie ses propres requêtes, qui comptent dans les mêmes limites d’utilisation, et doit souvent reconstruire un contexte que la conversation principale avait déjà, au point de se révéler plus lent.

Les sous-agents travaillent à l’intérieur d’une session. Pour des travaux parallèles plus longs — une fonctionnalité d’un côté, un correctif de l’autre —, il faut aussi séparer les fichiers, sinon deux sessions modifient la même copie et se marchent sur les pieds. L’outil pour cela est le worktree de git : un répertoire de travail séparé, avec sa propre branche, qui partage l’historique du dépôt. claude --worktree nom (ou -w) en crée un sous .claude/worktrees/, sur une nouvelle branche, et y lance la session ; la même commande avec un autre nom, dans un second terminal, ouvre une seconde session isolée. Un sous-agent peut lui aussi travailler dans son propre worktree, avec l’option isolation: worktree dans le frontmatter.

Deux sessions parallèles, chacune dans son propre worktree et sur sa propre branche.bash
# keep worktree contents out of the main checkout
echo ".claude/worktrees/" >> .gitignore

# terminal 1
claude --worktree feature-auth

# terminal 2
claude --worktree fix-login

Un worktree est un checkout neuf : les dépendances n’y sont pas installées et les fichiers ignorés par git, comme .env, n’y figurent pas. Un fichier .worktreeinclude à la racine du dépôt liste ceux qu’il faut y copier automatiquement. La vraie limite du parallélisme, toutefois, n’est pas technique : chaque session parallèle produit du travail à relire, et votre attention est la ressource qui s’épuise en premier. Deux sessions bien vérifiées valent mieux que cinq que vous n’arrivez pas à contrôler. L’usage qui paie presque toujours est le plus simple : une session écrit, une autre — qui n’a pas vu comment le code est né — le relit.

Chapitre 09

Le flux de travail quotidien : tests, petits commits, revue

L’usage qui rend vraiment productif ne consiste pas à demander à l’agent d’écrire une fonction, mais à lui confier une tâche complète et vérifiable : « ajoute les tests de ce module et assure-toi qu’ils passent ». Un objectif assorti d’un critère de réussite objectif permet à l’agent d’itérer seul : il modifie, exécute le contrôle, lit la sortie, corrige, jusqu’à ce que le contrôle passe. Sans contrôle, l’agent s’arrête quand le travail semble fini — et c’est vous qui devenez le testeur.

Il en découle une conséquence pratique : les projets dotés d’une bonne suite de tests tirent des agents un avantage bien plus grand. Le test est le contrat qui permet de vérifier sans relire chaque ligne ; là où les tests manquent, la revue humaine redevient le goulet d’étranglement. Le contrôle peut toutefois être n’importe quoi qui renvoie un résultat lisible : le code de sortie d’un build, un linter, le typecheck, un script qui compare une sortie à une référence. Pour corriger un bug, la séquence la plus solide consiste à demander d’abord un test qui reproduit le problème et échoue, puis la correction qui le fait passer. Et quand l’agent déclare avoir terminé, demandez les preuves : la commande exécutée et sa sortie. « Tous les tests passent », à lui seul, ne dit pas grand-chose.

La demande compte autant que le contrôle. Une demande utile indique d’où partir, décrit le symptôme et dit ce que signifie « résolu » : non pas « corrige le bug de connexion », mais « la connexion échoue après l’expiration de la session ; regarde le renouvellement du token dans src/auth/, écris un test qui reproduit le problème, puis corrige-le ». Si l’agent s’engage sur une mauvaise piste, arrêtez-le tout de suite avec Esc. Si, après deux corrections, il fait toujours fausse route, la documentation conseille de ne pas insister : /clear et une nouvelle demande qui intègre ce que vous avez appris fonctionnent mieux qu’une troisième correction dans une conversation déjà encombrée de tentatives ratées.

Côté contrôle de version, mieux vaut travailler sur une branche dédiée et par petits commits. Non par rigueur formelle, mais parce que cela rend chaque modification annulable isolément : si une partie ne convainc pas, on l’écarte sans perdre le reste. L’agent sait utiliser git et peut faire des commits si vous le lui demandez, mais la décision sur ce qui entre dans l’historique — et surtout sur ce qui part sur la branche partagée — vous revient. Les points de contrôle de Claude Code sont pratiques pour revenir en arrière au sein d’une session, mais ils ne remplacent pas l’historique de git.

Une branche par tâche, et un commit par étape vérifiée : relisez avant d’indexer.bash
git switch -c fix/session-timeout

# after each verified step
git diff
git add -p
git commit -m "Add failing test for token refresh after timeout"

Reste la revue. Le code généré doit être lu avec la même attention que celui d’un collègue — pas davantage, pour ne pas annuler le gain, mais pas moins non plus. Le risque spécifique est qu’il soit syntaxiquement impeccable et conceptuellement faux : précisément la catégorie d’erreurs qu’une lecture distraite ne repère pas. Un second regard indépendant aide : la commande /code-review passe en revue les modifications avec un sous-agent qui n’a pas vu la conversation, et vous pouvez aussi demander une revue ciblée par rapport à la spécification rédigée pendant la planification. Dans les deux cas, demandez de se concentrer sur l’exactitude et de laisser le style de côté : un relecteur à qui l’on demande de trouver des problèmes en trouve toujours, et vouloir tous les traiter produit des abstractions et des tests inutiles.

Chapitre 10

En automatisation et en équipe : CI, configuration partagée, limites et coûts

En dehors de la session interactive, Claude Code s’utilise avec claude -p : il exécute une demande, affiche le résultat et se termine, avec un code de sortie non nul si l’exécution échoue. C’est la forme qui s’insère dans les scripts, les hooks git et les pipelines de CI. En usage automatisé, certaines options deviennent presque obligatoires : --allowedTools pré-approuve les outils nécessaires, --permission-mode dontAsk refuse tout le reste au lieu d’attendre une confirmation que personne ne donnera, --max-turns limite les itérations, --output-format json renvoie un objet exploitable. Avec --bare, l’exécution saute le chargement des hooks, des skills, des serveurs MCP et de CLAUDE.md, et se comporte de la même manière sur toutes les machines ; dans ce mode, l’authentification passe par une clé API ou par les identifiants du fournisseur cloud, et non par la connexion de l’abonnement.

Une exécution non interactive avec des outils pré-approuvés, tout le reste refusé et un plafond d’itérations.bash
claude -p "Run the test suite and fix failing tests. Reply OK or FAIL." \
  --allowedTools "Read,Edit,Bash(npm test *)" \
  --permission-mode dontAsk \
  --max-turns 20 \
  --output-format json

Un détail de sécurité à ne pas négliger : sans --bare, une exécution avec -p charge les hooks du .claude/settings.json du projet et connecte les serveurs de .mcp.json sans afficher ni la boîte de dialogue de confiance ni les approbations. Sur un dépôt dont vous ne maîtrisez pas le contenu, cela revient à exécuter une configuration écrite par d’autres. Plus généralement, avant de laisser tourner une exécution sans supervision, la documentation propose cinq questions : sait-il ce que signifie « terminé » ? Peut-il vérifier son propre travail ? Que peut-il toucher ? Qu’est-ce qui l’arrête ? Où va le résultat, et qui l’approuve ? La dernière réponse doit toujours inclure une personne, pour tout ce qui ne peut pas être annulé.

Pour GitHub, il existe une intégration officielle, la GitHub Action anthropics/claude-code-action. Le moyen le plus rapide de la configurer est la commande /install-github-app dans Claude Code, qui guide l’installation de l’application GitHub et de l’identifiant en tant que secret du dépôt, puis ouvre une pull request avec le fichier de workflow à relire avant de la fusionner. Il y a deux modes d’utilisation : interactif, où l’agent répond quand quelqu’un le mentionne avec @claude dans une issue ou une pull request, et automatique, où il exécute un prompt fixe sur un événement, y compris de façon planifiée. Les clés vont toujours dans les secrets, jamais dans le dépôt ; on ne donne au workflow que les permissions nécessaires ; et les modifications proposées se relisent avant le merge. L’intégration avec GitLab CI/CD est également documentée.

Dans le travail en équipe, la configuration se répartit par portée. Dans le dépôt, sous contrôle de version, se trouvent CLAUDE.md, .claude/settings.json avec les permissions et les hooks communs, .mcp.json, les skills et les sous-agents du projet. Les exceptions personnelles vont dans .claude/settings.local.json et dans CLAUDE.local.md, qui restent hors de git. Au-dessus de tout, les paramètres gérés (managed settings) déployés par l’organisation ont la priorité et ne peuvent pas être contournés : c’est là que se placent les politiques de sécurité. Quand la même clé apparaît dans plusieurs fichiers, c’est celle du niveau le plus élevé qui l’emporte, tandis que les listes comme les règles de permission s’additionnent.

Reste la question des coûts. L’utilisation se mesure en tokens et varie beaucoup selon le modèle choisi, la taille du code et les habitudes : longues sessions qui accumulent des tâches différentes, sous-agents, exécutions automatisées. /usage affiche la consommation de la session et, pour les abonnés, les limites de l’offre ; le montant en dollars qu’il indique est une estimation, pas la facture. Les habitudes qui réduisent la dépense sont les mêmes que celles qui améliorent les résultats : /clear entre des tâches sans rapport, un CLAUDE.md court, des demandes précises, des plafonds explicites pour les exécutions automatisées. Les tarifs, les offres, les modèles et même les paramètres par défaut changent souvent : pour tout ce qui est chiffré ou relève de la configuration, la référence est la documentation officielle, pas un cours — celui-ci compris.

Épreuve finaleseuil 80%

Obtenez votre attestation

Réussissez l’épreuve finale en répondant correctement à au moins 80 % des questions. L’attestation est délivrée automatiquement et reste vérifiable en ligne grâce à un lien permanent : il s’agit d’un Open Badge conforme à la norme 2.0, que vous pouvez ajouter à LinkedIn et à vos portefeuilles numériques de compétences.

Aucune inscription. Votre nom figurera sur l’attestation ; l’adresse e-mail sert uniquement à identifier l’attestation numérique et à éviter les doublons.

Votre nom et l’intitulé du cours seront visibles publiquement sur la page de vérification de l’attestation, accessible à toute personne disposant du lien.

Questions fréquentes

Attestation, badge et accès au cours

Le cours est-il gratuit ? Vais-je recevoir une attestation ?

Oui, dans les deux cas. Le cours est entièrement gratuit : les contenus, l’épreuve finale et l’attestation, sans module payant et sans qu’on vous demande jamais un moyen de paiement. Lorsque vous réussissez l’épreuve finale avec au moins 80 % de bonnes réponses, vous recevez une Attestation de suivi à votre nom, avec un code de vérification, une page publique que chacun peut consulter pour en confirmer l’authenticité, le PDF à télécharger et un Open Badge à ajouter à votre profil LinkedIn. Votre nom et votre adresse e-mail ne vous sont demandés qu’à la fin, si vous décidez de passer l’épreuve.

Faut-il un abonnement payant pour suivre le cours ?

Pour le lire et réussir l’épreuve, non. Pour mettre en pratique ce qu’il explique, oui, car Claude Code n’est pas gratuit : il nécessite un abonnement Claude payant, un compte sur la Claude Console avec du crédit API, ou un accès via un fournisseur cloud pris en charge. Le cours est écrit de sorte que chaque concept soit compréhensible même sans l’avoir essayé, mais l’essayer sur l’un de vos projets est la meilleure façon de le retenir. Les offres et les tarifs changent : vérifiez-les sur les pages officielles d’Anthropic.

Est-ce un cours officiel d’Anthropic ?

Non. C’est un cours indépendant de Rinoova Academy, qui n’est ni affilié à Anthropic ni approuvé par Anthropic, et l’attestation est délivrée par Rinoova. Claude et Claude Code sont des produits d’Anthropic. Chaque information technique du cours a été vérifiée dans la documentation officielle de Claude Code, qui reste la référence pour tout ce qui concerne les commandes, la configuration et le comportement de l’outil.

Quelle est la durée du cours et comment les heures sont-elles calculées ?

Environ deux heures. Dix chapitres, soit environ 5 800 mots de texte technique, qui demandent un peu moins d’une heure de lecture attentive, plus onze blocs de commandes et de configuration à essayer sur votre projet, et l’épreuve finale. Ce n’est pas un cours vidéo : vous pouvez le lire à votre rythme, l’interrompre et le reprendre quand vous le souhaitez.

Quels sont les prérequis ?

Le cours est de niveau intermédiaire : il suppose que vous utilisez le terminal et git dans votre travail quotidien et que vous avez une expérience de développement dans au moins un langage. Il n’est pas nécessaire d’avoir déjà utilisé un agent de codage, ni de connaître le Model Context Protocol : là où c’est nécessaire, le cours l’introduit et renvoie au cours dédié.

Que se passe-t-il si je ne réussis pas l’épreuve finale ?

Vous pouvez la repasser. Le seuil est de 80 % et les questions couvrent tous les chapitres : si une partie n’est pas claire, mieux vaut revenir au chapitre correspondant et le relire avant de réessayer. L’attestation n’est délivrée qu’en cas de réussite, et jamais deux fois pour le même cours à la même personne.

Le cours est-il à jour ? Claude Code évolue souvent.

Oui, et c’est justement pour cela qu’il est écrit d’une façon bien précise. Les concepts — contexte, instructions, permissions, planification, vérification — sont stables, et c’est sur eux que porte l’épreuve. Les détails qui changent le plus vite, comme les versions, les tarifs, les modèles et les paramètres par défaut, sont volontairement laissés de côté, et là où un comportement peut évoluer, le texte le signale et renvoie à la documentation officielle. La date de la dernière révision est indiquée en haut de la page.

Pour continuer

Autres cours Open