Maîtriser les Compétences de l'Agent Claude - Le Guide Complet pour Construire Votre Arsenal de Superpouvoirs IA

Le Moment où J'ai Compris ce que Sont Vraiment les Compétences

Laissez-moi vous raconter une histoire. Imaginez qu'on vous demande de mentorer une nouvelle recrue brillante au travail. Cette personne est incroyablement intelligente — apprend plus vite que quiconque, comprend tout ce que vous expliquez, parle avec éloquence de n'importe quel sujet. Mais il y a un problème : elle ne connaît pas les règles de votre entreprise.

Chaque matin, vous vous asseyez avec elle et expliquez les mêmes choses. "Voici comment nous formatons les rapports. Voici notre style de code. Voici qui mettre en copie sur quels e-mails. Voici le modèle pour les propositions clients." Et chaque matin, après le déjeuner, elle a tout oublié. Non pas parce qu'elle est stupide — elle est brillante. Mais elle n'a aucune mémoire persistante de la façon de faire de votre entreprise.

C'est exactement ce que c'était de travailler avec l'IA avant.

Les Prompts sont comme se tenir à côté de cette nouvelle recrue, donnant des instructions verbales sur le moment. "Écris cet e-mail plus formellement." "Utilise des puces ici." "Vérifie ce code pour les bugs." Ça marche. Mais dès que vous fermez la conversation, tout disparaît. Chaque nouveau chat repart de zéro.

Les Compétences (Skills) sont comme lui remettre un manuel de procédures interne — un dossier de base de connaissances contenant des spécifications, des scripts, des modèles et des matériaux de référence. L'Agent cherchera ce dont il a besoin quand il en a besoin. Et surtout, ce manuel persiste à travers chaque conversation.

Voici l'idée révolutionnaire : Les Compétences ne sont pas juste des prompts sophistiqués. Elles sont un paradigme complètement différent. Un prompt est réactif — vous donnez une instruction, vous obtenez une réponse. Une Compétence est proactive — elle reste là, attendant d'être découverte et appliquée quand c'est pertinent, performant de la même manière à chaque fois.

Ce Qu'une Compétence Contient Vraiment

Chaque Compétence est un dossier, pas juste un fichier texte. C'est crucial à comprendre. À l'intérieur de ce dossier, vous pouvez avoir :

Quand j'ai vu cette structure pour la première fois, j'ai pensé : "Attends, c'est comme construire une petite application." Et c'est exactement ça. Chaque Compétence est un module de capacité autonome. Certaines sont simples — juste un fichier markdown avec des règles de relecture. D'autres sont complexes — complètes avec des scripts Python qui traitent des données, téléchargent sur des serveurs et génèrent des rapports.

Quand les Compétences Sont-elles Arrivées ?

Anthropic a publié les Skills pour Claude Code en octobre 2025. Au début, je pensais que c'était juste une autre mise à jour de fonctionnalité. Mais ensuite, quelque chose s'est passé en décembre 2025 — ils ont ouvert les Skills comme un standard via agentskills.io. Soudainement, les compétences n'étaient plus juste un truc de Claude. Le CLI Codex d'OpenAI a adopté la même architecture. Cursor, Codebuddy, OpenCode — tout le monde a commencé à construire la compatibilité.

Les Compétences sont devenues le standard de facto pour l'extension des capacités des Agents IA, tout comme MCP est rapidement devenu le protocole de tout le monde pour les connexions externes.

Et la popularité ? Laissez-moi vous dire ceci : Un dépôt contenant plus de 50 compétences Claude a atteint 18 000 étoiles sur GitHub. Le mot "Skills" est maintenant aussi omniprésent dans les cercles IA que "Prompt" l'était en 2023.

Divulgation Progressive - Pourquoi ce Design est Génial

Avant de comprendre la divulgation progressive, j'avais une inquiétude tenace : "Si j'installe 50 compétences, le contexte de Claude ne va-t-il pas exploser ? Ne vais-je pas brûler des milliers de jetons juste en chargeant les descriptions des compétences ?"

C'est là que brille le génie du design d'Anthropic. Ils ont emprunté un concept du design UX — la divulgation progressive — et l'ont appliqué parfaitement à la gestion du contexte IA.

Le Système de Chargement à Trois Couches

