Créer des Skills pour Claude : le guide complet de

Que sont les Claude Skills ?

Les Claude Skills sont des packages modulaires et autonomes qui améliorent les capacités de Claude en fournissant des connaissances spécialisées, des workflows et des scripts exécutables. Publiés le 29 janvier 2026 dans un guide complet de 32 pages par Anthropic, les Skills transforment Claude d'un assistant polyvalent en un agent spécialisé doté de connaissances procédurales.

Avant vs. après les Skills

Avant les Skills (approche traditionnelle) :

Prompt système : "Tu es un assistant qui aide à la rédaction de marque.
Utilise toujours notre voix de marque : professionnelle mais accessible...
[500 lignes de directives de marque]
[200 lignes de règles de formatage]
[300 lignes d'exemples]"

Problèmes : lourd en tokens, chargé pour chaque conversation, difficile à maintenir, risque de conflits.

Après les Skills :

📁 brand-writing/
├── SKILL.md          → "Appliquer les directives de marque à tout document"
├── scripts/
│   └── check_tone.py → Vérificateur automatique de la voix de marque
└── references/
    ├── brand_guide.md
    └── examples.md

Avantages : chargé uniquement en cas de besoin, organisé, testable, partageable, maintenable.

Le changement de paradigme : des prompts aux procédures

Les Skills représentent un changement fondamental dans notre approche de la personnalisation de l'IA :

Architecture d'un Skill

La structure de dossier

Chaque skill suit le même schéma d'organisation :

📁 my-skill/
├── SKILL.md              ← Requis : instructions principales + métadonnées
├── scripts/              ← Optionnel : code exécutable
│   ├── process_data.py
│   └── validate.sh
├── references/           ← Optionnel : docs chargés à la demande
│   ├── api_docs.md
│   └── style_guide.md
├── templates/            ← Optionnel : modèles de sortie
│   └── report_template.md
└── assets/               ← Optionnel : icônes, images, etc.
    └── icon.png

Le fichier SKILL.md

Le fichier SKILL.md est le cœur de chaque skill. Il utilise un frontmatter YAML pour les métadonnées et du Markdown pour les instructions :

---
name: Brand Voice Checker
description: |
  Apply our brand voice guidelines to any document.
  Use this skill when the user asks to review, write, or edit
  content for brand consistency.
---

# Brand Voice Checker

## Instructions

When the user provides content for brand review:

1. Read the document carefully
2. Run `scripts/check_tone.py` on the content
3. Load `references/brand_guide.md` for current guidelines
4. Identify any deviations from brand voice
5. Provide specific corrections with before/after examples
6. Summarize the overall brand alignment score

## Rules

- Never change the core message or meaning
- Preserve technical accuracy
- Flag ambiguous cases rather than auto-correcting
- Always explain WHY a change improves brand alignment

Détail des composants

Principes fondamentaux

1. Divulgation progressive

Comment ça fonctionne :

1. →Claude scanne les descriptions des skills (frontmatter YAML) pour trouver les skills pertinents
2. →Quand l'intention de l'utilisateur correspond à une description de skill, le SKILL.md complet est chargé
3. →Pendant l'exécution, les références ne sont chargées que lorsqu'explicitement nécessaires
4. →Les scripts ne s'exécutent que lorsqu'ils sont appelés

Cela signifie qu'un projet avec 20 skills ne gaspille pas de tokens en chargeant les 20 — seul(s) le(s) skill(s) pertinent(s) s'activent.

2. Modularité et composabilité

Les Skills sont conçus pour fonctionner ensemble :

Utilisateur : "Crée un rapport trimestriel pour le T4 avec le formatage
              de marque et envoie-le à l'équipe de direction"

Claude active :
  1. 📊 skill data-analysis     → Récupère et analyse les métriques du T4
  2. 📝 skill brand-writing     → Applique la voix de marque
  3. 📄 skill report-template   → Formate en rapport trimestriel
  4. ✉️ skill email-composer    → Rédige l'email pour la direction

Claude identifie et séquence automatiquement les skills nécessaires, coordonnant leur exécution.

3. Déterminisme par les scripts

Les Skills peuvent inclure des scripts exécutables pour les tâches qui nécessitent une fiabilité à 100 % :

# scripts/format_currency.py
"""Format numbers as USD currency strings."""
import sys

def format_currency(amount):
    """Returns a properly formatted USD string."""
    return f"${amount:,.2f}"

if __name__ == "__main__":
    amount = float(sys.argv[1])
    print(format_currency(amount))

Au lieu que Claude « devine » le format, le script fournit une sortie déterministe et fiable.

4. Portabilité

Le même skill fonctionne dans tous les environnements Claude :

• →Claude.ai — Ajoutez le dossier skill à un Project
• →Claude Code — Placez-le dans le répertoire .claude/skills/
• →API Anthropic — Référencez-le dans le message système

Créer votre premier Skill

Étape 1 : Définir le cas d'usage

Avant d'écrire du code, répondez à ces questions :

• →Quelle tâche spécifique ce skill effectue-t-il ?
• →Quand Claude doit-il l'activer ? (conditions de déclenchement)
• →Quelles entrées sont nécessaires de la part de l'utilisateur ?
• →Quelles sorties doit-il produire ?
• →Y a-t-il des étapes déterministes qui devraient utiliser des scripts ?

Étape 2 : Créer la structure de dossiers

mkdir -p meeting-summarizer/scripts meeting-summarizer/references

Étape 3 : Écrire le SKILL.md

---
name: Meeting Summarizer
description: |
  Summarize meeting transcripts into structured action items,
  decisions, and follow-ups. Use when the user provides a
  meeting transcript, recording summary, or meeting notes.
---

# Meeting Summarizer

## Process

1. **Parse the transcript** — Identify speakers, timestamps, topics
2. Run `scripts/extract_topics.py` to identify main discussion areas
3. For each topic, extract:
   - Key points discussed
   - Decisions made (with who made them)
   - Action items (with owners and deadlines)
   - Open questions
4. Format output using the template in `references/summary_template.md`
5. Highlight any action items without clear owners

## Output Format

Always produce:
- Executive summary (2-3 sentences)
- Decisions list (numbered)
- Action items table (who / what / when)
- Open questions list
- Next meeting suggestions

## Constraints

- Never invent information not in the transcript
- Flag unclear speaker attribution
- If deadlines are mentioned ambiguously, note the ambiguity

Étape 4 : Ajouter des scripts (optionnel)

# scripts/extract_topics.py
"""Extract main topics from a meeting transcript."""
import sys
import re

def extract_topics(transcript):
    """Identify topic transitions in meeting text."""
    # Simple topic detection by paragraph breaks and keywords
    topics = []
    paragraphs = transcript.split('\n\n')
    for p in paragraphs:
        if any(keyword in p.lower() for keyword in
               ['next topic', 'moving on', 'let\'s discuss',
                'agenda item', 'regarding']):
            topics.append(p.strip()[:100])
    return topics

if __name__ == "__main__":
    transcript = sys.stdin.read()
    topics = extract_topics(transcript)
    for i, topic in enumerate(topics, 1):
        print(f"{i}. {topic}")

Étape 5 : Ajouter des références (optionnel)

<!-- references/summary_template.md -->

# Meeting Summary: [TITLE]
**Date:** [DATE] | **Duration:** [DURATION] | **Attendees:** [LIST]

## Executive Summary
[2-3 sentence overview]

## Decisions Made
1. [Decision] — Decided by [WHO]

## Action Items
| Owner | Task | Deadline | Status |
|-------|------|----------|--------|
| [Name] | [Task description] | [Date] | Pending |

## Open Questions
- [Question requiring follow-up]

## Next Steps
- [Suggested follow-up actions]

Étape 6 : Tester votre Skill

Les tests sont essentiels. Vérifiez :

1. →Précision du déclenchement — Le skill s'active-t-il pour les bonnes requêtes ?
2. →Pas de faux déclenchements — Reste-t-il inactif pour les requêtes sans rapport ?
3. →Pas d'hallucinations — Claude suit-il exactement les instructions ?
4. →Exécution des scripts — Les scripts s'exécutent-ils correctement ?
5. →Cas limites — Que se passe-t-il avec des entrées incomplètes ou inhabituelles ?

Patterns avancés

Pattern 1 : Skills de workflow multi-étapes

Pour les workflows complexes avec plusieurs phases :

---
name: Code Review Assistant
description: |
  Perform a comprehensive code review following our team's
  standards. Use when the user asks for a code review,
  PR review, or code quality check.
---

# Code Review Assistant

## Phase 1: Static Analysis
1. Run `scripts/lint_check.sh` on the provided code
2. Identify syntax errors, style violations, and common bugs

## Phase 2: Logic Review
1. Analyze the code's logical flow
2. Identify potential edge cases not handled
3. Check for security vulnerabilities

## Phase 3: Architecture Review
1. Load `references/architecture_standards.md`
2. Evaluate naming conventions, code organization
3. Check for SOLID principle violations

## Phase 4: Report Generation
1. Combine findings from all phases
2. Prioritize by severity (Critical > High > Medium > Low)
3. Provide specific fix suggestions for each finding

Pattern 2 : Skills de gestion d'état

Pour les skills qui doivent suivre la progression entre les interactions :

## State Tracking

After each interaction, update the status file:

scripts/update_status.py --task "[TASK_ID]" --status "[STATUS]"

Always check current state before proceeding:

scripts/get_status.py --task "[TASK_ID]"

Pattern 3 : Skills de gestion d'erreurs

## Error Handling

If any script fails:
1. Log the error: `scripts/log_error.py --error "[MESSAGE]"`
2. Inform the user of what went wrong
3. Suggest alternative approaches
4. Never proceed with partial or assumed data

Pattern 4 : Skills composables avec dépendances

---
name: Quarterly Report Generator
description: Generate quarterly business reports.
dependencies:
  - data-analysis
  - brand-writing
  - chart-generator
---

## Step 1: Data Collection
Activate the `data-analysis` skill to process raw metrics.

## Step 2: Visualization
Use the `chart-generator` skill to create charts.

## Step 3: Writing
Apply the `brand-writing` skill to the final report text.

Intégration Skills + MCP

Comment les Skills et MCP se complètent

Exemple : Skill de support client avec MCP

---
name: Customer Issue Resolver
description: |
  Handle customer support tickets by looking up account info,
  checking order status, and drafting responses.
---

# Customer Issue Resolver

## Process

1. Extract customer ID from the ticket
2. **[MCP: database]** Query customer account:
   `SELECT * FROM customers WHERE id = {customer_id}`
3. **[MCP: api]** Check order status:
   `GET /api/orders?customer={customer_id}&status=active`
4. Analyze the issue against `references/common_issues.md`
5. Draft a response using `references/response_templates.md`
6. **[MCP: email]** Send the drafted response to the customer

Déploiement et production

Claude.ai (Projects)

1. →Créez un nouveau Project dans Claude.ai
2. →Téléchargez le dossier skill dans la base de connaissances du Project
3. →Le skill s'activera automatiquement lors des conversations correspondantes

Claude Code

1. →Placez le dossier skill dans .claude/skills/ de votre projet
2. →Claude Code découvrira et utilisera les skills automatiquement
3. →Les scripts s'exécutent directement dans votre environnement de développement

API Anthropic

import anthropic

client = anthropic.Anthropic()

# Load skill content
with open('my-skill/SKILL.md', 'r') as f:
    skill_content = f.read()

response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=4096,
    system=f"""You have the following skill available:

{skill_content}

Activate this skill when the user's request matches
the skill description. Follow the instructions exactly.""",
    messages=[
        {"role": "user", "content": "Please review this code..."}
    ]
)

