+200 XP

Claude · Fonctions avancées : skills, subagents, hooks et settings

Entre utiliser Claude Code comme une simple fenêtre de chat dans votre terminal et l'exploiter comme un environnement d'ingénierie configuré, la différence tient à quelques fonctionnalités : les Skills et les slash commands, les subagents pour le travail en parallèle, les hooks qui déclenchent vos scripts sur des événements, les serveurs MCP branchés sur votre projet, et le settings.json qui gouverne l'ensemble. Cette leçon les détaille un par un.

Skills et slash commands

Vous savez déjà que Claude Code est livré avec des slash commands intégrées comme /clear et /init. Le vrai levier, c'est d'écrire les vôtres, et aujourd'hui cela veut dire écrire un Skill.

Un Skill est un dossier contenant un fichier SKILL.md, accompagné des scripts, templates ou documents de référence dont la tâche a besoin. Placez-le dans .claude/skills/<name>/SKILL.md de votre repo et il fonctionne dans ce projet. Placez-le dans ~/.claude/skills/ et il fonctionne partout. Chaque Skill s'utilise de deux façons. Vous pouvez taper /<name> pour le lancer vous-même, ou Claude peut le charger de lui-même quand la tâche correspond à la description du Skill.

Voici un Skill review qui donne à l'équipe une passe de code review homogène :

markdown
---
name: review
description: Review staged changes for bugs, security issues, and style
allowed-tools: Bash(git diff:*), Read
---

Review the staged diff below. Flag:
1. Logic bugs and edge cases
2. Security issues (injection, secrets, auth gaps)
3. Style deviations from CLAUDE.md

Be terse. Cite file:line. Skip praise.

Staged changes:
!`git diff --cached`

Deux points à noter. Le préfixe ! exécute une commande shell et injecte sa sortie dans le prompt. Le frontmatter allowed-tools délimite ce que le Skill peut toucher, si bien que /review ne peut pas partir modifier des fichiers. Vous pouvez aussi passer des arguments avec $ARGUMENTS.

Si un Skill ne doit tourner que sur votre demande (un déploiement, par exemple), ajoutez disable-model-invocation: true dans le frontmatter pour que Claude ne le déclenche jamais de lui-même.

L'ancien format fonctionne toujours. Un simple fichier Markdown dans .claude/commands/<name>.md devient /<name>, ce qui est pratique pour un prompt ponctuel. Passez au format dossier quand la capacité a besoin de fichiers associés : « remplir notre template de facture » ou « générer un PDF à partir de ces données » avec un script d'appoint à côté. Le même format de Skills fonctionne dans Claude Code, les applications Claude et l'API : un Skill construit une fois vous suit partout. Voir code.claude.com/docs/en/skills.

Subagents pour le travail en parallèle

Un subagent est une instance distincte de Claude, avec sa propre fenêtre de contexte, son propre system prompt et son propre jeu d'outils restreint, lancée par votre session principale pour traiter une tâche ciblée. L'intérêt, c'est l'isolement. Le subagent absorbe une tâche bruyante (lire 40 fichiers, lancer une suite de tests) et ne renvoie que la conclusion, ce qui garde votre contexte principal propre.

Vous définissez les subagents avec des fichiers Markdown dans .claude/agents/, ou de façon interactive avec /agents. Chacun déclare un nom, une description qui indique à Claude *quand* lui déléguer, et les outils qu'il a le droit d'utiliser.

markdown
---
name: test-runner
description: Runs the test suite and diagnoses failures. Use after code changes.
tools: Bash, Read, Grep
---

You are a test specialist. Run the project's test command, read failing
output, locate the root cause, and report a concise fix. Do not edit
files unless explicitly asked.

Votre session principale peut maintenant déléguer : « utilise le test-runner pour vérifier ça ». Claude lit la description, la rapproche de la tâche et délègue. Comme le subagent a sa propre fenêtre, un millier de lignes de stack traces ne viennent jamais polluer votre conversation principale.

Le vrai gain, c'est le parallélisme. Vous pouvez demander à Claude de répartir le travail sur plusieurs subagents à la fois : l'un audite les dépendances, un autre rédige la documentation, un troisième refactore un module. Ils tournent indépendamment et font leur rapport. C'est le même schéma de délégation que le Claude Agent SDK expose par programmation, piloté ici depuis le terminal. Gardez des droits d'outils serrés pour chaque subagent. Un rédacteur de documentation n'a rien à faire avec Bash.

Des hooks qui lancent vos scripts sur des événements

