Créateur de Skill

Ce skill fournit des conseils pour créer des skills efficaces.

À propos des Skills

Les skills sont des packages modulaires et autonomes qui étendent les capacités de Claude en fournissant des connaissances spécialisées, des workflows et des outils. Pensez à eux comme des « guides d'intégration » pour des domaines ou tâches spécifiques — ils transforment Claude d'un agent polyvalent en un agent spécialisé équipé de connaissances procédurales qu'aucun modèle ne peut pleinement posséder.

Ce que les Skills Fournissent

1. Workflows spécialisés - Procédures multi-étapes pour des domaines spécifiques
2. Intégrations d'outils - Instructions pour travailler avec des formats de fichiers ou des APIs spécifiques
3. Expertise métier - Connaissances propres à l'entreprise, schémas, logique métier
4. Ressources groupées - Scripts, références et ressources pour les tâches complexes et répétitives

Principes Fondamentaux

La Concision est Clé

La fenêtre de contexte est un bien public. Les skills partagent la fenêtre de contexte avec tout ce dont Claude a besoin : prompt système, historique de conversation, métadonnées d'autres Skills et la demande utilisateur réelle.

Hypothèse par défaut : Claude est déjà très intelligent. Ajoutez uniquement du contexte que Claude ne possède pas déjà. Remettez en question chaque information : « Claude a-t-il vraiment besoin de cette explication ? » et « Ce paragraphe justifie-t-il son coût en tokens ? »

Préférez les exemples concis aux explications verbeux.

Définir les Degrés de Liberté Appropriés

Adaptez le niveau de spécificité à la fragilité et à la variabilité de la tâche :

Liberté élevée (instructions basées sur le texte) : Utilisez quand plusieurs approches sont valides, les décisions dépendent du contexte ou des heuristiques guident l'approche.

Liberté moyenne (pseudocode ou scripts avec paramètres) : Utilisez quand un modèle préféré existe, certaines variations sont acceptables ou la configuration affecte le comportement.

Liberté faible (scripts spécifiques, peu de paramètres) : Utilisez quand les opérations sont fragiles et sujettes aux erreurs, la cohérence est critique ou une séquence spécifique doit être suivie.

Pensez à Claude comme explorant un chemin : un pont étroit avec des falaises a besoin de garde-fous spécifiques (liberté faible), tandis qu'un champ ouvert permet de nombreuses routes (liberté élevée).

Anatomie d'un Skill

Chaque skill se compose d'un fichier SKILL.md obligatoire et de ressources groupées optionnelles :

skill-name/
├── SKILL.md (required)
│   ├── YAML frontmatter metadata (required)
│   │   ├── name: (required)
│   │   └── description: (required)
│   └── Markdown instructions (required)
└── Bundled Resources (optional)
    ├── scripts/          - Executable code (Python/Bash/etc.)
    ├── references/       - Documentation intended to be loaded into context as needed
    └── assets/           - Files used in output (templates, icons, fonts, etc.)

SKILL.md (obligatoire)

Chaque SKILL.md se compose de :

• Frontmatter (YAML) : Contient les champs name et description. Ce sont les seuls champs que Claude lit pour déterminer quand le skill est utilisé, il est donc très important d'être clair et complet dans la description de ce que le skill est et de quand il doit être utilisé.
• Corps (Markdown) : Instructions et conseils pour utiliser le skill. Chargé uniquement APRÈS le déclenchement du skill (le cas échéant).

Ressources Groupées (optionnel)

Scripts (scripts/)

Code exécutable (Python/Bash/etc.) pour les tâches nécessitant une fiabilité déterministe ou qui sont réécrites à répétition.

• Quand inclure : Quand le même code est réécrit à répétition ou quand la fiabilité déterministe est nécessaire
• Exemple : scripts/rotate_pdf.py pour les tâches de rotation PDF
• Avantages : Efficace en tokens, déterministe, peut être exécuté sans charger dans le contexte
• Remarque : Les scripts peuvent toujours avoir besoin d'être lus par Claude pour des correctifs ou des ajustements spécifiques à l'environnement

