Claude Code Skills : Créer des Commandes Personnalisées

Mis à jour le 3 mars 2026

Les skills sont le système de commandes personnalisées de Claude Code. Au lieu de répéter les mêmes instructions à chaque session, tu les packages une fois en skill et tu les invoques en un mot. C'est la différence entre un outil générique et un outil taillé pour TON workflow.

Tu as un process de review que tu répètes 10 fois par jour ? Un format de commit que tu veux toujours identique ? Une checklist de déploiement que tu oublies une fois sur trois ? Chacun de ces cas est un skill. Tu l'écris une fois, tu l'appelles avec /review, /commit ou /deploy, et Claude Code exécute exactement ce que tu as défini. Pas de reformulation. Pas d'oubli. Pas de variation.

Ce guide te montre comment créer tes propres skills, comprendre chaque option du frontmatter YAML, et te donne des exemples concrets à copier-coller. Si tu débutes avec Claude Code, commence par le guide complet Claude Code pour les bases, puis reviens ici pour passer au niveau supérieur.

C'est quoi un skill Claude Code

Un skill est un fichier Markdown avec des instructions réutilisables, stocké dans .claude/skills/. Tu l'invoques avec /nom-du-skill ou Claude Code le déclenche automatiquement quand le contexte correspond. C'est une commande personnalisée que tu crées toi-même.

Techniquement, un skill est un prompt enrichi. Tu prends des instructions que tu donnerais manuellement à Claude Code ("analyse le git diff, vérifie la sécurité, génère un message de commit en conventional commits"), tu les mets dans un fichier SKILL.md avec un peu de métadonnées YAML en en-tête, et tu obtiens une commande réutilisable.

Il existe deux types de skills :

• Les knowledge skills (skills de connaissance) : ce sont des skills qui se déclenchent automatiquement quand Claude Code détecte un contexte pertinent. Par exemple, un skill qui contient les conventions de ton design system s'activera quand tu travailles sur du CSS ou des composants UI. Leur description dans le frontmatter sert de déclencheur — Claude Code lit la description et décide si le skill est pertinent pour la tâche en cours.
• Les workflow skills (skills d'action) : ce sont des commandes manuelles que tu invoques avec /nom-du-skill. Un /commit, un /review, un /deploy. Tu décides quand les lancer. Ils ont l'option disable-model-invocation: true dans le frontmatter pour empêcher le déclenchement automatique.

La puissance des skills, c'est la standardisation. Au lieu que Claude Code interprète tes instructions différemment à chaque session (selon la formulation, le contexte, l'humeur du modèle), le skill garantit un comportement constant. Les mêmes étapes. Le même format de sortie. Les mêmes vérifications. A chaque fois.

Comment créer ton premier skill

Créer un skill prend littéralement 5 minutes. Voici le process étape par étape.

Etape 1 : Créer la structure de fichiers

Un skill vit dans un dossier dédié à l'intérieur de .claude/skills/. Le nom du dossier devient le nom de la commande. Crée la structure suivante :

.claude/
  skills/
    review/
      SKILL.md

Le fichier SKILL.md (avec exactement ce nom, en majuscules) est le fichier principal du skill. C'est lui que Claude Code lit quand tu invoques la commande /review.

Etape 2 : Ecrire le frontmatter YAML

Le frontmatter est le bloc de métadonnées au début du fichier, entre deux lignes de ---. Le YAML est un format de données simple qui utilise des paires clé/valeur. Voici le frontmatter minimal :

---
name: review
description: "Revue de code : analyse le git diff pour détecter les problèmes de sécurité, qualité et maintenabilité."
---

name est le nom de la commande (ce que tu tapes après le /). description explique à Claude Code quand et comment utiliser ce skill — c'est aussi ce texte qui apparaît dans la liste des commandes disponibles.

Etape 3 : Ecrire les instructions