La divulgation progressive signifie charger par étapes et à la demande. Claude ne déverse pas tout dans le contexte au démarrage. Au lieu de cela, il utilise un système à trois couches :

Faisons le Calcul

Voici une comparaison qui m'a fait apprécier ce design :

C'est une réduction de 75% de la consommation de jetons. Et cela ne compte même pas l'avantage des scripts.

La Magie des Scripts

C'est là que les Compétences laissent les prompts loin derrière. Lorsqu'une Compétence inclut un script, quelque chose de remarquable se produit :

1. Claude génère une commande : python scripts/upload_image.py image.png
2. Le script s'exécute localement sur votre machine
3. Seul le résultat (comme une URL d'image) retourne à Claude

Le code du script lui-même n'entre jamais dans le contexte.

Pensez à ce que cela signifie. Vous pouvez écrire un script Python de 500 lignes gérant chaque cas limite, avec une gestion d'erreurs robuste, des logs, des tentatives — toutes les choses qui gonfleraient un prompt de manière impossible. Claude a juste besoin de savoir "exécute ce script". La complexité est encapsulée.

L'Analogie du Menu Mobile

Si vous avez déjà conçu une application mobile, vous connaissez intimement la divulgation progressive. C'est pourquoi nous avons des menus hamburger — nous ne montrons pas aux utilisateurs 47 options immédiatement. Nous montrons une icône de menu. Ils tapent. Ils voient des catégories. Ils tapent encore. Ils atteignent le réglage qu'ils veulent.

Le but ? Ne jamais submerger d'informations. Décomposer en morceaux digestes. Laisser les utilisateurs (ou dans ce cas, l'IA) se concentrer sur la tâche actuelle avec une charge cognitive minimale.

Les humains peuvent retenir environ 7±2 morceaux d'information dans la mémoire de travail. L'IA, limitée par le contexte des jetons, a essentiellement la même contrainte. La divulgation progressive respecte cette limitation dans les deux cas.

Skills vs MCP vs Subagent - Enfin Démêlé

Cette question m'a hanté pendant des semaines. MCP, Skills, Subagent — ils semblent tous "étendre les capacités de Claude". Quelle est la différence réelle ? Après avoir construit avec les trois, j'ai enfin une réponse qui a du sens.

La Distinction en Une Phrase

MCP permet à Claude de toucher des systèmes externes. Les Skills disent à Claude comment utiliser ce qu'il touche. Subagent envoie quelqu'un d'autre faire le travail.

Laissez-moi détailler cela avec des analogies qui m'ont vraiment aidé à comprendre :

Le Tableau de Comparaison

Quand Utiliser Quoi

Utilisez MCP quand vous devez vous connecter à des systèmes externes :

• Interroger une base de données
• Appeler des API tierces
• Lire/écrire Notion, Jira, GitHub, Salesforce
• Accéder à tout service nécessitant une authentification

Utilisez les Skills quand vous avez des flux de travail répétitifs :

• Processus de revue de code avec des listes de contrôle spécifiques
• Relecture d'articles avec des règles de style cohérentes
• Génération de rapports avec des formats standardisés
• Toute instruction que vous vous retrouvez à taper de manière répétée

Utilisez Subagent quand les tâches sont complexes et parallélisables :

• Revoir une base de code entière (chronophage)
• Traiter plusieurs tâches indépendantes simultanément
• Prévenir la pollution du contexte entre des travaux non liés

Ils Travaillent Ensemble

Voici la belle partie : ce ne sont pas des technologies concurrentes. Ce sont des couches complémentaires.

Un flux de travail complexe pourrait utiliser les trois :

1. MCP se connecte à Salesforce pour extraire les données de vente
2. Skills définissent le processus d'analyse des données — comment calculer les métriques, générer des rapports
3. Subagent traite différentes analyses régionales en parallèle

Dans mon propre flux de travail d'écriture :

• Les Skills définissent mes règles de relecture et mon guide de style
• Les scripts (inclus dans les skills) téléchargent les images sur mon service d'hébergement
• Je prévois d'ajouter MCP pour me connecter à ma base de données de matériaux

Pourquoi Simon Willison Dit que les Skills Pourraient Être Plus Importantes que MCP

Simon Willison est l'une des voix les plus respectées dans la communauté des développeurs IA. Quand il a écrit que "les Skills pourraient être une affaire plus importante que MCP", les gens ont prêté attention. Après des mois d'utilisation des deux, je comprends exactement pourquoi il a dit ça.