Les Skills et les subagents, c'est vous qui les invoquez. Les hooks sont l'inverse : des commandes shell que Claude Code exécute *automatiquement* à des moments définis de son cycle de vie, sans prompt. C'est ainsi que vous imposez des règles au lieu d'espérer que Claude les suive.

Les principaux événements du cycle de vie :

  • PreToolUse : avant l'exécution d'un outil (vous pouvez la bloquer)
  • PostToolUse : après la réussite d'un outil
  • UserPromptSubmit : quand vous appuyez sur Entrée
  • Stop : quand Claude termine sa réponse
  • SessionStart : à l'ouverture d'une session

Chaque hook reçoit sur stdin un payload JSON qui décrit l'événement : le nom de l'outil, son input, l'ID de session, etc. Le cas d'usage classique est le formatage automatique de chaque fichier que Claude modifie. Ajoutez ceci à votre settings.json :

json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs prettier --write 2>/dev/null"
          }
        ]
      }
    ]
  }
}

Dès que Claude modifie ou écrit un fichier, jq extrait le chemin du payload et Prettier formate ce fichier. Claude n'a jamais à se souvenir de vos règles de style, car le hook les rend non négociables. Le matcher est une regex appliquée aux noms d'outils.

PreToolUse va plus loin, car il peut bloquer. Sortez avec le code 2 et Claude Code annule l'appel d'outil et transmet votre message stderr à Claude pour qu'il s'ajuste. Les autres codes de sortie non nuls comptent comme des erreurs non bloquantes et l'outil s'exécute quand même : un garde-fou doit donc utiliser précisément le code 2. Pour un contrôle plus fin, un hook peut afficher un JSON contenant une décision de permission allow, deny ou ask. Les équipes s'en servent pour interdire les modifications dans secrets/, bloquer git push --force ou exiger un lint réussi avant un commit. Le hook s'exécute de façon déterministe, en dehors du jugement du modèle.

Une mise en garde : les hooks exécutent de vraies commandes shell avec vos permissions. Lisez ce que vous collez. Un hook venant d'un repo non fiable peut faire tout ce que vous pouvez faire. La référence complète des événements et les schémas de payload sont sur code.claude.com/docs/en/hooks.

Claude Code Hooks: Automate Your Workflow

Watch on YouTube

Les serveurs MCP dans Claude Code

Vous avez découvert le Model Context Protocol en tant que concept : une manière standard d'exposer des outils et des données à n'importe quel client IA. Claude Code est un client MCP : vous pouvez donc brancher directement dans vos sessions de terminal les mêmes serveurs que dans l'application desktop Claude.

Ajoutez-en un via la CLI. GitHub héberge un serveur distant officiel :

bash
claude mcp add --transport http github https://api.githubcopilot.com/mcp/

Lancez /mcp dans une session pour vous authentifier. Une fois connecté, Claude peut ouvrir des issues, lire des PR et inspecter des repos comme avec des outils natifs, sans code d'intégration. Les serveurs locaux qui tournent comme un processus sur votre machine utilisent la forme --, par exemple claude mcp add myserver -- npx -y some-mcp-package. Les serveurs peuvent être limités à un seul projet ou rendus disponibles globalement. Les serveurs au niveau projet vont dans un fichier .mcp.json versionné dans le repo, pour que toute l'équipe dispose des mêmes intégrations.

MCP relie Claude Code à l'écosystème plus large. Les connecteurs que vous voyez dans les applications Claude reposent sur MCP, et la spécification du protocole est documentée sur modelcontextprotocol.io. Construisez un serveur une fois et il fonctionne dans Claude Code, l'application desktop et tout ce qui parle MCP.

Vérification des acquis

1. Qu'est-ce, fondamentalement, qu'une slash command personnalisée dans Claude Code ?

2. Selon la règle empirique de la leçon, quand faut-il construire un Skill plutôt qu'une slash command ?

3. Pourquoi l'exemple review.md comporte-t-il une entrée `allowed-tools` dans son frontmatter ?

CHOIX MULTIPLES

4. Sélectionnez TOUTES les affirmations qui décrivent correctement ce qui distingue les Skills des slash commands personnalisées.

Sélectionnez toutes les réponses correctes.

CHOIX MULTIPLES

5. Sélectionnez TOUTES les affirmations correctes sur l'écriture de fichiers de slash commands personnalisées.

Sélectionnez toutes les réponses correctes.

settings.json : le plan de contrôle