Après le frontmatter, tu écris tes instructions en Markdown. C'est le corps du skill — ce que Claude Code va exécuter. Voici un exemple complet de skill de review :

---
name: review
description: "Revue de code complète : sécurité, qualité, maintenabilité. Analyse le git diff et produit un rapport structuré."
disable-model-invocation: true
allowed-tools: Read, Grep, Glob, Bash(git diff), Bash(git log)
---

# Code Review

Analyse les changements du dernier commit ou du diff en cours.

## Etapes

1. Lance `git diff --staged` pour voir les changements staged
2. Si rien n'est staged, lance `git diff` pour les changements non-staged
3. Si rien non plus, lance `git diff HEAD~1` pour le dernier commit

## Critères d'analyse

- **Sécurité** : secrets exposés, injections, permissions trop larges
- **Qualité** : nommage, lisibilité, complexité excessive
- **Maintenabilité** : code dupliqué, couplage fort, dette technique
- **Performance** : boucles inutiles, requêtes N+1, assets non optimisés

## Format de sortie

Produis un rapport avec :
- Un résumé en 1-2 phrases
- Les problèmes critiques (bloquants)
- Les suggestions d'amélioration (non-bloquants)
- Un score global sur 10

Etape 4 : Invoquer le skill

Dans ta session Claude Code, tape simplement :

/review

Claude Code charge le fichier SKILL.md, applique les instructions, et exécute la revue de code. Le skill apparaît aussi dans l'auto-complétion quand tu tapes / dans le terminal.

C'est tout. Pas de compilation, pas d'installation, pas de configuration. Tu crées le fichier, tu l'invoques. Si tu modifies le fichier SKILL.md, les changements sont pris en compte immédiatement à la prochaine invocation.

Les options du frontmatter

Le frontmatter YAML est la partie configuration du skill. Chaque option modifie le comportement de la commande. Voici le détail de chacune.

name

Le nom de la commande. C'est ce que tu tapes après le /. Utilise le format kebab-case (mots en minuscules séparés par des tirets) : fix-issue, deploy-check, generate-doc.

name: deploy-check

description