Raison 1 : Efficacité des Jetons

MCP a un problème fondamental : le gonflement des jetons.

Lorsque vous connectez un serveur MCP, Claude doit comprendre ce que ce serveur peut faire. Chaque fonction disponible, chaque paramètre, chaque type de retour — tout doit être dans le contexte. Simon a noté que le serveur MCP officiel de GitHub consomme à lui seul des dizaines de milliers de jetons.

Les Skills contournent élégamment cela. Charger uniquement les métadonnées (100 jetons chacun), puis charger les instructions complètes uniquement lorsqu'elles sont déclenchées. La différence d'efficacité est stupéfiante.

Raison 2 : L'Avantage de la Simplicité

Pour construire un serveur MCP, vous devez :

• Comprendre la spécification du protocole
• Écrire du code côté serveur
• Configurer correctement le JSON
• Gérer la communication et les états d'erreur

Pour construire une Compétence ?

Juste écrire du Markdown.

Si vous savez écrire de la documentation, vous savez écrire des Skills. La différence de seuil est énorme. Et dans la technologie, des barrières plus basses à la création mènent toujours à une croissance explosive.

Raison 3 : Compatibilité Multiplateforme

Les serveurs MCP sont souvent spécifiques à l'hôte. Quelque chose construit pour Claude Code pourrait ne pas fonctionner ailleurs sans modification.

Les Skills sont juste des dossiers avec du Markdown et des scripts optionnels. Ils ne dépendent pas de la technologie propriétaire d'Anthropic. Simon a souligné que vous pouvez pointer le même dossier Skill vers le CLI Codex, le CLI Gemini — ils fonctionneront même sans support natif des Skills, car à leur base, les compétences sont juste des instructions bien structurées.

Cette portabilité est la raison pour laquelle OpenAI a adopté essentiellement la même architecture dans le CLI Codex. Les Skills deviennent un standard universel.

Raison 4 : La Prédiction de l'Explosion Cambrienne

"Je prédis que les Skills apporteront une explosion cambrienne plus spectaculaire que la folie MCP de l'année dernière."

Pourquoi ? Parce que lorsque le seuil de création baisse suffisamment, les contributions de la communauté explosent. Écrire un serveur MCP nécessite des compétences de développement backend. Écrire une Compétence nécessite de savoir écrire un document.

Nous voyons déjà cette prédiction se réaliser. Les places de marché de Skills apparaissent partout. Les dépôts GitHub débordent de contributions communautaires. L'écosystème croît plus vite que quiconque ne l'avait anticipé.

Ma Propre Observation

Après des mois avec les deux technologies, je suis d'accord avec l'évaluation de Simon. Les Skills semblent plus alignées avec la façon dont les LLM fonctionnent naturellement — comprendre du texte, suivre des instructions, appliquer des connaissances contextuellement.

MCP représente la pensée traditionnelle de l'ingénierie logicielle : définir des interfaces, implémenter des services, gérer des protocoles.

Les Skills représentent la pensée native LLM : écrire clairement comment faire quelque chose, laisser le modèle comprendre quand et comment l'appliquer.

Les deux ont leur place. Mais les Skills pourraient être le changement de paradigme le plus profond.

L'Anatomie d'une Compétence Parfaite

Laissez-moi vous guider à travers la structure d'une Compétence bien conçue. Ce n'est pas juste de la théorie — comprendre cette anatomie fera cliquer tout le reste de ce guide.

La Structure du Dossier

my-skill/
├── SKILL.md                 # Instructions principales (requis)
├── scripts/
│   └── process.py           # Script exécutable
├── references/
│   └── DETAILED_GUIDE.md    # Doc de référence détaillée
└── assets/
    └── template.md          # Ressource modèle

Le Fichier SKILL.md

C'est le cœur de votre compétence. Il a deux parties :

---
name: my-awesome-skill
description: Brève explication de ce que fait cette compétence et quand l'utiliser. Inclure des mots-clés de déclenchement.
---

# My Awesome Skill

## Instructions

Guide étape par étape que Claude doit suivre lorsque cette compétence est invoquée.

## Examples

Démonstrations concrètes de modèles d'entrée/sortie ou d'utilisation.

## Guidelines

