Accueil › Claude Code › Commands

Claude Code Commands : créer des skills et commandes personnalisées

Les commands et skills de Claude Code transforment des prompts ponctuels en workflows réutilisables. Un fichier Markdown dans le bon dossier crée une commande invocable par /nom, avec des arguments dynamiques, un frontmatter pour contrôler le comportement, et la possibilité d’auto-invocation par Claude quand la tâche le justifie.

Commands vs Skills : comprendre l’unification

Claude Code a historiquement séparé deux systèmes : les « commands » (fichiers .md dans .claude/commands/) et les « skills » (fichiers SKILL.md dans .claude/skills/). Ces deux systèmes ont été fusionnés. Les fichiers dans l’un ou l’autre emplacement créent la même interface /slash-command.

Vos fichiers .claude/commands/ existants continuent de fonctionner. Mais Anthropic recommande les skills pour les nouvelles créations car elles supportent des fonctionnalités supplémentaires : un répertoire pour les fichiers de support (templates, exemples, scripts), un frontmatter pour contrôler l’auto-invocation, et la possibilité pour Claude de les charger automatiquement quand elles sont pertinentes.

Les skills suivent le standard ouvert Agent Skills, conçu pour fonctionner dans plusieurs outils IA, pas uniquement Claude Code.

Commandes intégrées et skills bundled

Commandes intégrées (built-in)

Les commandes intégrées exécutent une logique fixe codée directement dans le CLI Claude Code. Elles ne sont pas modifiables. Pour la liste complète et détaillée de chaque commande, consultez la page Prompts Claude Code. Voici les plus importantes :

Skills bundled

Contrairement aux commandes intégrées qui exécutent une logique fixe, les skills bundled sont des prompts détaillés qui donnent à Claude un playbook et le laissent orchestrer le travail avec ses outils. Elles peuvent créer des sous-agents en parallèle, lire des fichiers et s’adapter à votre codebase.

/batch orchestre un changement massif et parallélisable sur la codebase. Vous décrivez la modification, et Claude la réplique sur tous les fichiers correspondants en parallèle. Indispensable pour les refactorings à grande échelle.

/simplify simplifie du code complexe en préservant le comportement. Claude analyse le code, identifie la complexité inutile et propose une version plus lisible.

/loop programme des tâches récurrentes (monitoring, polling). Par exemple, /loop 5m check deploy status vérifie le déploiement toutes les 5 minutes, jusqu’à 3 jours. C’est un cron job léger au niveau de la session.

/debug lance un debugging structuré avec analyse des logs et stack traces.

/claude-api aide à l’utilisation de l’API Claude et du SDK. Cette skill s’active aussi automatiquement quand Claude détecte du code qui importe anthropic, @anthropic-ai/sdk ou claude_agent_sdk.

Créer une skill étape par étape

Structure de base

Chaque skill nécessite un fichier SKILL.md dans un répertoire dédié. Le fichier contient deux parties : un frontmatter YAML (entre des marqueurs ---) qui dit à Claude quand utiliser la skill, et du contenu Markdown avec les instructions.

# Créer le répertoire de la skill
mkdir -p .claude/skills/review-security

# Créer le fichier SKILL.md
cat > .claude/skills/review-security/SKILL.md << 'EOF'
---
name: review-security
description: Audit de sécurité du code. Utiliser quand l'utilisateur
  demande une revue de sécurité ou mentionne des vulnérabilités.
allowed-tools: Read, Grep, Glob
---

# Audit de sécurité

Analyse le code pour les vulnérabilités suivantes :

1. **Injections** : SQL, XSS, commande, template
2. **Authentification** : tokens, sessions, mots de passe
3. **Autorisations** : contrôle d'accès, élévation de privilèges
4. **Données sensibles** : credentials exposées, logs excessifs
5. **Dépendances** : versions vulnérables connues

Pour chaque trouvaille :
- Identifie le fichier et la ligne exacte
- Explique le risque concret
- Propose un fix avec un exemple de code
- Classe par sévérité (critique, haute, moyenne, basse)
EOF

Le champ name devient la commande /review-security. Le champ description aide Claude à décider quand charger la skill automatiquement.

Options du frontmatter

Le frontmatter YAML contrôle finement le comportement de la skill.

Arguments dynamiques

Les skills acceptent des arguments positionnels ($1, $2) ou l’ensemble via $ARGUMENTS.

---
name: fix-issue
argument-hint: [numéro-issue] [priorité]
description: Corrige une issue GitHub
allowed-tools: Bash(gh *)
---

Corrige l'issue #$1 avec une priorité $2.

1. Lis l'issue sur GitHub avec `gh issue view $1`
2. Analyse le code concerné
3. Implémente le fix
4. Écris les tests
5. Crée un commit Conventional Commits

Usage : /fix-issue 42 haute produit le prompt avec $1 = 42 et $2 = haute.