Références (references/)

Documentation et matériel de référence destinés à être chargés au besoin dans le contexte pour informer le processus et la réflexion de Claude.

• Quand inclure : Pour la documentation que Claude doit consulter lors du travail
• Exemples : references/finance.md pour les schémas financiers, references/mnda.md pour le modèle NDA de l'entreprise, references/policies.md pour les politiques de l'entreprise, references/api_docs.md pour les spécifications d'API
• Cas d'usage : Schémas de base de données, documentation API, connaissances métier, politiques de l'entreprise, guides de workflows détaillés
• Avantages : Maintient SKILL.md léger, chargé uniquement quand Claude le juge nécessaire
• Bonne pratique : Si les fichiers sont volumineux (>10k mots), incluez les modèles de recherche grep dans SKILL.md
• Éviter la duplication : L'information doit résider soit dans SKILL.md soit dans les fichiers de références, pas dans les deux. Préférez les fichiers de références pour les informations détaillées sauf si c'est vraiment central pour le skill — cela maintient SKILL.md léger tout en rendant l'information découvrable sans monopoliser la fenêtre de contexte. Conservez uniquement les instructions procédurales essentielles et les conseils de workflow dans SKILL.md ; déplacez le matériel de référence détaillé, les schémas et les exemples vers les fichiers de références.

Ressources (assets/)

Fichiers non destinés à être chargés dans le contexte, mais plutôt utilisés dans la sortie produite par Claude.

• Quand inclure : Quand le skill a besoin de fichiers qui seront utilisés dans la sortie finale
• Exemples : assets/logo.png pour les ressources de marque, assets/slides.pptx pour les modèles PowerPoint, assets/frontend-template/ pour le boilerplate HTML/React, assets/font.ttf pour la typographie
• Cas d'usage : Modèles, images, icônes, code boilerplate, polices, exemples de documents qui sont copiés ou modifiés
• Avantages : Sépare les ressources de sortie de la documentation, permet à Claude d'utiliser des fichiers sans les charger dans le contexte

Ce qu'il ne faut pas Inclure dans un Skill

Un skill ne doit contenir que les fichiers essentiels qui soutiennent directement sa fonctionnalité. Ne créez PAS de documentation superflue ou de fichiers auxiliaires, notamment :

• README.md
• INSTALLATION_GUIDE.md
• QUICK_REFERENCE.md
• CHANGELOG.md
• etc.

Le skill ne doit contenir que les informations nécessaires pour qu'un agent IA effectue le travail en main. Il ne doit pas contenir de contexte auxiliaire sur le processus de création, les procédures de configuration et de test, la documentation orientée utilisateur, etc. Créer des fichiers de documentation supplémentaires ne fait qu'ajouter du désordre et de la confusion.

Principe de Divulgation Progressive

Les skills utilisent un système de chargement à trois niveaux pour gérer le contexte efficacement :

1. Métadonnées (name + description) - Toujours en contexte (~100 mots)
2. Corps SKILL.md - Quand le skill se déclenche (<5k mots)
3. Ressources groupées - Au besoin par Claude (Illimitées car les scripts peuvent être exécutés sans être lus dans la fenêtre de contexte)

Modèles de Divulgation Progressive

Gardez le corps SKILL.md aux éléments essentiels et moins de 500 lignes pour minimiser l'encombrement du contexte. Divisez le contenu en fichiers séparés en approchant cette limite. Quand vous divisez le contenu en d'autres fichiers, il est très important de les référencer depuis SKILL.md et de décrire clairement quand les lire, pour s'assurer que le lecteur du skill sait qu'ils existent et quand les utiliser.

Principe clé : Quand un skill supporte plusieurs variantes, frameworks ou options, conservez uniquement le workflow central et les conseils de sélection dans SKILL.md. Déplacez les détails spécifiques aux variantes (modèles, exemples, configuration) dans des fichiers de référence séparés.

Modèle 1 : Guide haut niveau avec références

