Commandes personnalisées et skills - Tutoriel

Ce tutoriel vous guide pas à pas pour créer vos propres commandes slash, configurer des skills réutilisables, orchestrer des subagents et automatiser vos workflows avec les hooks dans Claude Code. En 30 minutes, vous saurez personnaliser et étendre Claude Code pour l'adapter à vos pratiques de développement quotidiennes.

Les commandes personnalisées et skills de Claude Code constituent le système d'extensibilité qui transforme l'assistant IA en un outil adapté à vos workflows spécifiques. Claude Code v2.1 propose quatre mécanismes complémentaires : les commandes slash custom, les skills, les subagents et les hooks. plus de 60 % des utilisateurs avancés créent au moins une commande personnalisée dans leur première semaine d'utilisation.

Quels sont les prérequis avant de commencer ?

Avant de créer vos premières commandes, vérifiez que votre environnement est prêt. Vous avez besoin de Claude Code installé et fonctionnel sur votre machine. Consultez le tutoriel d'installation et premier lancement si ce n'est pas encore fait.

Exécutez ces vérifications dans votre terminal :

claude --version
node --version

Vous devez aussi disposer d'un projet avec un fichier CLAUDE.md initialisé. Si vous découvrez ce fichier, le tutoriel sur le système de mémoire CLAUDE.md vous explique son fonctionnement en détail.

Durée totale estimée : environ 30 minutes.

À retenir : Claude Code v2.1 sur Node.js 22 et un fichier CLAUDE.md sont les trois prérequis indispensables.

Comment créer votre première commande slash custom ? (~5 min)

Une commande slash custom est un prompt Markdown réutilisable que vous invoquez avec /nom-de-commande dans Claude Code. Concrètement, chaque fichier .md placé dans le répertoire .claude/commands/ devient une commande disponible.

Étape 1 : Créez le répertoire de commandes dans votre projet.

mkdir -p .claude/commands

Étape 2 : Créez un fichier Markdown pour votre commande.

touch .claude/commands/review.md

Étape 3 : Écrivez le prompt de votre commande dans le fichier.

Analyse le code modifié dans la branche courante.
Vérifie :
- Les failles de sécurité potentielles
- Les problèmes de performance
- La couverture de tests manquante
Formate la sortie en tableau Markdown.

✅ Vérification : Lancez Claude Code et tapez /review. La commande doit apparaître dans l'autocomplétion et exécuter votre prompt.

claude
# Dans la session, tapez : /review

Les commandes acceptent aussi des arguments dynamiques grâce à la variable $ARGUMENTS. En pratique, vous pouvez créer une commande /explain qui prend un nom de fichier en paramètre.

Explique le fichier $ARGUMENTS en détail.
Liste les fonctions, leur rôle et les dépendances.

⚠️ Si vous voyez "Command not found", vérifiez que le fichier est bien dans .claude/commands/ (pas .claude/command/ au singulier) et qu'il porte l'extension .md.

Pour découvrir les commandes slash natives, consultez le tutoriel sur les commandes slash essentielles qui couvre /init, /compact et /clear.

À retenir : un fichier .md dans .claude/commands/ = une commande slash invocable immédiatement avec $ARGUMENTS pour les paramètres.

Comment configurer des skills pour que l'IA apprenne vos patterns ? (~5 min)

Un skill est une commande enrichie qui permet à Claude Code de reproduire vos conventions de code automatiquement. Là où une commande simple envoie un prompt, un skill capture un pattern complet : structure de fichier, conventions de nommage, tests associés.

Créez un skill de génération de composant React :

# Skill : Créer un composant React

Crée un composant React TypeScript avec :
- Fichier : `src/components/$ARGUMENTS.tsx`
- Interface Props typée et exportée
- Export par défaut
- Fichier de test : `src/components/__tests__/$ARGUMENTS.test.tsx`
- Minimum 2 tests : rendu par défaut et gestion des props

Conventions :
- PascalCase pour le composant
- camelCase pour les props
- Utiliser des arrow functions

Enregistrez ce fichier sous .claude/commands/component.md. Vous invoquez ensuite /component Button et Claude Code génère le composant, l'interface et les tests en respectant vos conventions.

les skills réduisent le temps de scaffolding de 70 % en moyenne sur les projets TypeScript. SFEIR Institute utilise ce mécanisme dans ses formations pour standardiser la production de code entre participants.

Comment structurer un skill avancé ?

Vous pouvez organiser vos skills en sous-répertoires pour les catégoriser :

.claude/commands/
├── frontend/
│   ├── component.md
│   ├── hook.md
│   └── page.md
├── backend/
│   ├── endpoint.md
│   └── migration.md
└── test/
    └── integration.md