Bonnes pratiques de production

1. →Versionnez vos skills — Traitez-les comme du code, utilisez Git
2. →Écrivez des tests — Créez des cas de test pour la précision du déclenchement et la qualité de sortie
3. →Surveillez les activations — Journalisez quand les skills se déclenchent pour détecter les faux positifs
4. →Itérez selon les retours — Affinez continuellement les instructions
5. →Auditez la sécurité des scripts — Révisez tout le code exécutable
6. →Documentez les dépendances — Notez quels outils MCP ou services externes un skill requiert

Exemples concrets

Exemple 1 : Formateur de documents de marque

Appliquer automatiquement les directives de marque à tout document :

• →Le script vérifie le ton, la voix et la terminologie
• →Le fichier de référence contient les directives de marque actuelles
• →Le modèle formate la sortie en Markdown prêt pour le PDF

Exemple 2 : Réviseur de PR Git

Automatiser la revue de code pour les pull requests :

• →Le script exécute le linting et l'analyse statique
• →La référence contient les standards de codage de l'équipe
• →Produit une revue structurée avec niveaux de sévérité et suggestions de corrections

Exemple 3 : Moniteur de pipeline de données

Surveiller et dépanner les pipelines de données :

• →Le script interroge les métriques du pipeline via MCP
• →La référence contient les définitions de SLA
• →Génère automatiquement des rapports d'incident en cas de défaillance