Toutes règles, contraintes ou meilleures pratiques à suivre.

Le Frontmatter YAML

La section entre les marqueurs --- est cruciale. C'est ce que Claude lit pour décider d'utiliser ou non votre compétence.

Options Frontmatter Avancées

Au-delà du nom et de la description, les Skills supportent des options de configuration puissantes :

La Règle d'Or : 500 Lignes

Conventions de Nommage

Le nom de votre dossier compte. Il doit être en lettres minuscules + tirets. Pas d'espaces. Pas de majuscules.

• Bien : hotspot-collector, code-review, ai-proofreading
• Mal : Hotspot Collector, codeReview, AI_Proofreading

Créer Votre Première Compétence

Voici mon conseil le plus important : Vous n'avez pas besoin d'écrire les Skills vous-même.

Laissez-moi expliquer. La valeur d'une Compétence réside dans ce qu'elle encapsule — votre flux de travail, votre expérience, vos SOP. Ceux-ci viennent de vous, découverts par le travail réel. Mais transformer cela en un fichier SKILL.md correctement formaté ? Laissez l'IA faire cela.

Ce que vous devez faire :

1. Penser clairement au problème que vous voulez résoudre
2. Clarifier votre flux de travail
3. Fournir suffisamment de contexte et de matériaux de référence

Puis dites à Claude : "Aide-moi à créer une Compétence pour faire XXX." Il générera des fichiers correctement formatés pour vous.

Étape par Étape : Un Exemple Simple

Créons une compétence qui apprend à Claude à expliquer du code en utilisant des diagrammes visuels et des analogies.

---
name: explain-code
description: Explique le code avec des diagrammes visuels et des analogies. Utiliser pour expliquer comment fonctionne le code, enseigner sur une base de code, ou quand l'utilisateur demande "comment ça marche ?"
---

Quand tu expliques du code, inclus toujours :

1. **Commence par une analogie** : Compare le code à quelque chose de la vie quotidienne
2. **Dessine un diagramme** : Utilise l'art ASCII pour montrer le flux, la structure ou les relations
3. **Parcours le code** : Explique étape par étape ce qui se passe
4. **Souligne un piège** : Quelle est une erreur commune ou une idée fausse ?

Garde les explications conversationnelles. Pour les concepts complexes, utilise plusieurs analogies.

Où Vivent les Skills

L'emplacement détermine la portée :

Utiliser le skill-creator Officiel

Anthropic fournit une compétence spécifiquement pour créer des compétences. Méta, non ?

Installez-la en disant à Claude :

Install this skill, project address is: https://github.com/anthropics/skills/tree/main/skills/skill-creator

Une fois installée, vous pouvez simplement dire : "Aide-moi à créer une compétence pour relire des articles" et Claude utilisera le skill-creator pour tout générer correctement.

Transformer Tout GitHub en Votre Arsenal Personnel

C'est ici que les choses deviennent excitantes. C'est la technique qui a changé ma façon de penser aux capacités de l'IA entièrement.

Voici l'idée : En trente ans d'Internet, d'innombrables développeurs brillants ont résolu presque tous les problèmes que vous pouvez imaginer. Ils ont construit des outils, les ont mis en open source et les ont rendus disponibles pour tout le monde. Le seul problème ? La plupart de ces outils nécessitent un déploiement, des opérations en ligne de commande, une configuration de l'environnement — des barrières qui bloquent les utilisateurs ordinaires.

Les Compétences peuvent dissoudre ces barrières.

Le Concept Fondamental

Parce que les Skills peuvent empaqueter des scripts et des instructions ensemble, vous pouvez encapsuler des projets open source entiers en capacités appelables. Le code éprouvé au combat qui a été affiné par des milliers d'utilisateurs au fil des ans devient une partie de la boîte à outils de votre IA.

Exemple Réel : Téléchargement de Vidéo

Laissez-moi vous guider à travers un exemple réel. Disons que vous avez souvent besoin de télécharger des vidéos de YouTube, Bilibili et d'autres plateformes.

Étape 1 : Trouver le bon projet. Demandez à n'importe quelle IA : "Existe-t-il un projet open source sur GitHub qui télécharge des vidéos de divers sites web ?"

Elle vous dirigera vers yt-dlp — un projet légendaire avec 143 000+ étoiles qui supporte des milliers de sites web.