La description du skill. Elle a deux rôles : elle apparaît dans la liste des commandes, et elle sert de déclencheur pour les knowledge skills (ceux qui s'activent automatiquement). Sois précis — plus la description est claire, mieux Claude Code saura quand utiliser le skill.

description: "Vérifie que le projet est prêt pour le déploiement : tests, build, variables d'environnement, dépendances."

disable-model-invocation

Quand cette option est à true, le skill ne se déclenche jamais automatiquement. Tu dois l'invoquer manuellement avec /nom-du-skill. C'est l'option à utiliser pour les workflow skills — les commandes d'action que tu veux contrôler toi-même.

disable-model-invocation: true

Sans cette option, Claude Code peut décider d'utiliser ton skill de lui-même s'il juge que le contexte correspond à la description. C'est le comportement souhaité pour les knowledge skills (design system, conventions de code, règles métier).

allowed-tools

Restreint les outils que Claude Code peut utiliser pendant l'exécution du skill. Par défaut, un skill a accès à tous les outils (Read, Write, Edit, Bash, Grep, Glob, etc.). Avec allowed-tools, tu crées un périmètre de sécurité.

allowed-tools: Read, Grep, Glob

Cet exemple crée un skill en lecture seule. Claude Code peut lire et chercher dans les fichiers, mais il ne peut ni les modifier (Write, Edit), ni exécuter des commandes (Bash). Parfait pour un skill de review ou d'analyse qui ne doit rien toucher.

Tu peux aussi autoriser des commandes Bash spécifiques :

allowed-tools: Read, Grep, Glob, Bash(git diff), Bash(git log), Bash(npm test)

La syntaxe Bash(commande) autorise uniquement cette commande précise. Claude Code ne pourra pas exécuter d'autres commandes shell.

context: fork

Lance le skill dans un contexte isolé — un sous-agent (subagent) avec sa propre fenêtre de contexte. Le skill s'exécute sans polluer la conversation principale. Une fois terminé, seul le résultat remonte dans ta session.

context: fork

C'est utile pour les skills qui font beaucoup de travail d'analyse (scanner tout un projet, lire des dizaines de fichiers). Sans fork, tout ce travail consomme ta fenêtre de contexte principale. Avec fork, ça se passe en arrière-plan.

$ARGUMENTS

$ARGUMENTS n'est pas une option du frontmatter — c'est un placeholder que tu utilises dans le corps du skill. Quand tu invoques /fix-issue 42, le texte "42" remplace $ARGUMENTS dans les instructions du skill.

---
name: fix-issue
description: "Analyse et corrige un bug à partir de son numéro d'issue GitHub."
disable-model-invocation: true
---

Récupère l'issue GitHub #$ARGUMENTS avec `gh issue view $ARGUMENTS`.
Analyse le problème décrit.
Trouve le code concerné dans le projet.
Propose et applique un correctif.

Tu peux aussi utiliser des arguments positionnels : $ARGUMENTS[0], $ARGUMENTS[1], etc. Si tu tapes /mon-skill valeur1 valeur2, $ARGUMENTS[0] vaut "valeur1" et $ARGUMENTS[1] vaut "valeur2".

Commandes shell avec !

Tu peux inclure des commandes shell dans le frontmatter avec la syntaxe ! suivie de backticks. La commande s'exécute au chargement du skill, et le résultat est injecté dans le contexte avant que Claude Code traite les instructions.

---
name: status
description: "Rapport de statut du projet"
!`git status --short`
!`git log --oneline -5`
---

Analyse le statut git ci-dessus et produis un résumé clair.

Quand tu invoques /status, les commandes git status et git log s'exécutent d'abord, et leurs résultats sont injectés dans le prompt. Le skill peut ensuite analyser ces données.

Les skills bundled de Claude Code

Claude Code est livré avec des skills intégrés que tu peux utiliser directement sans rien configurer.

/simplify — passe en revue ton code pour identifier les opportunités de simplification. Il cherche le code dupliqué, les abstractions inutiles, les fonctions trop longues, et les patterns qui pourraient être consolidés. C'est un refactoring en un mot.

/batch — exécute des changements à grande échelle en parallèle. Tu lui donnes une liste de fichiers et une transformation à appliquer, et il traite tout en même temps via des sous-agents. Pratique pour renommer une variable dans 50 fichiers, mettre à jour un import obsolète partout, ou appliquer un pattern de code à toute une codebase.

/debug — lance un diagnostic de session quand quelque chose ne fonctionne pas. Il analyse les erreurs récentes, les fichiers de logs, les messages du terminal, et propose des pistes de résolution. Au lieu de chercher toi-même pourquoi ton build échoue, tu tapes /debug et Claude Code enquête.

Developer platform skill — celui-ci est un knowledge skill automatique. Quand tu importes le SDK Anthropic dans ton code ou que tu travailles sur une intégration avec l'API Claude, ce skill se déclenche automatiquement. Il charge la documentation de l'API, les bonnes pratiques d'intégration, et les patterns recommandés directement dans le contexte de ta session.

Ces skills bundled sont un bon point de départ pour comprendre la structure et les conventions. Tu peux t'en inspirer pour créer les tiens.

Scopes : global vs projet

Les skills peuvent vivre à trois endroits différents, chacun avec un périmètre différent.

Skills globaux : ~/.claude/skills/

Les skills stockés dans ~/.claude/skills/ (le dossier .claude dans ton répertoire home) sont disponibles dans tous tes projets. Ce sont tes skills personnels — ta boîte à outils universelle. Un /commit que tu utilises partout, un /review avec tes critères de qualité, un /doc qui génère ta documentation dans ton format préféré.

Ces skills ne sont pas versionnés avec un projet. Ils restent sur ta machine. Si tu changes d'ordinateur, tu dois les copier manuellement (ou les versionner dans un repo dédié, comme un dotfiles).

Skills projet : .claude/skills/

Les skills stockés dans .claude/skills/ à la racine de ton projet sont spécifiques à ce projet. L'avantage majeur : ils sont versionnés avec git. Quand un coéquipier clone le repo, il récupère automatiquement tous les skills du projet.

C'est l'endroit idéal pour les skills liés aux conventions du projet : un skill qui connaît ton design system, un skill de déploiement avec les commandes spécifiques à ton infra, un skill de review qui vérifie les règles métier du projet.

Les skills projet surchargent les skills globaux si les noms sont identiques. Un /review dans le projet prend le dessus sur un /review global. Cela te permet d'avoir un comportement par défaut personnalisable projet par projet — le même principe que le fichier CLAUDE.md avec sa hiérarchie de scopes.

Skills de plugins

Les plugins Claude Code peuvent aussi embarquer des skills. Quand tu actives un plugin, ses skills deviennent disponibles dans les projets où le plugin est activé. C'est le mécanisme de distribution pour partager des skills avec la communauté ou au sein d'une organisation.

Fichiers de support

Un dossier de skill peut contenir plus qu'un simple SKILL.md. Tu peux y ajouter des fichiers de support : templates, scripts, exemples. Le skill peut les référencer dans ses instructions.

.claude/
  skills/
    deploy/
      SKILL.md
      checklist.md
      deploy-script.sh

Dans le SKILL.md, tu peux demander à Claude Code de lire checklist.md pour vérifier chaque point, ou d'exécuter deploy-script.sh comme partie du workflow de déploiement.

5 skills à créer immédiatement

Voici 5 skills pratiques que tu peux créer en quelques minutes. Copie les exemples, adapte-les à tes besoins, et commence à les utiliser dès maintenant.

1. /commit — Générer des messages de commit

---
name: commit
description: "Génère un message de commit structuré à partir des changements staged."
disable-model-invocation: true
allowed-tools: Bash(git diff), Bash(git status), Bash(git log), Bash(git add), Bash(git commit)
---

Analyse les changements staged avec `git diff --staged`.
Si rien n'est staged, signale-le et propose de stager les fichiers modifiés.

Génère un message de commit au format Conventional Commits :
- type(scope): description (max 50 chars)
- Body : what + why (pas how), wrap à 72 chars
- Types : feat, fix, refactor, docs, style, test, chore

Montre le message proposé. Attends ma validation avant de commiter.

Ce skill élimine le "qu'est-ce que je mets comme message de commit" qui te fait perdre 2 minutes à chaque commit. Tu tapes /commit, Claude Code analyse les changements, propose un message structuré, et commite après ta validation.

2. /review — Revue de code sécurité + qualité

---
name: review
description: "Revue de code : sécurité, qualité, maintenabilité."
disable-model-invocation: true
allowed-tools: Read, Grep, Glob, Bash(git diff), Bash(git log)
context: fork
---

Analyse les changements récents (staged, unstaged, ou dernier commit).

Vérifie :
- Secrets ou credentials exposés
- Injections (SQL, XSS, command injection)
- Erreurs de logique et edge cases non gérés
- Code dupliqué
- Nommage et lisibilité
- Error handling manquant

Produis un rapport avec un score /10 et des recommandations actionnables.

Note le allowed-tools en lecture seule et le context: fork. Ce skill ne peut rien modifier et s'exécute dans un contexte isolé. Il analyse sans risque. C'est exactement la philosophie qu'on applique aussi aux hooks Claude Code pour la sécurité.

3. /doc — Générer de la documentation

---
name: doc
description: "Génère la documentation JSDoc/TSDoc pour un fichier ou une fonction."
disable-model-invocation: true
---

Analyse le fichier ou la fonction spécifié dans $ARGUMENTS.
Si aucun argument, analyse le fichier actuellement ouvert.

Génère des commentaires de documentation :
- JSDoc pour JavaScript, TSDoc pour TypeScript
- Description claire de ce que fait chaque fonction
- @param avec types et descriptions
- @returns avec type et description
- @throws si applicable
- @example avec un cas d'usage concret

Applique les commentaires directement dans le code.

Usage : /doc src/utils/validation.ts. Claude Code lit le fichier, comprend chaque fonction, et ajoute la documentation inline. 30 secondes au lieu de 15 minutes.

4. /fix-issue — Analyser et corriger un bug GitHub

---
name: fix-issue
description: "Analyse une issue GitHub et propose un correctif."
disable-model-invocation: true
---

Récupère l'issue #$ARGUMENTS avec `gh issue view $ARGUMENTS`.

1. Lis la description et les commentaires de l'issue
2. Identifie le problème décrit
3. Cherche le code concerné dans le projet
4. Analyse la cause racine
5. Propose un correctif avec explication
6. Applique le correctif après ma validation
7. Suggère un message de commit adapté

Usage : /fix-issue 42. Claude Code récupère l'issue, trouve le code, corrige le bug, et prépare le commit. Un workflow complet en une commande. C'est la même logique que la création d'agents custom Claude Code, mais en plus simple et plus rapide à mettre en place.

5. /deploy-check — Checklist de pré-déploiement

---
name: deploy-check
description: "Vérifie que le projet est prêt pour le déploiement."
disable-model-invocation: true
allowed-tools: Read, Grep, Glob, Bash(npm run build), Bash(npm test), Bash(git status)
context: fork
---

Exécute la checklist de pré-déploiement :

1. `git status` — vérifier qu'il n'y a pas de changements non commités
2. `npm test` — vérifier que tous les tests passent
3. `npm run build` — vérifier que le build réussit
4. Chercher des console.log restants dans le code source
5. Vérifier qu'aucun fichier .env n'est tracké par git
6. Chercher des TODO ou FIXME critiques dans le code
7. Vérifier que les dépendances sont à jour (pas de vulnérabilités critiques)

Produis un rapport GO / NO-GO avec les détails de chaque vérification.

Ce skill transforme une checklist manuelle (que tu oublies toujours) en une vérification automatique en 30 secondes. Tu tapes /deploy-check avant chaque déploiement, et tu sais immédiatement si c'est safe.

Ces 5 skills couvrent les actions les plus répétitives du quotidien. Mais la vraie puissance arrive quand tu crées des skills spécifiques à ton métier. Un consultant en IA peut avoir un /audit-workflow qui analyse un workflow N8N. Un développeur web peut avoir un /a11y qui vérifie l'accessibilité. Un formateur peut avoir un /generate-exercise qui crée des exercices à partir d'un cours. Le prompt engineering que tu apprends en créant des skills se transfère directement à toutes tes interactions avec l'IA.

Le réflexe à adopter : chaque fois que tu te surprends à donner les mêmes instructions deux fois, c'est un skill qui attend d'être créé. Le temps d'écriture du skill (5-10 minutes) est amorti dès la troisième utilisation.

Pour aller plus loin, les skills se combinent avec les autres briques de l'écosystème Claude Code. Un skill peut être chargé par un agent custom. Un hook peut déclencher un skill automatiquement. Le fichier CLAUDE.md peut référencer des skills dans ses instructions. C'est tout un écosystème qui s'emboîte.

Si tu débutes avec Claude Code et que tu te demandes comment tout ça s'articule, le guide Claude Code pour entrepreneurs te donne la vue d'ensemble. Les skills sont une pièce du puzzle — une pièce essentielle, mais qui prend tout son sens quand elle est connectée au reste.

Meydeey — Architecte IA & Automatisation

+110 entrepreneurs formés au Vibe Coding et à l'automatisation IA avec N8N. Fondateur du Labo IA.