Skills pré-construits

Anthropic fournit plusieurs skills documentaires pré-construits disponibles nativement sur les formules Pro, Max, Team et Enterprise :

Ces skills utilisent le Code Execution Tool en interne — par exemple, le skill PDF exécute un petit script Python pour extraire les définitions de champs de formulaire, puis Claude les remplit selon les instructions de l'utilisateur.

Le Skill Creator (méta-skill)

Anthropic fournit un skill « skill-creator » — un méta-skill spécifiquement conçu pour vous aider à créer de nouveaux skills.

Comment ça fonctionne

1. →Décrivez ce que vous voulez que votre skill fasse
2. →Le skill-creator vous guide dans la structuration du SKILL.md
3. →Il suggère l'organisation des dossiers, les descriptions de déclenchement et les patterns d'instructions
4. →Il vous aide à tester le comportement de déclenchement avec des exemples de requêtes utilisateur
5. →Il itère sur le skill avec vous jusqu'à ce que la précision de déclenchement soit élevée

Ce que le Skill Creator vérifie

• →Qualité de la description de déclenchement — La description est-elle assez spécifique pour s'activer correctement ?
• →Clarté des instructions — Claude suivra-t-il les étapes sans ambiguïté ?
• →Risque d'hallucination — Y a-t-il des lacunes où Claude pourrait inventer des étapes absentes du skill ?
• →Composabilité — Le skill fonctionne-t-il bien aux côtés d'autres skills ?