Étape 2 : Empaquetez-le comme une Compétence.

Help me package this open source tool https://github.com/yt-dlp/yt-dlp into a Skill, so that whenever I give a video link, it can help me download the video.

Étape 3 : Laissez Claude planifier. Utilisez d'abord le mode Plan. Claude analysera le projet, comprendra ses capacités et posera des questions de clarification sur vos préférences.

Étape 4 : Construire et tester. Passez en mode développement. En quelques minutes, vous aurez une Compétence de téléchargement vidéo fonctionnelle.

Étape 5 : Itérer basé sur la première exécution. La première fois que vous utilisez une compétence enveloppant un outil open source, vous rencontrerez des problèmes. YouTube a des mécanismes anti-crawling. Vous pourriez devoir installer des dépendances. Documentez ces expériences et dites à Claude de mettre à jour la compétence.

Update all these experiences into the video-downloader skill. Remember the Cookie requirement, the dependency installation, everything we just figured out.

La prochaine fois ? Ouvrez et téléchargez. Instantané.

Plus d'Idées pour GitHub-to-Skills

Ce ne sont que la pointe de l'iceberg. GitHub héberge des millions de projets — des décennies de génie humain, librement disponibles.

Vous n'avez pas besoin de trois têtes et six bras. Vous n'avez pas besoin de cornes sur la tête. Derrière vous se tient la connaissance accumulée de toute l'humanité au cours des dernières décennies. Tant que vous le voulez — ça peut être à vous de commander.

Construire un Système de Gestion de Compétences Auto-Évolutif

Maintenant nous entrons dans un territoire qui m'a pris deux jours entiers à comprendre. C'est ici que les Skills passent de "outils utiles" à "capacités vivantes et croissantes".

Le problème : Les Skills empaquetées à partir de projets GitHub nécessitent de la maintenance. Les dépôts originaux se mettent à jour. Des corrections de bugs arrivent. De nouvelles fonctionnalités apparaissent. Pendant ce temps, vous avez utilisé votre compétence et accumulé de l'expérience — "ce paramètre fonctionne mieux", "ajoute ce drapeau pour éviter cette erreur". Comment gérez-vous tout cela ?

La Solution en Trois Pièces

J'ai construit (avec l'aide de l'IA) un trio de compétences qui travaillent ensemble pour résoudre ceci :

Le Problème du Contrôle de Version

Voici un conflit que je n'arrêtais pas de rencontrer : Quand GitHub se met à jour, je veux récupérer le dernier code et régénérer le SKILL.md. Mais j'ai aussi itéré sur ma compétence basé sur l'expérience d'utilisation — ajustements, corrections, préférences. Ces modifications vivent dans SKILL.md aussi.

Deux forces, modifiant toutes deux le même fichier, avec des objectifs complètement différents. Désastre en attente.

La Solution : evolution.json

L'idée : Séparer les préoccupations.

Les mises à jour GitHub continuent de régénérer le fichier SKILL.md de base. Mais toute l'expérience accumulée est stockée dans un fichier evolution.json séparé. Pensez-y comme une sauvegarde de jeu. Peu importe la version à laquelle le jeu principal se met à jour, votre fichier de sauvegarde préserve votre progression.

Quand SKILL.md est écrasé par une nouvelle version, evolution.json joue son rôle — réinjectant la sagesse accumulée dans la compétence fraîche.

yt-dlp-skill/
├── SKILL.md           # Instructions de base (peuvent être régénérées)
├── evolution.json     # Expérience accumulée (préservée)
└── scripts/
    └── download.sh    # Script d'exécution

Le Volant de Gestion

Avec ces trois pièces en place, la gestion des compétences devient un cycle qui s'auto-renforce :

1. Créer de nouvelles compétences depuis GitHub en utilisant github-to-skills (avec identité intégrée)
2. Utiliser les compétences dans le travail quotidien, rencontrant des cas limites et des solutions
3. Évoluer les compétences automatiquement via skill-evolution-manager (solutions capturées)
4. Mettre à jour les compétences de base quand les dépôts GitHub se mettent à jour via skill-manager
5. Fusionner les données d'évolution dans les compétences mises à jour (expérience préservée)

Le résultat : Des compétences qui apprennent et s'améliorent véritablement. Pas métaphoriquement — réellement. Chaque fois que vous les utilisez et résolvez un problème, elles deviennent plus intelligentes.