En pratique, chaque sous-répertoire crée un namespace. La commande devient /frontend:component ou /backend:endpoint. Cette organisation s'avère utile dès que vous dépassez 5 commandes.

Pour bien gérer le contexte de vos prompts dans ces skills, reportez-vous au tutoriel sur la gestion du contexte qui détaille les limites de tokens.

✅ Vérification : Listez vos commandes disponibles avec / dans Claude Code. Vous devez voir apparaître vos skills avec leur namespace.

À retenir : les skills capturent vos patterns de code complets - structure, conventions et tests - et les reproduisent en une seule commande slash.

Comment orchestrer des subagents pour les tâches complexes ? (~7 min)

Un subagent est une instance Claude Code spécialisée qu'un agent principal peut lancer pour traiter une sous-tâche en parallèle. Le système supporte jusqu'à 10 subagents concurrents, chacun disposant de son propre contexte de 200 000 tokens.

Configurez un skill qui utilise des subagents pour un audit complet de projet :

# Skill : Audit complet du projet

Lance 3 analyses en parallèle :

1. **Sécurité** : Vérifie les dépendances vulnérables avec
   `npm audit` et analyse les patterns dangereux (eval, innerHTML)

2. **Performance** : Mesure la taille du bundle, identifie
   les imports inutilisés et les re-renders React superflus

3. **Qualité** : Vérifie la couverture de tests, le typage
   TypeScript strict et les TODO/FIXME restants

Fusionne les 3 rapports dans un tableau de synthèse.

Concrètement, Claude Code décompose automatiquement ce prompt en sous-tâches distribuées. Chaque subagent traite sa partie et le résultat est consolidé.

Quels paramètres configurer pour les subagents ?

Vous contrôlez le comportement des subagents via plusieurs paramètres dans vos commandes :

• max_turns : limite le nombre d'itérations (par défaut 25, recommandé 10 pour les tâches simples)
• model : choisissez haiku pour les tâches rapides, opus pour les analyses profondes
• mode : plan exige une approbation, bypassPermissions automatise entièrement

Utilise un subagent Explore pour trouver toutes les fonctions
non testées dans src/, puis un subagent general-purpose
pour générer les tests manquants.
Mode : plan (demander confirmation avant d'écrire).

⚠️ Si un subagent tourne en boucle, c'est souvent dû à un max_turns trop élevé ou un prompt ambigu. Réduisez max_turns à 5 et précisez le livrable attendu.

L'aide-mémoire des commandes personnalisées récapitule les paramètres de subagents dans un format imprimable.

À retenir : les subagents permettent de paralléliser les tâches lourdes - limitez max_turns et précisez toujours le livrable attendu pour éviter les boucles.

Comment automatiser vos workflows avec les hooks ? (~7 min)

Un hook est un script shell déclenché automatiquement par un événement dans Claude Code. Contrairement aux skills (pilotés par l'IA), les hooks exécutent du code déterministe à chaque fois. les hooks couvrent 4 événements principaux.

Configurez votre premier hook dans le fichier .claude/settings.json :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "command": "npx eslint --fix $CLAUDE_FILE_PATH"
      }
    ]
  }
}

Ce hook lance ESLint automatiquement après chaque écriture ou modification de fichier. En pratique, vous obtenez un formatage cohérent sans jamais y penser.

Comment créer un hook de validation pré-commit ?

Ajoutez un hook PreToolUse qui vérifie le typage TypeScript avant toute opération Bash de commit :

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "command": "if echo \"$CLAUDE_TOOL_INPUT\" | grep -q 'git commit'; then npx tsc --noEmit; fi"
      }
    ]
  }
}

✅ Vérification : Modifiez un fichier .ts avec une erreur de type, puis demandez à Claude Code de committer. Le hook doit bloquer le commit et afficher l'erreur TypeScript.

Pour comprendre comment les hooks interagissent avec le système de permissions, consultez le tutoriel sur les permissions et la sécurité qui explique les niveaux d'autorisation.

⚠️ Si un hook bloque toutes les opérations, vérifiez le matcher : un matcher trop large comme ".*" intercepte absolument tout. Ciblez précisément les outils concernés.

Le temps d'exécution moyen d'un hook est de 120 ms pour un lint et jusqu'à 3 secondes pour une compilation TypeScript complète. Au-delà de 5 secondes, Claude Code affiche un avertissement de timeout.

À retenir : les hooks garantissent une automatisation déterministe - utilisez PostToolUse pour le lint automatique et PreToolUse pour les validations bloquantes.

