Guide Débutant : Les Skills dans Claude Code

# Guide Débutant : Les Skills dans Claude Code > **Guide pédagogique pour comprendre et créer vos propres skills Claude Code** > Aucune connaissance technique avancée requise ! --- ## 📚 Table des matières 1. [Qu'est-ce qu'une Skill ?](#1-quest-ce-quune-skill-) 2. [Pourquoi utiliser des Skills ?](#2-pourquoi-utiliser-des-skills-) 3. [Votre première Skill (très simple)](#3-votre-première-skill-très-simple) 4. [Comment fonctionnent les Skills ?](#4-comment-fonctionnent-les-skills-) 5. [Créer des Skills plus avancées](#5-créer-des-skills-plus-avancées) 6. [Exemples pratiques étape par étape](#6-exemples-pratiques-étape-par-étape) 7. [Organisation et bonnes pratiques](#7-organisation-et-bonnes-pratiques) 8. [Dépannage et erreurs courantes](#8-dépannage-et-erreurs-courantes) 9. [Idées de Skills à créer](#9-idées-de-skills-à-créer) --- ## 1. Qu'est-ce qu'une Skill ? ### 🤔 Analogie simple Imaginez que Claude est un assistant personnel très intelligent. Une **skill** est comme une **fiche de consignes** que vous lui donnez pour une tâche spécifique. **Exemple de la vie réelle :** - Vous avez un assistant - Vous lui donnez une fiche : "Procédure pour préparer mon café du matin" - Chaque fois que vous dites "prépare mon café", il suit exactement cette procédure **Avec Claude Code :** - Vous avez Claude - Vous créez une skill : "Procédure pour réviser mon code" - Chaque fois que vous tapez `/reviser-code`, Claude suit cette procédure ### 🎯 Définition simple Une **skill** est : - Un fichier texte (format Markdown) - Contenant des instructions pour Claude - Accessible via une commande slash (ex: `/ma-skill`) - Réutilisable à volonté ### ✨ Ce qu'une Skill PEUT faire - ✅ Donner des instructions détaillées à Claude - ✅ Définir un processus étape par étape - ✅ Spécifier un format de réponse - ✅ Créer des raccourcis pour tâches répétitives - ✅ Appliquer un rôle spécifique à Claude (expert en sécurité, testeur, etc.) ### ❌ Ce qu'une Skill NE PEUT PAS faire - ❌ Exécuter du code directement (c'est Claude qui le fait) - ❌ Modifier les fichiers automatiquement sans Claude - ❌ Remplacer un vrai programme - ❌ Fonctionner sans Claude --- ## 2. Pourquoi utiliser des Skills ? ### 💡 Les avantages #### 1. **Gain de temps** Au lieu de retaper les mêmes instructions à chaque fois : ``` ❌ SANS SKILL (à chaque fois) : "Claude, peux-tu réviser mon code en vérifiant la sécurité, la performance, la lisibilité, et me donner un rapport avec les problèmes trouvés classés par priorité avec des suggestions de correction..." ✅ AVEC SKILL (une seule fois) : /reviser-code ``` #### 2. **Cohérence** Les instructions sont toujours identiques, donc les résultats sont plus prévisibles. #### 3. **Partage** Vous pouvez partager vos skills avec votre équipe ou la communauté. #### 4. **Organisation** Vous construisez votre propre "boîte à outils" personnalisée. ### 🎯 Cas d'usage concrets | Situation | Sans Skill | Avec Skill | |-----------|------------|------------| | Révision de code quotidienne | Retaper les critères à chaque fois | `/reviser-code` | | Génération de tests | Expliquer le format voulu | `/generer-tests` | | Documentation | Décrire la structure attendue | `/documenter` | | Commit Git | Rappeler le format de message | `/commit-message` | --- ## 3. Votre première Skill (très simple) ### 🎬 Tutoriel pas-à-pas pour débutants Nous allons créer une skill qui demande à Claude de vous saluer de manière amicale. #### Étape 1 : Créer le dossier pour les skills **Sur macOS/Linux :** ```bash # Ouvrir le Terminal et taper : mkdir -p ~/.claude/skills ``` **Sur Windows :** ```powershell # Ouvrir PowerShell et taper : New-Item -ItemType Directory -Path "$env:USERPROFILE\.claude\skills" -Force ``` **Explication :** - `mkdir` = créer un dossier - `-p` = créer aussi les dossiers parents si nécessaire - `~/.claude/skills` = emplacement où Claude cherche les skills #### Étape 2 : Créer le dossier de votre skill ```bash mkdir -p ~/.claude/skills/salut ``` **Pourquoi un dossier ?** Chaque skill a son propre dossier. C'est plus organisé et permet d'ajouter d'autres fichiers si besoin. #### Étape 3 : Créer le fichier de la skill Ouvrez votre éditeur de texte préféré (TextEdit, Notepad, VS Code, etc.) et créez un fichier nommé **exactement** : ``` SKILL.md ``` **Emplacement complet :** ``` ~/.claude/skills/salut/SKILL.md ``` #### Étape 4 : Écrire le contenu de la skill Copiez-collez ce texte dans votre fichier `SKILL.md` : ```markdown --- name: salut description: Salue l'utilisateur de manière amicale --- # Skill de salutation Salue l'utilisateur de manière chaleureuse et amicale. ## Instructions 1. Salue l'utilisateur en français 2. Demande comment se passe sa journée 3. Propose ton aide pour la session de travail ## Ton de communication - Chaleureux et amical - Professionnel mais décontracté - Encourageant ``` #### Étape 5 : Sauvegarder le fichier Sauvegardez le fichier **en format texte brut** (pas de format Word ou Rich Text). #### Étape 6 : Tester votre skill 1. Ouvrez Claude Code : ```bash claude ``` 2. Tapez : ```bash /salut ``` 3. Appuyez sur Entrée **Résultat attendu :** Claude devrait vous saluer chaleureusement en suivant les instructions de votre skill ! #### 🎉 Félicitations ! Vous venez de créer votre première skill ! C'était simple, non ? --- ## 4. Comment fonctionnent les Skills ? ### 📖 Anatomie d'une Skill Une skill a deux parties principales : #### Partie 1 : Le Frontmatter (en-tête) ```markdown --- name: nom-de-la-skill description: Description courte --- ``` **Explication :** - Les `---` délimitent l'en-tête - `name` : Le nom de votre commande (utilisé avec `/nom`) - `description` : Aide Claude à décider quand utiliser cette skill automatiquement #### Partie 2 : Le Corps (instructions) ```markdown # Titre de la skill Instructions détaillées pour Claude... ## Section 1 [Instructions...] ## Section 2 [Instructions...] ``` **Explication :** - Écrit en Markdown (format de texte simple avec `#` pour les titres) - Contient toutes les instructions pour Claude - Peut être organisé en sections ### 🗺️ Où mettre vos Skills ? Il existe **deux emplacements** pour vos skills : #### 1. Skills globales (pour tous vos projets) ``` ~/.claude/skills/ ma-skill-1/ SKILL.md ma-skill-2/ SKILL.md ``` **Quand l'utiliser :** - Skills génériques (révision de code, génération de tests, etc.) - Skills que vous voulez réutiliser partout #### 2. Skills de projet (pour un projet spécifique) ``` mon-projet/ .claude/ skills/ skill-specifique/ SKILL.md ``` **Quand l'utiliser :** - Skills spécifiques à un projet - Skills qui dépendent de l'architecture du projet ### 🔍 Comment Claude trouve vos Skills Quand vous tapez `/ma-skill`, Claude cherche dans cet ordre : 1. **Projet local** : `.claude/skills/ma-skill/SKILL.md` 2. **Utilisateur global** : `~/.claude/skills/ma-skill/SKILL.md` 3. **Plugins** : `~/.claude/plugins/*/skills/ma-skill/SKILL.md` **Important :** La première skill trouvée est utilisée (priorité au projet local). --- ## 5. Créer des Skills plus avancées ### 🎨 Structure recommandée pour une Skill complète ```markdown --- name: ma-skill-avancee description: Description précise de ce que fait la skill version: 1.0.0 --- # Titre de la Skill Description générale de ce que fait la skill. ## Ton rôle Tu es un [expert en X, spécialiste de Y, etc.]. ## Contexte [Informations de contexte importantes] ## Processus 1. **Étape 1 :** [Description] - Sous-action A - Sous-action B 2. **Étape 2 :** [Description] - Sous-action A - Sous-action B 3. **Étape 3 :** [Description] ## Règles importantes - ⚠️ Règle critique 1 - ⚠️ Règle critique 2 - ✅ Règle positive 1 ## Format de sortie [Description précise du format attendu] ### Exemple de sortie [Exemple concret de ce que tu attends] ## Cas particuliers ### Cas A [Comment gérer le cas A] ### Cas B [Comment gérer le cas B] ## Critères de qualité - [ ] Critère 1 - [ ] Critère 2 - [ ] Critère 3 ``` ### 📝 Éléments optionnels dans le Frontmatter ```markdown --- name: ma-skill # Obligatoire description: Description # Recommandé version: 1.0.0 # Optionnel (pour suivre les versions) author: Votre Nom # Optionnel tags: [python, testing, backend] # Optionnel (pour organisation) --- ``` --- ## 6. Exemples pratiques étape par étape ### 📘 Exemple 1 : Skill de révision de code #### Objectif Créer une skill qui révise votre code en vérifiant la sécurité, la qualité et les performances. #### Étape par étape **1. Créer le dossier :** ```bash mkdir -p ~/.claude/skills/reviser-code ``` **2. Créer le fichier `SKILL.md` :** ```bash # Sur macOS/Linux touch ~/.claude/skills/reviser-code/SKILL.md # Sur Windows New-Item ~/.claude/skills/reviser-code/SKILL.md ``` **3. Remplir le contenu :** ```markdown --- name: reviser-code description: Effectue une révision complète du code (sécurité, qualité, performance) version: 1.0.0 --- # Révision de Code Complète Tu es un expert en révision de code avec 10+ ans d'expérience. ## Ton rôle Analyser le code fourni et identifier tous les problèmes potentiels dans ces catégories : - Sécurité - Performance - Qualité du code - Maintenabilité ## Processus de révision ### 1. Lecture initiale - Lis tout le code fourni - Comprends l'intention et le contexte - Identifie les patterns utilisés ### 2. Analyse de sécurité Vérifie : - ❌ Injections SQL - ❌ XSS (Cross-Site Scripting) - ❌ CSRF (Cross-Site Request Forgery) - ❌ Exposition de données sensibles - ❌ Authentification/Autorisation faibles - ❌ Utilisation de dépendances vulnérables ### 3. Analyse de performance Vérifie : - 🐌 Boucles inefficaces - 🐌 Requêtes N+1 - 🐌 Chargements inutiles en mémoire - 🐌 Calculs redondants - 🐌 Manque de cache ### 4. Analyse de qualité Vérifie : - 📖 Lisibilité du code - 📖 Noms de variables/fonctions clairs - 📖 Commentaires appropriés - 📖 Respect des conventions - 📖 Code dupliqué - 📖 Fonctions trop longues/complexes ### 5. Analyse de maintenabilité Vérifie : - 🔧 Architecture et structure - 🔧 Couplage entre composants - 🔧 Gestion des erreurs - 🔧 Tests manquants - 🔧 Documentation manquante ## Format de sortie Pour chaque problème identifié, utilise ce format : ### [Catégorie] Problème #N **🔴 Sévérité :** Critique / Haute / Moyenne / Basse **📍 Localisation :** - Fichier : `nom-fichier.ext` - Ligne(s) : 42-45 **🔍 Description :** [Explication claire du problème] **💡 Recommandation :** [Solution proposée avec exemple de code si pertinent] **📚 Ressources :** [Liens utiles si applicable] --- ## Résumé final À la fin de ta révision, fournis : ### Statistiques - 🔴 Problèmes critiques : X - 🟠 Problèmes de haute sévérité : X - 🟡 Problèmes de sévérité moyenne : X - 🟢 Problèmes de basse sévérité : X ### Points positifs - ✅ [Aspect bien fait 1] - ✅ [Aspect bien fait 2] - ✅ [Aspect bien fait 3] ### Priorités d'action 1. [Action prioritaire 1] 2. [Action prioritaire 2] 3. [Action prioritaire 3] ### Note globale [Note de 0 à 10 avec justification] ## Règles importantes - ⚠️ Sois constructif, pas juste critique - ⚠️ Fournis toujours des solutions, pas juste des problèmes - ⚠️ Priorise les problèmes de sécurité - ⚠️ Reste factuel et objectif ``` **4. Tester la skill :** ```bash claude ``` Puis : ``` /reviser-code [Collez votre code ou référencez un fichier] ``` --- ### 📗 Exemple 2 : Skill de génération de tests #### Objectif Créer une skill qui génère des tests unitaires complets pour votre code. #### Contenu de la skill ```markdown --- name: generer-tests description: Génère des tests unitaires complets avec cas nominaux, limites et d'erreur version: 1.0.0 --- # Générateur de Tests Unitaires Tu es un expert en testing avec une expertise en TDD (Test-Driven Development). ## Ton rôle Générer des tests unitaires complets, robustes et maintenables pour le code fourni. ## Analyse préliminaire Avant de générer les tests, analyse : 1. **Langage et framework** - Identifie le langage de programmation - Détecte le framework de test à utiliser (Jest, pytest, JUnit, etc.) 2. **Code à tester** - Fonctions/méthodes publiques - Entrées possibles - Sorties attendues - Cas limites (edge cases) - Erreurs possibles ## Types de tests à générer ### 1. Tests des cas nominaux Tests des scénarios standards et attendus. **Exemple :** ```javascript test('addition de deux nombres positifs', () => { expect(add(2, 3)).toBe(5); }); ``` ### 2. Tests des cas limites (edge cases) Tests des valeurs extrêmes ou inhabituelles. **Exemples de cas limites :** - Valeurs nulles (`null`, `undefined`) - Valeurs vides (chaînes vides, tableaux vides, objets vides) - Très grandes valeurs - Très petites valeurs - Valeurs négatives - Zéro **Exemple :** ```javascript test('addition avec zéro', () => { expect(add(5, 0)).toBe(5); }); test('addition avec nombres négatifs', () => { expect(add(-2, -3)).toBe(-5); }); ``` ### 3. Tests d'erreur Tests qui vérifient que les erreurs sont bien gérées. **Exemple :** ```javascript test('erreur si argument non numérique', () => { expect(() => add('a', 2)).toThrow('Arguments must be numbers'); }); ``` ## Structure des tests Utilise le pattern **AAA** (Arrange-Act-Assert) : ```javascript test('description claire du test', () => { // Arrange (Préparer) const input = ...; const expected = ...; // Act (Agir) const result = functionToTest(input); // Assert (Vérifier) expect(result).toBe(expected); }); ``` ## Règles de qualité ### Noms de tests ✅ **BON :** ```javascript test('retourne true quand l\'utilisateur est authentifié') test('lève une erreur si l\'email est invalide') ``` ❌ **MAUVAIS :** ```javascript test('test1') test('ça marche') ``` ### Organisation ```javascript describe('NomDeLaFonction', () => { describe('cas nominaux', () => { test('scénario 1', () => { ... }); test('scénario 2', () => { ... }); }); describe('cas limites', () => { test('avec valeur nulle', () => { ... }); test('avec tableau vide', () => { ... }); }); describe('gestion d\'erreurs', () => { test('erreur si paramètre invalide', () => { ... }); }); }); ``` ### Isolation des tests - ⚠️ Chaque test doit être indépendant - ⚠️ Utilise des mocks/stubs pour les dépendances externes - ⚠️ Nettoie après chaque test si nécessaire ## Couverture de code Vise une couverture de **80% minimum** : - Toutes les fonctions publiques testées - Tous les chemins d'exécution importants - Tous les cas d'erreur principaux ## Format de sortie ### 1. En-tête ```javascript /** * Tests pour [NomDuFichier] * * Couverture : * - X tests de cas nominaux * - Y tests de cas limites * - Z tests de gestion d'erreur */ ``` ### 2. Imports ```javascript import { functionToTest } from './source-file'; import { jest } from '@jest/globals'; // Si nécessaire pour mocks ``` ### 3. Corps des tests [Tests organisés comme décrit ci-dessus] ### 4. Commentaires explicatifs Ajoute des commentaires pour les tests complexes : ```javascript test('cas complexe nécessitant explication', () => { // Ce test vérifie que... parce que... // Arrange ... }); ``` ## Frameworks supportés Adapte la syntaxe selon le framework détecté : - **JavaScript/TypeScript :** Jest, Mocha, Jasmine - **Python :** pytest, unittest - **Java :** JUnit, TestNG - **C# :** NUnit, xUnit - **Go :** testing package - **Ruby :** RSpec, Minitest ## Exemple complet de sortie Pour une fonction simple : ```javascript // Source: calculator.js export function add(a, b) { if (typeof a !== 'number' || typeof b !== 'number') { throw new Error('Arguments must be numbers'); } return a + b; } ``` Tu génères : ```javascript /** * Tests pour calculator.js * * Couverture : * - 3 tests de cas nominaux * - 4 tests de cas limites * - 2 tests de gestion d'erreur */ import { add } from './calculator'; describe('add', () => { describe('cas nominaux', () => { test('additionne deux nombres positifs', () => { expect(add(2, 3)).toBe(5); }); test('additionne deux nombres négatifs', () => { expect(add(-2, -3)).toBe(-5); }); test('additionne un nombre positif et un négatif', () => { expect(add(5, -3)).toBe(2); }); }); describe('cas limites', () => { test('additionne avec zéro', () => { expect(add(0, 5)).toBe(5); expect(add(5, 0)).toBe(5); }); test('additionne deux zéros', () => { expect(add(0, 0)).toBe(0); }); test('gère les grands nombres', () => { expect(add(1000000, 2000000)).toBe(3000000); }); test('gère les nombres décimaux', () => { expect(add(0.1, 0.2)).toBeCloseTo(0.3); }); }); describe('gestion d\'erreurs', () => { test('lève une erreur si le premier argument n\'est pas un nombre', () => { expect(() => add('a', 2)).toThrow('Arguments must be numbers'); }); test('lève une erreur si le second argument n\'est pas un nombre', () => { expect(() => add(2, 'b')).toThrow('Arguments must be numbers'); }); }); }); ``` ## Instructions finales 1. Génère les tests dans un fichier séparé avec le nom approprié : - `calculator.js` → `calculator.test.js` - `utils.py` → `test_utils.py` - `Service.java` → `ServiceTest.java` 2. Assure-toi que les tests sont exécutables immédiatement 3. Explique brièvement les choix de test importants 4. Suggère des tests additionnels si pertinent ``` --- ### 📙 Exemple 3 : Skill interactive avec questions #### Objectif Créer une skill qui pose des questions avant d'agir. #### Contenu de la skill ```markdown --- name: creer-feature description: Guide pour créer une nouvelle fonctionnalité avec questions interactives version: 1.0.0 --- # Assistant de Création de Fonctionnalité Tu es un guide qui aide à créer de nouvelles fonctionnalités de manière structurée. ## Processus interactif ### Étape 1 : Questionnaire initial Avant de commencer, pose ces questions à l'utilisateur : #### Question 1 : Type de fonctionnalité ``` Quel type de fonctionnalité veux-tu créer ? a) API endpoint (backend) b) Composant UI (frontend) c) Service/Utilitaire d) Feature complète (frontend + backend) ``` #### Question 2 : Complexité ``` Quelle est la complexité estimée ? a) Simple (quelques heures) b) Moyenne (1-2 jours) c) Complexe (plusieurs jours) ``` #### Question 3 : Priorité ``` Quelle est la priorité ? a) Critique (bloquer) b) Haute c) Moyenne d) Basse ``` #### Question 4 : Tests requis ``` Quels tests sont nécessaires ? a) Tests unitaires seulement b) Tests d'intégration seulement c) Tests unitaires + intégration d) Tests E2E complets ``` ### Étape 2 : Analyse et planification Basé sur les réponses : 1. **Analyse les fichiers existants** - Identifie où placer le nouveau code - Vérifie les patterns existants à suivre 2. **Crée un plan détaillé** ``` ## Plan d'implémentation ### Fichiers à créer - [ ] fichier1.ext - Description - [ ] fichier2.ext - Description ### Fichiers à modifier - [ ] fichier3.ext - Modifications à apporter ### Dépendances nécessaires - [ ] dépendance1 - [ ] dépendance2 ### Étapes d'implémentation 1. Étape 1 2. Étape 2 3. Étape 3 ### Tests à créer - [ ] test1 - [ ] test2 ``` 3. **Demande confirmation** ``` Ce plan te convient-il ? - Si oui, je commence l'implémentation - Si non, dis-moi ce qu'il faut ajuster ``` ### Étape 3 : Implémentation Une fois le plan approuvé : 1. Crée les fichiers dans l'ordre logique 2. Implémente le code en suivant les patterns existants 3. Ajoute les tests au fur et à mesure 4. Documente le code ### Étape 4 : Vérification finale Avant de terminer : 1. **Checklist de qualité** - [ ] Code écrit et testé - [ ] Tests créés et qui passent - [ ] Documentation ajoutée - [ ] Pas de code dupliqué - [ ] Conventions respectées - [ ] Gestion d'erreur appropriée 2. **Proposer les prochaines étapes** - Tests manuels à faire - Documentation à mettre à jour - Revue de code recommandée ## Ton de communication - 🎯 Guidant et structuré - ❓ Pose des questions clarifiantes - 📋 Fournis des checklists - ✅ Confirme chaque étape majeure ``` --- ## 7. Organisation et bonnes pratiques ### 📁 Structure recommandée #### Pour vos skills globales ``` ~/.claude/ skills/ # Skills générales reviser-code/ SKILL.md exemples/ # Dossier optionnel pour exemples exemple1.md exemple2.md generer-tests/ SKILL.md documenter/ SKILL.md # Organisation par catégorie (optionnel) backend/ api-review/ SKILL.md database-query/ SKILL.md frontend/ component-review/ SKILL.md accessibility-check/ SKILL.md ``` #### Pour les skills de projet ``` mon-projet/ .claude/ skills/ # Skills spécifiques au projet deploy-prod/ SKILL.md run-integration-tests/ SKILL.md ``` ### ✅ Bonnes pratiques de nommage #### Noms de skills ``` ✅ BON : reviser-code generer-tests documenter-api creer-component ❌ MAUVAIS : rc test doc cc ``` **Règles :** - Utiliser des tirets (`-`) pas des underscores (`_`) - Noms descriptifs et clairs - En minuscules - Verbes d'action (réviser, générer, créer, etc.) #### Noms de fichiers ``` ✅ Correct : SKILL.md # Obligatoire, en majuscules README.md # Optionnel, documentation de la skill exemples.md # Optionnel ❌ Incorrect : skill.md Skill.md SKILL.txt ``` ### 📝 Bonnes pratiques de rédaction #### 1. Instructions claires et précises ```markdown ✅ BON : ## Processus 1. Lis tous les fichiers fournis 2. Identifie les vulnérabilités selon OWASP Top 10 3. Classe chaque problème par sévérité (Critique/Haute/Moyenne/Basse) 4. Fournis une solution pour chaque problème ❌ VAGUE : ## Processus - Regarde le code - Trouve les problèmes - Dis ce qui ne va pas ``` #### 2. Exemples concrets ```markdown ✅ BON : ## Format de sortie ### Exemple : **🔴 Sévérité :** Critique **📍 Fichier :** auth.js:42 **🔍 Problème :** Injection SQL possible **💡 Solution :** Utiliser des requêtes paramétrées ❌ SANS EXEMPLE : ## Format de sortie Fournis un rapport avec les problèmes trouvés. ``` #### 3. Ton approprié ```markdown ✅ BON : Tu es un expert en sécurité. Sois rigoureux dans ton analyse. ❌ TROP CASUAL : Yo ! Checke le code et dis-moi si c'est clean ou pas ``` ### 🔄 Versioning de vos skills ```markdown --- name: ma-skill description: Description version: 1.0.0 # Majeur.Mineur.Patch changelog: | 1.0.0 - 2026-02-04: Version initiale 1.1.0 - 2026-02-10: Ajout de la vérification de performance 1.1.1 - 2026-02-11: Correction du format de sortie --- ``` **Convention de versioning :** - **Majeur (1.0.0)** : Changements incompatibles - **Mineur (1.1.0)** : Nouvelles fonctionnalités compatibles - **Patch (1.1.1)** : Corrections de bugs ### 📚 Documenter vos skills Créez un fichier `README.md` dans le dossier de chaque skill : ```markdown # Skill : Révision de Code ## Description Cette skill effectue une révision complète du code en vérifiant la sécurité, la performance, la qualité et la maintenabilité. ## Usage ```bash /reviser-code ``` Puis fournir le code à réviser soit : - En collant le code - En référençant un fichier avec `@./chemin` ## Exemples ### Exemple 1 : Réviser un fichier ``` /reviser-code @./src/auth.js ``` ### Exemple 2 : Réviser un extrait ``` /reviser-code [Collez votre code ici] ``` ## Format de sortie La skill génère un rapport structuré avec : - Problèmes de sécurité - Problèmes de performance - Problèmes de qualité - Recommandations d'action ## Personnalisation Vous pouvez modifier les critères de révision dans le fichier `SKILL.md`. ## Version 1.0.0 ## Auteur Votre Nom ## License MIT ``` --- ## 8. Dépannage et erreurs courantes ### ❌ Problème 1 : Ma skill n'apparaît pas dans `/help` **Causes possibles :** 1. **Le fichier n'est pas nommé `SKILL.md`** ``` ❌ skill.md ❌ Skill.md ❌ SKILL.txt ✅ SKILL.md ``` 2. **Le dossier n'est pas au bon endroit** ``` ✅ ~/.claude/skills/ma-skill/SKILL.md ✅ .claude/skills/ma-skill/SKILL.md ❌ ~/claude/skills/ma-skill/SKILL.md (manque le point) ❌ ~/.claude/ma-skill/SKILL.md (manque /skills/) ``` 3. **Le frontmatter est mal formaté** ```markdown ❌ MAUVAIS : -- name: ma-skill -- ✅ CORRECT : --- name: ma-skill --- ``` **Solution :** ```bash # Vérifier l'emplacement ls -la ~/.claude/skills/ma-skill/SKILL.md # Si le fichier n'existe pas, le créer mkdir -p ~/.claude/skills/ma-skill touch ~/.claude/skills/ma-skill/SKILL.md ``` ### ❌ Problème 2 : Claude ne suit pas mes instructions **Causes possibles :** 1. **Instructions trop vagues** ```markdown ❌ Vague : Révise le code ✅ Précis : Révise le code en suivant ces étapes : 1. Vérifie les vulnérabilités OWASP Top 10 2. Identifie les problèmes de performance 3. Fournis des solutions avec exemples de code ``` 2. **Manque de structure** ```markdown ❌ Sans structure : Fais une révision complète vérifie tout donne un rapport ✅ Avec structure : ## Processus 1. Étape 1 2. Étape 2 ## Format de sortie [Format détaillé] ``` 3. **Instructions contradictoires** ```markdown ❌ Contradictoire : Sois très détaillé mais reste concis ✅ Clair : Fournis un rapport détaillé avec un résumé concis en fin ``` **Solution :** - Relire la skill et la rendre plus précise - Ajouter des exemples concrets - Tester avec des cas simples d'abord ### ❌ Problème 3 : La skill fonctionne différemment selon les fois **Cause :** Les LLMs comme Claude ont une certaine variabilité naturelle. **Solutions :** 1. **Rendre les instructions plus contraignantes** ```markdown ❌ Flexible : Fournis un rapport ✅ Contraint : Fournis EXACTEMENT ce format : ### Problème #1 **Sévérité :** [Critique/Haute/Moyenne/Basse] **Fichier :** [nom:ligne] **Description :** [texte] **Solution :** [texte] ``` 2. **Utiliser des checklists** ```markdown À la fin, vérifie que tu as bien : - [ ] Analysé tous les fichiers - [ ] Fourni au moins 3 recommandations - [ ] Inclus des exemples de code ``` 3. **Demander validation** ```markdown Avant de répondre, assure-toi que : 1. Tu as suivi toutes les étapes 2. Le format est correct 3. Tous les critères sont vérifiés ``` ### ❌ Problème 4 : Erreur "Skill not found" **Vérifications :** ```bash # 1. Vérifier que le dossier existe ls -la ~/.claude/skills/ # 2. Vérifier que votre skill existe ls -la ~/.claude/skills/ma-skill/ # 3. Vérifier le contenu du fichier cat ~/.claude/skills/ma-skill/SKILL.md # 4. Vérifier les permissions chmod 644 ~/.claude/skills/ma-skill/SKILL.md ``` ### ❌ Problème 5 : La skill est trop lente **Causes :** - Instructions trop complexes - Trop d'étapes - Trop de contexte à analyser **Solutions :** 1. **Simplifier la skill** - Diviser en plusieurs skills plus petites - Réduire le nombre d'étapes 2. **Utiliser le bon modèle** - Haiku pour skills simples et rapides - Sonnet pour usage général - Opus pour skills complexes 3. **Optimiser les instructions** ```markdown ❌ Lent : Lis tous les fichiers du projet, analyse chaque ligne, compare avec 50 patterns différents, génère un rapport ultra-détaillé... ✅ Plus rapide : Analyse le fichier fourni pour les 3 problèmes principaux : 1. Sécurité critique 2. Bugs évidents 3. Performance majeure ``` --- ## 9. Idées de Skills à créer ### 💼 Skills professionnelles #### Développement - `/reviser-pull-request` - Révise une PR complète - `/generer-changelog` - Génère un changelog depuis les commits - `/optimiser-performance` - Analyse et optimise les performances - `/refactoriser` - Propose un refactoring structuré - `/detecter-code-mort` - Identifie le code inutilisé #### Documentation - `/generer-readme` - Crée un README complet - `/documenter-api` - Génère la doc d'une API (OpenAPI/Swagger) - `/expliquer-code` - Explique du code complexe - `/generer-jsdoc` - Ajoute des commentaires JSDoc - `/creer-guide-contribution` - Crée CONTRIBUTING.md #### Tests - `/generer-tests-e2e` - Crée des tests end-to-end - `/calculer-couverture` - Analyse la couverture de tests - `/generer-mocks` - Crée des mocks pour tests - `/tests-performance` - Génère des tests de performance #### DevOps - `/creer-dockerfile` - Génère un Dockerfile optimisé - `/configurer-ci` - Crée un pipeline CI/CD - `/generer-helm-chart` - Crée des charts Helm - `/optimiser-build` - Optimise le temps de build ### 🎨 Skills créatives #### Frontend - `/creer-component` - Scaffold un nouveau composant - `/optimiser-css` - Optimise et organise le CSS - `/generer-theme` - Crée un système de thème - `/audit-accessibilite` - Vérifie l'accessibilité (a11y) #### Backend - `/creer-endpoint` - Crée un nouvel endpoint API - `/generer-migration` - Génère une migration de BDD - `/optimiser-requetes` - Optimise les requêtes SQL - `/creer-middleware` - Crée un middleware ### 🛠️ Skills utilitaires #### Organisation - `/creer-todo` - Extrait des TODOs du code - `/generer-rapport` - Crée un rapport de projet - `/analyser-dependencies` - Analyse les dépendances - `/detecter-vulnerabilities` - Scan de sécurité #### Conversion - `/convertir-format` - Convertit entre formats (JSON/YAML/etc.) - `/migrer-code` - Aide à migrer vers nouvelle version - `/traduire-code` - Traduit d'un langage à un autre - `/moderniser` - Modernise du code legacy ### 🎓 Skills d'apprentissage #### Tutoriels - `/expliquer-concept` - Explique un concept technique - `/generer-exercice` - Crée des exercices pratiques - `/corriger-exercice` - Corrige et explique - `/creer-quiz` - Génère un quiz sur un sujet #### Code reviews pédagogiques - `/revue-debutant` - Revue adaptée aux débutants - `/expliquer-erreurs` - Explique les erreurs courantes - `/bonnes-pratiques` - Enseigne les bonnes pratiques - `/anti-patterns` - Identifie et explique les anti-patterns ### 🎯 Skills par langage #### JavaScript/TypeScript - `/migration-typescript` - Migre JS vers TS - `/optimiser-react` - Optimise composants React - `/moderniser-js` - Modernise JS (ES6+) #### Python - `/pythoniser` - Rend le code plus pythonique - `/typer-python` - Ajoute type hints - `/optimiser-pandas` - Optimise code pandas #### Java - `/moderniser-java` - Migre vers Java moderne - `/pattern-java` - Applique design patterns - `/spring-boot` - Crée du code Spring Boot --- ## 🎓 Exercices pratiques ### Exercice 1 : Skill simple (débutant) **Objectif :** Créer une skill qui génère des messages de commit Git selon Conventional Commits. **À faire :** 1. Créer le dossier `~/.claude/skills/commit-message/` 2. Créer `SKILL.md` avec les instructions pour générer des commits : - Format : `type(scope): description` - Types : feat, fix, docs, style, refactor, test, chore - Limite de 50 caractères pour le titre 3. Tester avec `/commit-message` **Solution :** ```markdown --- name: commit-message description: Génère des messages de commit selon Conventional Commits --- # Générateur de messages de commit Génère des messages de commit suivant la convention Conventional Commits. ## Format ``` type(scope): description courte Corps du message (optionnel) ``` ## Types disponibles - `feat`: Nouvelle fonctionnalité - `fix`: Correction de bug - `docs`: Documentation - `style`: Formatage, sans changement de code - `refactor`: Refactoring - `test`: Ajout/modification de tests - `chore`: Maintenance, dépendances ## Règles 1. Titre max 50 caractères 2. Impératif présent ("ajoute" pas "ajouté") 3. Pas de point final au titre 4. Corps optionnel pour plus de détails ## Processus 1. Demande quels fichiers ont été modifiés 2. Demande la nature des changements 3. Génère 3 options de messages 4. Laisse l'utilisateur choisir ``` ### Exercice 2 : Skill interactive (intermédiaire) **Objectif :** Créer une skill qui aide à débugger du code en posant des questions. **À faire :** 1. Créer une skill `/debug-helper` 2. La skill doit poser des questions : - Quel est le problème observé ? - Quel est le comportement attendu ? - Quelles sont les étapes pour reproduire ? 3. Puis analyser et proposer des solutions ### Exercice 3 : Skill complexe (avancé) **Objectif :** Créer une skill d'audit de sécurité complète. **À faire :** 1. Créer `/audit-securite` 2. Vérifier OWASP Top 10 3. Générer un rapport HTML 4. Inclure des scores et métriques 5. Proposer un plan d'action priorisé --- ## 📚 Ressources et références ### Documentation officielle - [Claude Code Docs](https://code.claude.com/docs) - [Guide des Skills](https://code.claude.com/docs/en/slash-commands) ### Collections communautaires - [awesome-claude-code](https://github.com/hesreallyhim/awesome-claude-code) - [claude-code-skills](https://github.com/wshobson/commands) - [everything-claude-code](https://github.com/affaan-m/everything-claude-code) ### Inspiration Consultez ces repos pour des exemples de skills : - Révision de code - Génération de tests - Documentation automatique - Analyse de sécurité --- ## 🎯 Checklist finale Avant de considérer votre skill terminée : - [ ] Le nom est descriptif et suit les conventions - [ ] Le fichier est nommé `SKILL.md` (majuscules) - [ ] Le frontmatter est correct avec `name` et `description` - [ ] Les instructions sont claires et précises - [ ] Des exemples sont fournis - [ ] Le format de sortie est spécifié - [ ] La skill a été testée plusieurs fois - [ ] Un README.md documente la skill - [ ] La skill est versionnée --- ## 🎉 Conclusion Vous savez maintenant : - ✅ Ce qu'est une skill et pourquoi l'utiliser - ✅ Comment créer des skills simples et avancées - ✅ Comment organiser vos skills - ✅ Comment résoudre les problèmes courants - ✅ Plein d'idées de skills à créer **Prochaines étapes :** 1. Créez votre première skill simple 2. Testez-la plusieurs fois 3. Améliorez-la progressivement 4. Créez d'autres skills pour vos besoins 5. Partagez vos meilleures skills avec la communauté ! **Bonne création de skills ! 🚀** --- *Guide créé le 4 février 2026* *Pour le guide complet de Claude Code : `~/CLAUDE_STOCK/GUIDE_COMPLET.md`*

Syntax	Example	Reference
# Header	Header	基本排版
- Unordered List	Unordered List
1. Ordered List	Ordered List
- [ ] Todo List	Todo List
> Blockquote	Blockquote
Bold font	Bold font
Italics font	Italics font
~~Strikethrough~~	~~Strikethrough~~
19^th^	19^th
H~2~O	H₂O
++Inserted text++	Inserted text
==Marked text==	Marked text
[link text](https:// "title")	Link
![image alt](https:// "title")	Image
`Code`	`Code`	在筆記中貼入程式碼
```javascript var i = 0; ```	`var i = 0;`
:smile:		Emoji list
{%youtube youtube_id %}	Externals
$L^aT_eX$	L^aT_eX
:::info This is a alert area. :::	This is a alert area.