# PDF Processing

## Quick start

Extract text with pdfplumber:
[code example]

## Advanced features

- **Form filling**: See [FORMS.md](FORMS.md) for complete guide
- **API reference**: See [REFERENCE.md](REFERENCE.md) for all methods
- **Examples**: See [EXAMPLES.md](EXAMPLES.md) for common patterns

Claude charge FORMS.md, REFERENCE.md ou EXAMPLES.md uniquement en cas de besoin.

Modèle 2 : Organisation par domaine

Pour les Skills avec plusieurs domaines, organisez le contenu par domaine pour éviter de charger un contexte non pertinent :

bigquery-skill/
├── SKILL.md (overview and navigation)
└── reference/
    ├── finance.md (revenue, billing metrics)
    ├── sales.md (opportunities, pipeline)
    ├── product.md (API usage, features)
    └── marketing.md (campaigns, attribution)

Quand un utilisateur pose des questions sur les métriques de vente, Claude lit uniquement sales.md.

De même, pour les skills supportant plusieurs frameworks ou variantes, organisez par variante :

cloud-deploy/
├── SKILL.md (workflow + provider selection)
└── references/
    ├── aws.md (AWS deployment patterns)
    ├── gcp.md (GCP deployment patterns)
    └── azure.md (Azure deployment patterns)

Quand l'utilisateur choisit AWS, Claude lit uniquement aws.md.

Modèle 3 : Détails conditionnels

Montrez le contenu de base, liez au contenu avancé :

# DOCX Processing

## Creating documents

Use docx-js for new documents. See [DOCX-JS.md](DOCX-JS.md).

## Editing documents

For simple edits, modify the XML directly.

**For tracked changes**: See [REDLINING.md](REDLINING.md)
**For OOXML details**: See [OOXML.md](OOXML.md)

Claude lit REDLINING.md ou OOXML.md uniquement quand l'utilisateur a besoin de ces fonctionnalités.

Directives importantes :

• Éviter les références profondément imbriquées - Gardez les références à un seul niveau depuis SKILL.md. Tous les fichiers de référence doivent être liés directement depuis SKILL.md.
• Structurer les fichiers de référence plus longs - Pour les fichiers plus longs que 100 lignes, incluez une table des matières en haut pour que Claude puisse voir la portée complète en aperçu.

Processus de Création d'un Skill

La création d'un skill implique ces étapes :

1. Comprendre le skill avec des exemples concrets
2. Planifier le contenu réutilisable du skill (scripts, références, ressources)
3. Initialiser le skill (exécuter init_skill.py)
4. Éditer le skill (implémenter les ressources et écrire SKILL.md)
5. Empaqueter le skill (exécuter package_skill.py)
6. Itérer en fonction de l'utilisation réelle

Suivez ces étapes dans l'ordre, en les ignorant uniquement s'il y a une raison claire pour laquelle elles ne sont pas applicables.

Étape 1 : Comprendre le Skill avec des Exemples Concrets

Ignorez cette étape uniquement quand les modèles d'utilisation du skill sont déjà clairement compris. Elle reste précieuse même lors du travail avec un skill existant.

Pour créer un skill efficace, comprenez clairement les exemples concrets de la façon dont le skill sera utilisé. Cette compréhension peut provenir soit d'exemples utilisateur directs soit d'exemples générés validés avec les retours utilisateur.

Par exemple, lors de la création d'un skill d'éditeur d'images, les questions pertinentes incluent :

• « Quelle fonctionnalité le skill d'éditeur d'images doit-il supporter ? Édition, rotation, autre chose ? »
• « Pouvez-vous donner quelques exemples de comment ce skill serait utilisé ? »
• « Je peux imaginer que les utilisateurs demandent des choses comme « Supprime les yeux rouges de cette image » ou « Tourne cette image ». Y a-t-il d'autres façons dont vous imaginez ce skill être utilisé ? »
• « Qu'est-ce qu'un utilisateur dirait qui devrait déclencher ce skill ? »