J'ai mis ce trio en open source sur https://github.com/KKKKhazix/Khazix-Skills. Ce n'est pas parfait, mais ça marche. Et cela pointe vers quelque chose de puissant : les compétences de demain ne seront pas des documents statiques. Elles seront des systèmes vivants.

La Liste au Trésor des 14 Compétences Officielles

Avant de construire les vôtres, sachez ce qui est déjà disponible. Anthropic maintient un dépôt officiel de compétences qui couvre magnifiquement les besoins communs.

Toutes les compétences sur : https://github.com/anthropics/skills

Compétences Documents (Source Fermée)

Celles-ci alimentent la génération de documents que vous voyez dans Claude.ai :

Compétences de Développement (Apache 2.0 Open Source)

Compétences Créatives

Compétences de Communication et Méta

Méthodes d'Installation

Méthode 1 : Langage Naturel

Dites simplement à Claude : "Install this skill, project address is: [GitHub URL]"

Méthode 2 : Place de Marché Plugin

# Ajouter le dépôt officiel comme marketplace
/plugin marketplace add https://github.com/anthropics/skills

# Installer des compétences
/plugin install
# Tab vers Marketplace, sélectionner le paquet désiré

Méthode 3 : Glisser Manuel

Téléchargez le dossier de la compétence et placez-le dans votre répertoire skills (~/.claude/skills/ pour personnel, .claude/skills/ pour spécifique au projet).

L'Art des Compétences de Design - Une Analyse Approfondie

Ayant fait du design UX pendant des années, je trouve les compétences de design officielles particulièrement fascinantes. Laissez-moi décomposer les techniques qui les font si bien fonctionner. Ces modèles s'appliquent bien au-delà du design — ce sont des modèles pour toute compétence de haute qualité.

Technique 1 : Élever le Plafond

La compétence algorithmic-art ne commence pas par "aide-moi à dessiner avec p5.js". Elle commence par :

"Les philosophies algorithmiques sont des mouvements esthétiques computationnels qui sont ensuite exprimés à travers le code."

Cela élève la tâche de "générer une œuvre" à "créer un genre esthétique plus le système d'algorithmes correspondant". Cela rappelle au modèle que la sortie doit être systématique, pas une inspiration ponctuelle.

Technique 2 : Structure en Deux Étapes

Les deux compétences de design utilisent une approche en deux étapes :

1. D'abord, créer la Philosophie (cadre conceptuel en .md)
2. Ensuite, l'Exprimer visuellement (implémentation réelle)

Cela force l'abstraction avant l'implémentation. Le modèle ne peut pas tomber dans l'optimum local de "écrire du code, ajuster des valeurs". Le concept vient en premier ; le code est juste une expression.

Technique 3 : Modèles Poétiques + Ingénierie

La compétence algorithmic-art fournit une structure pour l'écriture de la philosophie :

Express how this philosophy manifests through:
- Computational processes and mathematical relationships
- Noise functions and randomness patterns
- Particle behaviors and field dynamics
- Temporal evolution and system states
- Parametric variation and emergent complexity

Notez : chaque point est à la fois langage esthétique ET objet technique. "Noise functions" correspond directement au code. "Particle behaviors" est implémentable. Cela relie la vision et l'exécution.

Technique 4 : Graines Conceptuelles

Une idée brillante des compétences officielles :

"Le concept est une référence subtile, de niche, intégrée dans l'algorithme lui-même — pas toujours littérale, toujours sophistiquée. Pensez comme un musicien de jazz citant une autre chanson à travers l'harmonie algorithmique."

Les thèmes utilisateurs devraient être intégrés dans les paramètres, les comportements, les modèles — pas écrits sur l'écran. Rendez hommage, mais cachez-le profondément. Ceux qui savent le sentiront ; ceux qui ne savent pas penseront juste que c'est beau.

Technique 5 : Modélisation avec Zones de Liberté

Les compétences définissent clairement ce qui est FIXE (mise en page, marque, contrôles) et ce qui est VARIABLE (algorithme, paramètres, couleurs). Cela assure :

• Chaque sortie a une expérience UI cohérente
• Le modèle sait exactement où il peut/ne peut pas modifier
• Réduit les "surprises" inattendues d'une interprétation trop créative