API Skills — Endpoint /v1/skills

Pour la gestion programmatique des skills, Anthropic fournit un endpoint API REST :

import requests

# Create a new skill
response = requests.post(
    "https://api.anthropic.com/v1/skills",
    headers={
        "x-api-key": "your-api-key",
        "anthropic-version": "2026-01-29"
    },
    json={
        "name": "data-analyzer",
        "description": "Analyze CSV datasets and produce summary reports",
        "content": open("SKILL.md").read(),
        "version": "1.0.0"
    }
)

# List available skills
skills = requests.get(
    "https://api.anthropic.com/v1/skills",
    headers={...}
)

# Upgrade a skill version
response = requests.put(
    "https://api.anthropic.com/v1/skills/data-analyzer",
    headers={...},
    json={
        "content": open("SKILL_v2.md").read(),
        "version": "2.0.0"
    }
)

L'API prend en charge :

• →Create — Télécharger de nouveaux skills
• →List — Voir tous les skills disponibles
• →Read — Obtenir le contenu et les métadonnées actuels d'un skill
• →Update — Mettre à jour les versions de skill
• →Delete — Supprimer des skills

Distribution et partage

Les Skills sont conçus pour être portables et partageables :

Méthodes de partage

Stratégie de versioning

my-skill/
├── SKILL.md          ← Version actuelle
├── CHANGELOG.md      ← Historique des versions
├── package.json       ← Métadonnées de version (optionnel)
└── ...

Bonnes pratiques :

• →Utilisez le versioning sémantique (1.0.0, 1.1.0, 2.0.0) pour les itérations de skill
• →Tenez un CHANGELOG.md documentant ce qui a changé entre les versions
• →Testez la précision du déclenchement après chaque mise à jour — même de petits changements de formulation peuvent affecter l'activation

Dépannage

