Claude Code exécute des instructions en langage naturel. Mais taper les mêmes consignes à chaque session gaspille du temps et introduit des incohérences. Les Skills et les Hooks résolvent ce problème. Les Skills transforment des workflows récurrents en commandes slash réutilisables. Les Hooks garantissent l'exécution de scripts à des moments précis du cycle de travail de l'agent. Combinés, ils convertissent Claude Code d'un outil ponctuel en une plateforme d'automatisation structurée.
Cet article détaille la création, la configuration et les cas d'usage de ces deux mécanismes. Chaque exemple est directement applicable dans un projet réel.
Skills : des workflows en commandes slash
Une Skill est un fichier Markdown qui enseigne à Claude Code un workflow reproductible. Au lieu de décrire à chaque fois les étapes d'une revue de code ou d'un déploiement, vous créez une Skill que l'agent charge sur commande.
Le principe : vous écrivez en langage naturel ce que l'agent doit faire, étape par étape. Claude Code interprète ces instructions et les exécute dans le contexte de votre projet. Pas de syntaxe propriétaire, pas de langage de programmation spécifique. Du Markdown structuré avec des consignes claires.
Les Skills sont stockées dans le répertoire .claude/skills/ à la racine de votre projet. Chaque fichier .md dans ce répertoire devient une Skill accessible via une commande slash. Un fichier nommé review-component.md s'invoque avec /review-component.
La structure d'un fichier Skill suit un schéma simple :
# Review Component
## Objectif
Analyser un composant front-end et vérifier la conformité aux standards du projet.
## Étapes
1. Lire le fichier du composant et ses dépendances directes
2. Vérifier la conformité au naming BEM pour les classes CSS
3. Vérifier l’accessibilité (attributs ARIA, contraste, navigation clavier)
4. Vérifier la gestion des erreurs et des états de chargement
5. Vérifier la couverture des tests unitaires
6. Produire un rapport structuré avec les problèmes identifiés et les corrections proposées
## Format du rapport
- Problèmes critiques (bloquants)
- Problèmes mineurs (qualité)
- Suggestions d’amélioration
- Score global sur 10
Ce fichier de 20 lignes remplace une instruction de 200 mots qu'il faudrait retaper à chaque revue de composant. L'agent suit les étapes dans l'ordre et produit un résultat standardisé.
Créer une Skill de déploiement
Les workflows de déploiement sont des candidats naturels pour les Skills. Chaque déploiement suit les mêmes étapes, dans le même ordre, avec les mêmes vérifications.
Voici une Skill /deploy pour un site statique :
# Deploy
## Prérequis
Vérifier que la branche courante est main ou une branche release/*
## Étapes
1. Exécuter le build : node generate-all-pages.js
2. Vérifier que dist/ contient des fichiers (le build a réussi)
3. Lancer les tests de liens cassés : node check-links.js
4. Si des liens sont cassés, lister les erreurs et ARRÊTER
5. Créer un commit avec le message "build: production [date]"
6. Demander confirmation avant de pousser vers le serveur
## Important
- Ne JAMAIS déployer si les tests échouent
- Ne JAMAIS modifier les fichiers source pendant le déploiement
- Afficher le résumé des fichiers modifiés avant la confirmation
L'intérêt de cette approche va au-delà du gain de temps. La Skill encode les règles de sécurité du déploiement. Un développeur junior qui lance /deploy bénéficie des mêmes garde-fous qu'un senior. Les erreurs de procédure disparaissent.
Activation automatique des Skills
Certaines Skills n'ont pas besoin d'être invoquées manuellement. Le mécanisme d'auto-activation permet à Claude Code de charger une Skill quand le contexte le justifie.
Pour activer ce comportement, ajoutez un bloc de métadonnées en tête du fichier Skill :
auto_activate: true
trigger: "quand l’utilisateur demande une revue de code"
Avec cette configuration, chaque fois que vous demandez "fais une revue de ce fichier" ou "vérifie la qualité du code", Claude Code charge automatiquement la Skill correspondante et applique son workflow.
L'auto-activation fonctionne par correspondance sémantique. L'agent analyse votre instruction et la compare aux déclencheurs définis dans les Skills disponibles. La correspondance n'est pas lexicale (mot pour mot) mais contextuelle. "Regarde si ce composant est propre" active la Skill de revue même si les mots exacts du trigger ne sont pas utilisés.
Une limite à connaître : si plusieurs Skills ont des triggers proches, l'agent peut hésiter ou charger la mauvaise. Des triggers précis et distincts évitent les ambiguïtés.
Hooks : exécution garantie sur événement
Les Skills reposent sur le raisonnement de l'agent pour décider quoi faire. Les Hooks, eux, exécutent un script shell de manière déterministe, sans intervention du modèle de langage. Le script tourne à chaque fois, sans exception.
Un Hook se déclenche sur un événement du cycle de vie de Claude Code :
- PreToolUse : avant chaque utilisation d'un outil (lecture de fichier, écriture, commande shell)
- PostToolUse : après chaque utilisation d'un outil
- Stop : quand l'agent termine sa réponse
- SessionStart : au lancement d'une nouvelle session
Les Hooks se configurent dans le fichier .claude/settings.json :
{
"hooks": {
"PostToolUse": [
{
"matcher": "write_file",
"command": "npx eslint --fix $CLAUDE_FILE_PATH"
}
],
"Stop": [
{
"command": "npm run lint"
}
]
}
}
Dans cet exemple, le premier Hook lance ESLint avec correction automatique après chaque écriture de fichier. Le deuxième exécute le linter complet quand l'agent termine son travail. Le résultat : chaque fichier produit par Claude Code respecte les règles de style du projet, automatiquement.
Hooks pour le linting et le formatage
Le cas d'usage principal des Hooks concerne la qualité du code. Claude Code génère du code fonctionnel, mais pas toujours conforme aux conventions de formatage spécifiques d'un projet.
Un Hook PostToolUse qui déclenche Prettier après chaque écriture de fichier JavaScript ou TypeScript :
{
"hooks": {
"PostToolUse": [
{
"matcher": "write_file",
"command": "npx prettier --write $CLAUDE_FILE_PATH 2>/dev/null || true"
}
]
}
}
Le || true empêche le Hook de bloquer l'agent si Prettier rencontre une erreur. La redirection vers /dev/null évite le bruit dans le terminal.
Pour les projets Python, le même principe s'applique avec Black ou Ruff :
{
"matcher": "write_file",
"command": "ruff format $CLAUDE_FILE_PATH && ruff check --fix $CLAUDE_FILE_PATH"
}
D'après une analyse de GitHub sur 15 000 projets open source, les équipes qui automatisent le formatage via des hooks ou des pre-commit réduisent de 25 % le nombre de commentaires de revue liés au style (source : GitHub Octoverse Report, 2025). Ce chiffre confirme ce que les développeurs constatent intuitivement : automatiser le formatage libère la revue de code pour les questions de fond.
Hooks de sécurité : prévenir les erreurs critiques
Les Hooks PreToolUse s'exécutent avant une action de l'agent. Ils permettent de bloquer des opérations dangereuses avant qu'elles ne se produisent.
Un cas concret : empêcher Claude Code de modifier des fichiers de configuration sensibles.
{
"hooks": {
"PreToolUse": [
{
"matcher": "write_file",
"command": "node .claude/scripts/check-protected-files.js $CLAUDE_FILE_PATH"
}
]
}
}
Le script check-protected-files.js vérifie si le fichier cible fait partie d'une liste protégée (.env, docker-compose.yml, fichiers de certificats). Si c'est le cas, le script renvoie un code d'erreur non nul et l'agent annule l'opération.
Un Hook SessionStart peut vérifier l'état de l'environnement avant toute action :
{
"hooks": {
"SessionStart": [
{
"command": "git status --porcelain | head -1 && echo ’Warning: uncommitted changes detected’"
}
]
}
}
Ce Hook avertit le développeur si des modifications non committées existent au démarrage de la session. Une précaution qui évite de mélanger les changements manuels et ceux de l'agent.
Combiner Skills, Hooks et MCP
La puissance de Claude Code apparaît quand Skills, Hooks et serveurs MCP fonctionnent ensemble. Chaque couche remplit un rôle distinct dans une pipeline d'automatisation complète.
Les Skills définissent le quoi : les étapes d'un workflow métier. Une Skill /audit-seo décrit les vérifications à effectuer, les métriques à extraire et le format du rapport.
Les serveurs MCP fournissent le comment : la connexion aux outils externes. Le serveur MCP Google Analytics fournit les données de trafic. Le serveur MCP Search Console fournit les données SEO. Le serveur MCP GitHub gère les commits et les pull requests.
Les Hooks assurent la qualité : le formatage automatique, les vérifications de sécurité, le linting post-modification.
Un exemple de pipeline complète : la Skill /weekly-report demande à l'agent de collecter les données GA4 (via MCP), d'analyser les tendances, de rédiger un rapport en Markdown et de le committer sur le repo. Après chaque écriture de fichier, le Hook PostToolUse vérifie le formatage. Au Stop, un Hook envoie une notification Slack confirmant que le rapport est prêt.
Cette architecture en couches permet de construire des automatisations robustes sans code complexe. Les Skills se rédigent en Markdown. Les Hooks exécutent des commandes shell standard. Les serveurs MCP utilisent des connecteurs préexistants. L'assemblage produit un résultat que seul un script sur mesure pouvait atteindre auparavant.
Bonnes pratiques pour structurer vos Skills
Quelques principes issus de l'usage quotidien améliorent la fiabilité des Skills.
Gardez chaque Skill focalisée sur un seul workflow. Une Skill qui combine déploiement et revue de code produit des résultats imprévisibles. Deux Skills distinctes, invoquées séquentiellement, fonctionnent mieux.
Rédigez les étapes de manière impérative et spécifique. "Vérifie le code" est vague. "Exécute npm run test et liste les tests en échec" est actionnable. Claude Code suit les instructions littéralement : la précision du Markdown détermine la qualité du résultat.
Versionnez vos Skills dans Git. Le répertoire .claude/skills/ fait partie du code source. Les Skills évoluent avec le projet. Un développeur qui rejoint l'équipe hérite automatiquement des workflows standardisés.
Testez vos Skills sur un cas simple avant de les utiliser en production. Une Skill mal formulée peut provoquer des modifications indésirables. La première exécution sur un fichier de test valide le comportement attendu.
La formation IA inclut un module dédié à la création de Skills et Hooks adaptés aux processus métier de chaque entreprise. Passer du concept à l'implémentation nécessite de cartographier les workflows existants, d'identifier les étapes automatisables et de rédiger les Skills correspondantes.
Pour comprendre les fondements de Claude Code avant de créer des Skills avancées, le guide CLI de Claude Code couvre l'installation, les commandes de base et le système de permissions. Le guide complet des agents IA replace ces mécanismes dans le contexte plus large de l'automatisation agentique.
Questions fréquentes
Faut-il savoir coder pour créer des Skills ?
Non. Les Skills sont rédigées en Markdown, en langage naturel. La syntaxe est celle d'un document structuré avec des titres et des listes. Un marketeur technique ou un chef de projet peut rédiger une Skill qui décrit un workflow de reporting ou d'audit de contenu sans écrire une ligne de code.
Les Hooks ralentissent-ils Claude Code ?
Un Hook léger (formatage, linting d'un fichier unique) s'exécute en moins d'une seconde et n'affecte pas la fluidité de la session. Un Hook lourd (suite de tests complète, analyse statique d'un projet entier) peut ajouter 10 à 30 secondes après chaque modification. La bonne pratique est de réserver les vérifications lourdes au Hook Stop (fin de réponse) et les vérifications légères au Hook PostToolUse.
Les Skills fonctionnent-elles avec tous les modèles Claude ?
Oui. Les Skills sont interprétées par le modèle actif dans la session (Opus, Sonnet ou Haiku). Les workflows complexes avec de nombreuses étapes conditionnelles gagnent à utiliser Opus, qui maintient mieux la cohérence sur les séquences longues. Les workflows simples et linéaires fonctionnent aussi bien avec Sonnet.
Comment partager des Skills entre plusieurs projets ?
Deux approches. La première : un répertoire de Skills partagé en tant que sous-module Git, inclus dans chaque projet. La deuxième : un CLAUDE.md global au niveau utilisateur (~/.claude/CLAUDE.md) qui référence des Skills communes. La première approche convient aux équipes qui travaillent sur des projets similaires. La deuxième convient aux développeurs individuels.
Quelle différence entre une Skill et un prompt system ?
Un prompt system (instruction système) s'applique à toute la conversation. Une Skill s'active ponctuellement pour un workflow spécifique. Le CLAUDE.md joue le rôle de prompt system permanent. Les Skills complètent ce contexte avec des procédures ciblées.