Technique 6 : L'Artisanat comme Liste de Contrôle

La compétence canvas-design encode les normes professionnelles comme des règles vérifiables :

• Rien ne tombe hors de la page
• Rien ne se chevauche
• Des marges adéquates sont non-négociables
• Le texte est toujours minimal et visuel d'abord

Cela traduit la connaissance professionnelle tacite en contraintes comportementales explicites. Le modèle peut vérifier son propre travail contre des critères concrets.

Technique 7 : Soustraction, Pas Addition

L'étape finale de raffinement est géniale :

"Pour raffiner le travail, évitez d'ajouter plus de graphiques ; raffinez plutôt ce qui a été créé. Si l'instinct est d'appeler une nouvelle fonction ou de dessiner une nouvelle forme, ARRÊTEZ."

Cela encode les "derniers 10% d'artisanat" qui séparent l'amateur du professionnel. Quand l'instinct dit "ajoute plus", demandez plutôt : Qu'est-ce qui peut être supprimé ? Qu'est-ce qui peut être aligné, fusionné, renforcé ?

Concevoir l'Architecture de Votre Bibliothèque de Compétences

Avec des douzaines de compétences, l'organisation compte. Voici comment je pense à la structuration d'une bibliothèque de compétences qui passe à l'échelle.

Pourquoi Diviser les Compétences ?

Les gens demandent souvent : "Je ne peux pas juste écrire une grosse compétence qui fait tout ?"

Non. Trois raisons :

Modèles de Types de Compétences

J'ai trouvé quatre modèles qui couvrent la plupart des cas d'utilisation :

Mon Système de Compétences d'Écriture

Comme exemple concret, voici comment j'ai structuré les compétences pour l'écriture :

P0 Compétences Core (Chaque Article)

• ai-proofreading : Processus en trois passes pour abaisser le taux de détection IA. Déclencheur : "proofread", "too AI"
• image-illustration : Générer image + télécharger sur hébergement + retourner markdown. Déclencheur : "illustrate", après relecture

P1 Compétences Régulières (La Plupart des Articles)

• topic-generator : Générer des idées de sujets basées sur les tendances. Déclencheur : "give me topics"
• long-to-x : Convertir long-format en fils Twitter. Déclencheur : "convert to X content"
• research-collector : Rassembler et organiser des matériaux de recherche. Déclencheur : "research [topic]"

P2 Compétences Occasionnelles

• headline-generator : Créer des titres accrocheurs. Déclencheur : "title ideas"
• seo-optimizer : Optimiser pour les moteurs de recherche. Déclencheur : "SEO", "optimize for search"

Gestion des Erreurs dans les Skills

L'Écosystème des Compétences en Explosion

Quand j'ai regardé les Skills pour la première fois le mois dernier, j'ai trouvé une poignée de dépôts. Maintenant ? L'écosystème a explosé. Il y a des places de marché dédiées, des répertoires curés et des dizaines de milliers de compétences contribuées par la communauté.

Points de Départ Officiels

Documentation Anthropic : https://code.claude.com/docs/en/skills

Guides clairs, étape par étape pour créer et utiliser des compétences.

Dépôt Officiel : https://github.com/anthropics/skills

Les 14 compétences officielles plus des exemples.

Standard Agent Skills : https://agentskills.io

La spécification standard ouverte. Si vous voulez comprendre la spécification technique complète, commencez ici.

Places de Marché Communautaires

Collections Curées

smithery.ai/skills — Pas beaucoup, mais chacune est vérifiée pour la qualité.

awesome-claude-skills sur GitHub — Une liste curée manuellement. Haute qualité, fréquemment mise à jour.

Répertoires Multi-outils

mcpservers.org/claude-skills — Met ensemble les serveurs MCP et les Compétences Claude. Perspective unique sur l'écosystème.

claudemarketplaces.com — Un répertoire de places de marché. La "place de marché des places de marché".

Modèles Avancés et Techniques Pro

Pour ceux qui sont prêts à aller plus loin, voici des modèles que j'ai découverts grâce à une utilisation intensive.

Injection Dynamique de Contexte

La syntaxe !`command` exécute des commandes shell avant que le contenu de la compétence n'atteigne Claude. La sortie remplace l'espace réservé.

---
name: pr-summary
description: Summarize changes in a pull request
context: fork
agent: Explore
---