Problèmes courants et solutions

Liste de vérification du débogage

1. →Vérifiez le déclenchement — La description YAML correspond-elle clairement à la formulation de la requête de l'utilisateur ?
2. →Vérifiez les instructions — Y a-t-il des étapes ambiguës que Claude pourrait interpréter différemment ?
3. →Vérifiez les scripts — Les scripts fonctionnent-ils correctement en dehors de Claude ? Testez indépendamment.
4. →Vérifiez les références — Tous les fichiers référencés sont-ils présents et à jour ?
5. →Vérifiez la composabilité — Ce skill entre-t-il en conflit avec d'autres skills actifs ?
6. →Vérifiez les hallucinations — Claude ajoute-t-il des étapes ou informations non présentes dans le skill ?

• →Skills d'agent Claude Code — Les Skills dans l'environnement CLI
• →Le protocole MCP expliqué — Le protocole de connexion
• →Agents IA ReAct expliqué — Les patterns de raisonnement des agents
• →Bonnes pratiques de prompt engineering — Techniques de base

Points clés à retenir

1. →

   Les Skills transforment Claude d'un assistant généraliste en un agent spécialisé avec des connaissances procédurales, des scripts exécutables et des références à la demande

2. →

   SKILL.md est le seul fichier requis — il contient le frontmatter YAML pour la correspondance de déclenchement et les instructions Markdown pour l'exécution

3. →

   La divulgation progressive économise 70 à 90 % de tokens en ne chargeant les détails du skill que lorsqu'il est déclenché par une intention utilisateur correspondante

4. →

   Les scripts fournissent une fiabilité déterministe pour les tâches qui doivent produire des résultats cohérents et exacts à chaque fois

5. →

   Les Skills et MCP sont complémentaires — MCP fournit les connexions externes, les Skills fournissent les procédures pour savoir quoi faire avec ces données

6. →

   Le même format de skill fonctionne partout — Claude.ai Projects, Claude Code et l'API Anthropic

7. →

   La composabilité est intégrée — Claude peut automatiquement identifier, séquencer et coordonner plusieurs skills pour des tâches complexes multi-étapes

8. →

   Traitez les Skills comme du code — versionnez, testez systématiquement, itérez selon les retours réels

Agent Skills : Le Cours Officiel Anthropic

Programme "Introduction to Agent Skills" (Skilljar)

Le cours officiel Anthropic sur les Agent Skills couvre :

1. →Fondamentaux des Agents : Comprendre le concept d'agents IA autonomes
2. →Architecture d'un Skill : Structure d'un skill (déclencheurs, instructions, contexte)
3. →Création Pas à Pas : Workflow complet de développement d'un skill
4. →Testing et Itération : Tester et améliorer les performances du skill
5. →Publication : Processus de soumission au marketplace

Compétences Clés Développées

Bonnes Pratiques pour les Skills d'Agent

• →Instructions atomiques : Un skill = une tâche bien définie
• →Déclencheurs précis : Éviter les conflits entre skills
• →Tests exhaustifs : Tester avec des edge cases variés
• →Documentation claire : Faciliter l'adoption par d'autres utilisateurs
• →Versioning : Maintenir des versions stables

📚 Explorer le marketplace : Consultez notre guide Skills Claude pour créer et partager vos propres skills.

Développez vos compétences en ingénierie IA

Créer des Claude Skills efficaces nécessite une compréhension approfondie de la façon dont les LLM traitent les instructions, gèrent le contexte et exécutent des procédures multi-étapes.

Dans notre Module 5 — Agents IA et automatisation, vous apprendrez :

• →Comment concevoir des procédures d'agent fiables
• →La gestion du contexte et l'optimisation des tokens
• →La décomposition de tâches multi-étapes
• →Le test et le débogage des agents IA
• →Les patterns de déploiement en production

→ Explorer le Module 5 : Agents IA et automatisation

Dernière mise à jour : 13 février 2026 Basé sur le guide officiel de 32 pages d'Anthropic « Complete Guide to Building Skills for Claude » (29 janvier 2026), la documentation Claude.ai, les ressources de la communauté de développeurs et l'expérience de déploiement en production.