Préprocessing avec commandes shell

La syntaxe !`commande` exécute des commandes shell avant l’envoi du prompt à Claude. Le résultat remplace le placeholder. C’est du préprocessing : Claude ne voit que le résultat final, pas la commande.

---
name: pr-summary
description: Résumé d'une pull request
allowed-tools: Bash(gh *)
context: fork
agent: Explore
---

## Contexte PR
- Diff complet : !`gh pr diff`
- Commentaires : !`gh pr view --comments`
- Fichiers modifiés : !`gh pr diff --name-only`

## Tâche
Résume cette PR en français :
1. Objectif principal
2. Fichiers clés et raisons des changements
3. Risques potentiels
4. Verdict : prêt à merger ou non

Le champ allowed-tools est nécessaire pour que les commandes !`...` puissent s’exécuter.

Fichiers de support

L’avantage des skills par rapport aux commands legacy est la possibilité d’inclure des fichiers supplémentaires dans le répertoire de la skill.

.claude/skills/generate-component/
├── SKILL.md              # Instructions principales
├── template.tsx          # Template de composant React
├── template.test.tsx     # Template de test
└── examples/
    ├── Button.tsx        # Exemple de composant généré
    └── Button.test.tsx   # Exemple de test généré

Référencez ces fichiers depuis votre SKILL.md pour que Claude sache quand les charger. Par exemple : « Utilise le template dans template.tsx comme base pour le composant. Consulte les exemples dans examples/ pour le format attendu. »

Auto-invocation et contrôle

Par défaut, Claude peut invoquer n’importe quelle skill dont la description correspond à la tâche en cours. C’est l’une des fonctionnalités les plus puissantes : vous n’avez pas besoin de taper la commande si Claude reconnaît que la skill est pertinente.

Trois mécanismes pour contrôler ce comportement :

Désactiver pour une skill spécifique. Ajoutez disable-model-invocation: true dans le frontmatter. La skill disparaît complètement du contexte de Claude et ne peut être invoquée que manuellement.

Restreindre via les permissions. Dans /permissions, vous pouvez autoriser ou bloquer des skills spécifiques : Skill(commit) pour un match exact, Skill(deploy *) pour un match par préfixe.

Désactiver globalement. Bloquez l’outil Skill dans /permissions pour empêcher toute auto-invocation.

Budget de contexte des skills

Les descriptions de skills sont chargées en contexte pour que Claude sache ce qui est disponible. Si vous avez beaucoup de skills, elles peuvent dépasser le budget de caractères. Ce budget est dynamique : 2% de la fenêtre de contexte, avec un fallback à 16 000 caractères.

Exécutez /context pour vérifier si des skills sont exclues. Pour ajuster la limite, configurez la variable SLASH_COMMAND_TOOL_CHAR_BUDGET. En pratique, gardez vos descriptions courtes et précises pour maximiser le nombre de skills dans le budget.

Skills avec sous-agents

En ajoutant context: fork dans le frontmatter, la skill s’exécute dans un contexte séparé. Combiné avec le champ agent, cela crée des workflows puissants qui préservent la fenêtre de contexte principale.

---
name: deep-research
description: Recherche approfondie sur un sujet dans la codebase
context: fork
agent: Explore
---

Recherche $ARGUMENTS en profondeur :

1. Trouve les fichiers pertinents avec Glob et Grep
2. Lis et analyse le code
3. Résume les trouvailles avec des références de fichiers précises
4. Identifie les patterns et les incohérences

Le sous-agent Explore fournit des outils en lecture seule optimisés pour l’exploration de la codebase. Les résultats sont résumés et retournés dans votre conversation principale.

Les options d’agent incluent les agents intégrés (Explore, Plan, general-purpose) ou n’importe quel sous-agent custom défini dans .claude/agents/. Si le champ est omis, Claude utilise l’agent general-purpose.

Pour activer le mode de réflexion étendue dans une skill, incluez le mot « ultrathink » dans le contenu du SKILL.md. Claude utilisera alors un temps de raisonnement maximal.

Plugins : partager et installer des skills

Les plugins sont des collections de skills, hooks, commandes et sous-agents empaquetées ensemble. Techniquement, un plugin est un dépôt Git public sur GitHub.

Installer un plugin

Claude Code inclut une commande /plugin pour découvrir et installer des plugins depuis des marketplaces.

# Ajouter un marketplace
/plugin marketplace add https://github.com/wshobson/agents

# Installer un plugin
/plugin install nom-du-plugin

Plugins communautaires notables

L’écosystème de plugins Claude Code est actif. Quelques collections qui valent le détour :

Code Review Plugin (officiel Anthropic) : lance 4 agents de review en parallèle, score chaque trouvaille sur un indice de confiance, ne retourne que les problèmes avec un score supérieur à 80. Inclus dans le dépôt Claude Code.