## Pull request context
- PR diff: !`gh pr diff`
- PR comments: !`gh pr view --comments`
- Changed files: !`gh pr diff --name-only`

## Your task
Summarize this pull request...

Exécution Forked (Intégration Subagent)

Ajoutez context: fork pour exécuter une compétence en isolement. Le contenu de la compétence devient le prompt pilotant un sous-agent.

---
name: deep-research
description: Research a topic thoroughly
context: fork
agent: Explore
---

Research $ARGUMENTS thoroughly:

1. Find relevant files using Glob and Grep
2. Read and analyze the code
3. Summarize findings with specific file references

Substitution d'Arguments

Passez des valeurs dynamiques dans les compétences en utilisant $ARGUMENTS ou positionnels $0, $1, etc.

---
name: migrate-component
description: Migrate a component from one framework to another
---

Migrate the $0 component from $1 to $2.
Preserve all existing behavior and tests.

Mode Lecture Seule

Utilisez allowed-tools pour restreindre ce que Claude peut faire quand une compétence est active :

---
name: safe-reader
description: Read files without making changes
allowed-tools: Read, Grep, Glob
---

Explore and understand the codebase without modifying anything.

Génération de Sortie Visuelle

Les Compétences peuvent générer des fichiers HTML interactifs qui s'ouvrent dans votre navigateur. Ce modèle fonctionne pour :

• Visualisations de base de code
• Graphes de dépendances
• Rapports de couverture de tests
• Diagrammes de schéma de base de données
• Toute donnée complexe qui bénéficie d'une exploration interactive

Le script inclus fait le gros du travail ; Claude orchestre. Les utilisateurs obtiennent une sortie visuelle riche sans étapes manuelles.

Journalisation de Session

Utilisez ${CLAUDE_SESSION_ID} pour des opérations spécifiques à la session :

---
name: session-logger
description: Log activity for this session
---

Log the following to logs/${CLAUDE_SESSION_ID}.log:

$ARGUMENTS

Déclencheur Extended Thinking

L'État de la Création

Je veux terminer par quelque chose de personnel.

Chaque fois que je travaille sur les Skills, je suis transporté en été 2013. Je venais de finir les examens de fin d'études et j'avais acheté un ordinateur portable avec mes économies. J'ai passé tout cet été à bricoler des mods pour Skyrim — les téléchargeant, les combinant, ajustant les fichiers de configuration, regardant mon jeu se transformer en quelque chose d'entièrement mien.

C'était la pure joie de la création. Pas consommer du contenu. Pas faire défiler des flux. Construire réellement quelque chose, personnaliser quelque chose, faire quelque chose de mien.

Les Skills ramènent ce sentiment.

Le plus bel état du mentorat n'est pas d'avoir quelqu'un de superficiel qui a besoin d'être tenu par la main constamment. C'est de leur remettre un ensemble de manuels et de les regarder feuilleter, exécuter, s'auto-contrôler et itérer indépendamment. Vous dites moins ; ils livrent plus.

Les Compétences sont exactement cela.

Aujourd'hui, vous pourriez installer skill-creator et solidifier une action commune — peut-être examiner les hotspots pour des sujets, transformer les journaux d'erreurs en plans de réparation, ou convertir des liens en résumés. Juste une.

Quand cela fonctionne avec succès, vous comprendrez la valeur de la réutilisation.

Demain, vous en voudrez une deuxième. Le jour d'après, vous voudrez déplacer tous vos processus dedans.

À ce point, vous entrez dans un état différent.

La liberté. L'état de la création.

Ces projets open source brillants sur GitHub — des décennies de sagesse humaine, librement partagées. Grâce aux Skills, grâce aux Agents, chaque personne ordinaire peut maintenant commander ce pouvoir.

Vous n'avez pas besoin de trois têtes et six bras. Vous n'avez pas besoin de capacités surnaturelles. Derrière vous se tient la connaissance accumulée de l'humanité. Tant que vous le voulez — c'est à vous.

Si vous vous compariez maintenant à vous-même il y a trois ans, y aurait-il même une comparaison ? Regardez ce que vous pouvez faire aujourd'hui. Regardez où vos limites de capacité se sont étendues.

Cette ère brillante, magnifique qui peut rendre n'importe qui surhumain — cela ne vous excite-t-il pas ?