Tout ce qui précède se configure via des fichiers de settings, et comprendre leur superposition fait la différence entre une configuration propre et une configuration confuse. Claude Code lit les settings à plusieurs emplacements, et le plus spécifique l'emporte :

  • ~/.claude/settings.json : vos valeurs par défaut personnelles, pour tous les projets
  • .claude/settings.json : les settings du projet, versionnés dans git, partagés avec l'équipe
  • .claude/settings.local.json : vos surcharges personnelles pour le projet, ignorées par git

Mettez les garde-fous communs à l'équipe (le hook de formatage, les règles de permission) dans le .claude/settings.json partagé pour que tout le monde en hérite. Mettez vos préférences personnelles et les chemins propres à votre machine dans settings.local.json pour ne pas vous battre avec vos collègues dans le contrôle de version. Les organisations peuvent aussi déployer des managed settings qui priment sur les trois.

La clé la plus importante est permissions, qui contrôle ce que Claude peut faire sans s'arrêter pour demander. Vous autorisez, soumettez à confirmation ou refusez des patterns d'outils :

json
{
  "permissions": {
    "allow": [
      "Bash(npm run test:*)",
      "Read",
      "Edit"
    ],
    "deny": [
      "Bash(rm -rf:*)",
      "Read(./.env)",
      "Read(./secrets/**)"
    ]
  }
}

Claude peut ainsi lancer vos scripts de test et modifier des fichiers librement, sans jamais lire votre `.env` ni vos secrets, et en refusant les suppressions dangereuses. Réglez cela une fois et vous cessez de surveiller les demandes de confirmation pour les opérations sûres, tout en gardant un mur étanche autour des opérations dangereuses. Considérez les patterns deny sur Bash comme une commodité, car une commande déterminée peut se formuler de bien des façons. Pour des garanties fermes, doublez-les d'un hook PreToolUse.

Autres clés à connaître : env injecte des variables d'environnement dans chaque session, model fixe le modèle Claude utilisé par le projet, et hooks (voir plus haut) se trouve aussi ici. Gardez le fichier partagé minimal et réfléchi, car quiconque clone le repo en hérite. Le schéma complet est sur code.claude.com/docs/en/settings.

Comment les briques s'assemblent

Ces fonctionnalités se combinent. Une configuration réelle ressemble à ceci :

Un hook SessionStart charge les conventions du projet. Votre bloc permissions donne le feu vert à la commande de test et isole les secrets. Un Skill /review lance à la demande votre code review standardisée. Un subagent test-runner prend en charge le travail bruyant d'exécution et de diagnostic de la suite. Un hook PostToolUse formate chaque fichier que Claude touche. Un serveur MCP GitHub permet à Claude d'ouvrir la PR quand vous avez terminé. Tout cela vit dans des fichiers du repo, si bien qu'un nouveau collègue le clone et obtient dès le premier jour exactement le même Claude configuré.

Cette reproductibilité, c'est tout l'enjeu. Vous livrez un environnement d'ingénierie configuré en même temps que votre code.

Points clés

  • Les Skills sont le principal moyen d'étendre Claude Code. Un dossier dans .claude/skills/<name>/ vous donne une commande /<name> que Claude peut aussi invoquer de lui-même. Les prompts en fichier unique dans .claude/commands/ fonctionnent toujours pour les cas rapides.
  • Utilisez les subagents pour protéger votre contexte principal. Déléguez les tâches bruyantes et ciblées à des agents isolés aux droits d'outils serrés, et répartissez-les en parallèle pour le travail indépendant.
  • Les hooks rendent les règles déterministes. Ils lisent le JSON de l'événement sur stdin, et un hook PreToolUse ne bloque qu'avec le code de sortie 2. Ils exécutent de vraies commandes shell avec vos permissions : auditez tout ce que vous n'avez pas écrit vous-même.
  • Traitez MCP comme votre couche d'intégration. claude mcp add branche dans votre terminal les mêmes serveurs que ceux utilisés dans tout l'écosystème Anthropic, et .mcp.json les partage avec l'équipe.
  • Versionnez votre settings.json et pensez la superposition : garde-fous partagés dans le fichier d'équipe, surcharges personnelles dans settings.local.json.

À faire, tiré de cette leçon

Ces actions sont compilées dans le plan d'action du rôle.

  • Écrivez des slash commands partageables pour les tâches que vous déclenchez de façon répétée
  • Imposer des règles déterministes avec les hooks PreToolUse et PostToolUse
  • Committer settings.json pour les garde-fous partagés, en gardant les overrides personnels en local
Voir le plan d'action complet →