Pour éviter de surcharger les utilisateurs, évitez de poser trop de questions dans un seul message. Commencez par les questions les plus importantes et complétez au besoin pour une meilleure efficacité.

Concluez cette étape quand il y a une compréhension claire de la fonctionnalité que le skill doit supporter.

Étape 2 : Planifier le Contenu Réutilisable du Skill

Pour transformer les exemples concrets en un skill efficace, analysez chaque exemple en :

1. Considérant comment exécuter l'exemple à partir de zéro
2. Identifiant quels scripts, références et ressources seraient utiles lors de l'exécution répétée de ces workflows

Exemple : Lors de la création d'un skill pdf-editor pour gérer des demandes comme « Aide-moi à tourner ce PDF », l'analyse montre :

1. Tourner un PDF nécessite de réécrire le même code chaque fois
2. Un script scripts/rotate_pdf.py serait utile à stocker dans le skill

Exemple : Lors de la conception d'un skill frontend-webapp-builder pour des demandes comme « Construis-moi une app todo » ou « Construis-moi un tableau de bord pour suivre mes étapes », l'analyse montre :

1. Écrire une webapp frontend nécessite le même HTML/React boilerplate chaque fois
2. Un modèle assets/hello-world/ contenant les fichiers du projet HTML/React boilerplate serait utile à stocker dans le skill

Exemple : Lors de la création d'un skill big-query pour gérer des demandes comme « Combien d'utilisateurs se sont connectés aujourd'hui ? », l'analyse montre :

1. Interroger BigQuery nécessite de redécouvrir les schémas de table et les relations chaque fois
2. Un fichier references/schema.md documentant les schémas de table serait utile à stocker dans le skill

Pour établir le contenu du skill, analysez chaque exemple concret pour créer une liste des ressources réutilisables à inclure : scripts, références et ressources.

Étape 3 : Initialiser le Skill

À ce moment, c'est le moment de créer réellement le skill.

Ignorez cette étape uniquement si le skill en cours de développement existe déjà et que l'itération ou l'empaquetage est nécessaire. Dans ce cas, continuez à l'étape suivante.

Lors de la création d'un nouveau skill à partir de zéro, exécutez toujours le script init_skill.py. Le script génère convenablement un nouveau répertoire de skill modèle qui inclut automatiquement tout ce qu'un skill nécessite, rendant le processus de création du skill beaucoup plus efficace et fiable.

Utilisation :

scripts/init_skill.py <skill-name> --path <output-directory>

Le script :

• Crée le répertoire du skill au chemin spécifié
• Génère un modèle SKILL.md avec le frontmatter approprié et les placeholders TODO
• Crée les répertoires de ressources d'exemple : scripts/, references/ et assets/
• Ajoute des fichiers d'exemple dans chaque répertoire qui peuvent être personnalisés ou supprimés

Après l'initialisation, personnalisez ou supprimez les fichiers SKILL.md et d'exemple générés au besoin.

Étape 4 : Éditer le Skill

Lors de l'édition du skill (nouvellement généré ou existant), souvenez-vous que le skill est créé pour qu'une autre instance de Claude l'utilise. Incluez des informations qui seraient bénéfiques et non évidentes pour Claude. Considérez quelles connaissances procédurales, détails spécifiques au domaine ou ressources réutilisables aideraient une autre instance de Claude à exécuter ces tâches plus efficacement.

Apprendre les Modèles de Conception Éprouvés

Consultez ces guides utiles en fonction des besoins de votre skill :

• Processus multi-étapes : Voir references/workflows.md pour les workflows séquentiels et la logique conditionnelle
• Formats de sortie spécifiques ou normes de qualité : Voir references/output-patterns.md pour les modèles de template et d'exemple

Ces fichiers contiennent des meilleures pratiques établies pour une conception efficace du skill.

Commencer par le Contenu Réutilisable du Skill