Comment partager et réutiliser vos commandes en équipe ? (~3 min)

Les commandes stockées dans .claude/commands/ au niveau du projet sont versionnées avec Git. Chaque membre de l'équipe y accède automatiquement après un git pull. C'est le mécanisme recommandé pour standardiser les pratiques dans un projet.

Créez un répertoire structuré pour une équipe de 5 développeurs :

.claude/
├── commands/
│   ├── review.md          # Code review standardisée
│   ├── deploy.md          # Procédure de déploiement
│   ├── hotfix.md          # Workflow de correction urgente
│   └── onboarding.md      # Guide pour les nouveaux
├── settings.json          # Hooks partagés
└── CLAUDE.md              # Conventions du projet

L'article sur les astuces avancées des commandes personnalisées détaille les patterns de partage les plus efficaces en équipe.

Les commandes personnelles dans ~/.claude/commands/ restent privées. Vous pouvez y stocker des raccourcis spécifiques à votre workflow sans affecter l'équipe. En 2026, environ 45 % des équipes utilisant Claude Code partagent plus de 10 commandes via leur dépôt Git.

Pour maîtriser la rédaction du fichier CLAUDE.md qui accompagne vos commandes, suivez le tutoriel CLAUDE.md - il couvre les bonnes pratiques de documentation.

À retenir : versionnez vos commandes dans .claude/commands/ pour que toute l'équipe bénéficie des mêmes standards, et gardez ~/.claude/commands/ pour vos raccourcis personnels.

Comment déboguer une commande qui ne fonctionne pas ? (~3 min)

Vous rencontrerez parfois des commandes qui ne produisent pas le résultat attendu. Voici la méthode systématique de diagnostic en 4 points.

Vérifiez d'abord que le fichier est bien détecté :

ls -la .claude/commands/

Testez ensuite le prompt directement dans une conversation Claude Code sans passer par la commande slash. Si le résultat est correct en mode direct mais pas via la commande, le problème vient du fichier .md.

La FAQ des commandes personnalisées répond aux 15 questions les plus fréquentes sur les erreurs de configuration.

Pour approfondir la construction de vos premières conversations avec Claude Code et comprendre comment les commandes s'insèrent dans le flux, consultez le tutoriel sur vos premières conversations.

⚠️ Si $ARGUMENTS ne se substitue pas, assurez-vous d'écrire $ARGUMENTS en majuscules exactes. Les variantes comme $arguments ou $ARGS ne fonctionnent pas.

À retenir : diagnostiquez en 4 étapes - présence du fichier, test du prompt brut, vérification des paramètres, puis analyse des logs.

Comment aller plus loin avec les commandes personnalisées ?

Vous maîtrisez désormais les quatre piliers d'extensibilité de Claude Code : commandes slash, skills, subagents et hooks. Voici les pistes pour pousser plus loin votre configuration.

Combinez hooks et skills pour créer des workflows complets. Par exemple, un skill /deploy qui génère un changelog, lance les tests via un subagent, puis déclenche un hook de notification Slack après le déploiement.

# Skill : Deploy to staging

1. Génère le changelog depuis le dernier tag Git
2. Lance les tests via un subagent (mode: bypassPermissions)
3. Exécute `npm run build && npm run deploy:staging`
4. Le hook PostToolUse enverra la notification Slack

SFEIR Institute propose la formation Claude Code sur 1 jour pour pratiquer ces mécanismes d'extensibilité en conditions réelles avec des labs encadrés. Si vous souhaitez intégrer Claude Code dans un workflow de développement complet, la formation Développeur Augmenté par l'IA sur 2 jours couvre l'ensemble des outils IA pour le développement. Pour ceux qui maîtrisent déjà les bases, la formation Développeur Augmenté par l'IA – Avancé approfondit les techniques d'orchestration multi-agents en 1 jour.

L'article de référence sur les commandes personnalisées et skills couvre l'ensemble des concepts abordés ici avec des exemples supplémentaires.

Trois idées de commandes à créer dès maintenant

1. /changelog - Génère un changelog formaté à partir des commits Git entre deux tags
2. /migrate - Crée une migration de base de données avec rollback et tests
3. /perf - Lance un audit de performance Lighthouse et résume les scores en tableau

En 2026, l'écosystème de commandes partagées continue de croître. Des répertoires communautaires de skills émergent, permettant d'importer des commandes prêtes à l'emploi avec un simple copier-coller dans votre répertoire .claude/commands/.

À retenir : combinez skills, subagents et hooks pour construire des workflows automatisés de bout en bout - commencez par une commande simple et enrichissez-la progressivement.