---
# System prepended metadata

title: '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`*