Pour commencer l'implémentation, commencez par les ressources réutilisables identifiées ci-dessus : les fichiers scripts/, references/ et assets/. Notez que cette étape peut nécessiter une entrée utilisateur. Par exemple, lors de l'implémentation d'un skill brand-guidelines, l'utilisateur peut avoir besoin de fournir des ressources de marque ou des modèles à stocker dans assets/, ou de la documentation à stocker dans references/.

Les scripts ajoutés doivent être testés en les exécutant réellement pour s'assurer qu'il n'y a pas de bugs et que la sortie correspond à ce qui est attendu. S'il y a beaucoup de scripts similaires, seul un échantillon représentatif doit être testé pour assurer la confiance que tous fonctionnent tout en équilibrant le temps de réalisation.

Tous les fichiers et répertoires d'exemple non nécessaires pour le skill doivent être supprimés. Le script d'initialisation crée des fichiers d'exemple dans scripts/, references/ et assets/ pour démontrer la structure, mais la plupart des skills n'en auront pas besoin.

Mettre à Jour SKILL.md

Conseils d'Écriture : Utilisez toujours la forme impérative/infinitive.

Frontmatter

Écrivez le frontmatter YAML avec name et description :

• name : Le nom du skill
• description : C'est le mécanisme de déclenchement principal de votre skill et aide Claude à comprendre quand utiliser le skill.
  • Incluez à la fois ce que fait le Skill et les déclencheurs/contextes spécifiques pour quand l'utiliser.
  • Incluez toutes les informations « quand utiliser » ici - Pas dans le corps. Le corps n'est chargé qu'après le déclenchement, donc les sections « When to Use This Skill » dans le corps ne sont pas utiles à Claude.
  • Exemple de description pour un skill docx : « Création, édition et analyse complètes de documents avec support des modifications suivies, commentaires, préservation du formatage et extraction de texte. Utilisez quand Claude doit travailler avec des documents professionnels (fichiers .docx) pour : (1) Créer de nouveaux documents, (2) Modifier ou éditer le contenu, (3) Travailler avec les modifications suivies, (4) Ajouter des commentaires, ou toute autre tâche de document »

N'incluez aucun autre champ dans le frontmatter YAML.

Corps

Écrivez les instructions pour utiliser le skill et ses ressources groupées.

Étape 5 : Empaqueter un Skill

Une fois le développement du skill terminé, il doit être empaqueté dans un fichier .skill distribuable qui est partagé avec l'utilisateur. Le processus d'empaquetage valide automatiquement le skill d'abord pour s'assurer qu'il respecte tous les exigences :

scripts/package_skill.py <path/to/skill-folder>

Spécification du répertoire de sortie optionnel :

scripts/package_skill.py <path/to/skill-folder> ./dist

Le script d'empaquetage va :

1. Valider le skill automatiquement, en vérifiant :

   • Format du frontmatter YAML et champs obligatoires
   • Conventions de nommage du skill et structure du répertoire
   • Complétude et qualité de la description
   • Organisation des fichiers et références aux ressources

2. Empaqueter le skill si la validation réussit, créant un fichier .skill nommé d'après le skill (par ex. my-skill.skill) qui inclut tous les fichiers et maintient la structure de répertoire appropriée pour la distribution. Le fichier .skill est un fichier zip avec l'extension .skill.

Si la validation échoue, le script rapportera les erreurs et quittera sans créer de paquet. Corrigez les erreurs de validation et exécutez la commande d'empaquetage à nouveau.

Étape 6 : Itérer

Après avoir testé le skill, les utilisateurs peuvent demander des améliorations. Cela se produit souvent juste après l'utilisation du skill, avec un contexte frais de comment le skill a performé.

Workflow d'itération :

1. Utiliser le skill sur des tâches réelles
2. Remarquer les difficultés ou inefficacités
3. Identifier comment SKILL.md ou les ressources groupées devraient être mises à jour
4. Implémenter les modifications et tester à nouveau

Qu'est-ce qui doit être noté ?

Les skills que vous créez doivent être placés dans le dossier .agent/skills/ de l'espace de travail actuel, car les autres skills sont installés à cet emplacement par défaut.