awesome-claude-code : une liste curatée de skills, hooks, commandes, orchestrateurs d’agents et plugins pour Claude Code, maintenue par la communauté.

Workflows de gestion de projet : plusieurs plugins proposent des slash commands pour le cycle de développement complet, de la planification au déploiement, avec des agents spécialisés pour chaque phase.

Bibliothèque d’exemples pratiques

Commit Git structuré

---
name: commit
description: Crée un commit structuré Conventional Commits
argument-hint: [message optionnel]
allowed-tools: Bash(git add:*), Bash(git status:*), Bash(git commit:*), Bash(git diff:*)
model: claude-haiku-4-5-20251001
---

# Contexte Git
- Status : !`git status --short`
- Diff staged : !`git diff --cached --stat`

Crée un commit Conventional Commits.
Si un message est fourni ($ARGUMENTS), utilise-le.
Sinon, analyse le diff et génère un message approprié.

Format : type(scope): description courte

Types : feat, fix, refactor, docs, test, chore, style, perf

Le modèle Haiku est spécifié via model car générer un message de commit ne nécessite pas le raisonnement d’Opus. Cela économise des tokens.

Scaffold de composant

---
name: new-component
description: Scaffold un nouveau composant React
argument-hint: [NomComposant]
---

Crée un nouveau composant React "$ARGUMENTS" :

1. Composant dans `src/components/$ARGUMENTS/$ARGUMENTS.tsx`
2. Tests dans `src/components/$ARGUMENTS/$ARGUMENTS.test.tsx`
3. Styles dans `src/components/$ARGUMENTS/$ARGUMENTS.module.css`
4. Export dans `src/components/index.ts`

Respecte les conventions du CLAUDE.md.
Composants fonctionnels, TypeScript strict, pas de `any`.

Migration de base de données

---
name: migrate
description: Crée et exécute une migration de base de données
argument-hint: [description de la migration]
allowed-tools: Bash(npx prisma *), Read, Edit
---

Crée une migration Prisma pour : $ARGUMENTS

1. Modifie le schéma `prisma/schema.prisma`
2. Génère la migration avec `npx prisma migrate dev --name `
3. Vérifie que la migration s'applique sans erreur
4. Met à jour le client Prisma avec `npx prisma generate`
5. Adapte les types TypeScript si nécessaire

Documentation automatique

---
name: update-docs
description: Met à jour la documentation après un changement de code
context: fork
agent: Explore
allowed-tools: Read, Grep, Glob
---

## Changements récents
!`git diff --name-only HEAD~1`

## Tâche
1. Identifie quels fichiers de documentation dans `docs/` sont
   impactés par les changements ci-dessus
2. Pour chaque fichier impacté, lis le code source modifié
   et la documentation existante
3. Propose les mises à jour nécessaires avec le contenu exact
4. Signale toute documentation manquante pour du code nouveau

Bonnes pratiques

Préférez les skills aux commands. Utilisez .claude/skills/ pour toute nouvelle création. Les skills supportent les fichiers de support, l’auto-invocation, et la détection live (modifiables sans redémarrer la session).

Gardez les descriptions courtes et précises. Elles sont chargées en contexte. Une description trop longue gaspille du budget. Visez 1-2 phrases qui décrivent quand la skill doit être utilisée.

Spécifiez les allowed-tools. Sans ce champ, Claude doit demander permission pour chaque outil. En listant les outils autorisés, vous rendez la skill fluide. Mais ne mettez que le strict nécessaire.

Utilisez le bon modèle. Les tâches mécaniques (commit, lint, scaffold) fonctionnent très bien avec Haiku ($1/5$ par M tokens). Réservez Opus pour les skills complexes (architecture, debugging, review approfondie). Le champ model dans le frontmatter permet de forcer le choix par skill.

Forked context pour les tâches exploratoires. Ajoutez context: fork pour les skills de recherche ou d’analyse qui peuvent générer beaucoup de contexte. Le sous-agent travaille dans son propre espace et ne pollue pas votre session principale.

Versionnez les skills du projet. Les skills dans .claude/skills/ à la racine du projet doivent être committées dans Git. Toute l’équipe bénéficie des mêmes workflows. Les skills personnelles vont dans ~/.claude/skills/.

Demandez à Claude de créer vos skills. C’est une approche parfaitement valide : décrivez le workflow que vous voulez automatiser, et demandez à Claude de créer la skill correspondante. Il connaît la syntaxe du frontmatter et peut générer le SKILL.md directement.

Commandes MCP

Les serveurs MCP connectés peuvent exposer leurs propres commandes. Elles apparaissent dans le format /mcp__<serveur>__<prompt> et sont découvertes dynamiquement depuis les serveurs connectés. Tapez / pour les voir dans la liste d’autocomplétion.

Questions fréquentes