Skills IA : à quoi servent-elles et comment les installer ?

Depuis quelques mois, je vois passer de plus en plus de Skills pour agents IA sur LinkedIn, X ou GitHub. Une Skill pour écrire les specs d'une fonctionnalité, ajouter des animations à une interface, préparer une campagne marketing, etc.

Dans cet article, je vais expliquer ce que sont réellement les Skills IA, où les trouver, comment les évaluer et les installer. Nous créerons aussi une première Skill simple, avant d'aborder un problème que je rencontre : leur gestion dans plusieurs outils IA.

Nous discuterons aussi de leurs limites. Le discours qui accompagne ces publications promet souvent beaucoup : il suffirait d’installer quelques Skills pour rendre Claude, Codex ou Cursor immédiatement meilleur dans de nombreux domaines. La réalité est plus nuancée.

Une Skill ne modifie pas le modèle et ne lui apprend pas soudainement une nouvelle discipline. Elle lui fournit une méthode, des instructions et éventuellement des ressources qu'il peut charger lorsqu'une demande correspond. Certaines sont très utiles. D'autres se limitent à un prompt bien présenté. Et les installer sans les lire revient à confier des instructions inconnues à un agent qui peut accéder à vos fichiers et exécuter des commandes.

Une Skill IA est un dossier que l'agent sait charger

Le format public Agent Skills définit une Skill comme un dossier contenant au minimum un fichier SKILL.md.

Ce fichier décrit :

• le nom de la Skill ;
• les situations dans lesquelles elle doit être utilisée ;
• les instructions que l'agent doit suivre ;
• le format du résultat attendu ;
• les limites et les erreurs à éviter.

Le dossier peut également contenir des scripts, des exemples, de la documentation ou d'autres ressources :

ma-skill/
├── SKILL.md
├── scripts/
├── references/
└── assets/

Une Skill dédiée à la création de présentations peut ainsi inclure une méthode de narration, des modèles de slides et un script de génération. Une Skill Nuxt peut rappeler les conventions du framework, indiquer les fichiers à inspecter et fournir des exemples adaptés à une version précise.

Le point important est que l'agent ne charge pas nécessairement tout ce contenu dans chaque conversation. Le format repose sur une divulgation progressive :

1. l'agent découvre d'abord le nom et la description de la Skill ;
2. il charge le contenu de SKILL.md lorsque la demande semble correspondre ;
3. il consulte les scripts ou les ressources complémentaires seulement s'ils deviennent utiles.

Cette logique permet de conserver un agent généraliste sans remplir son contexte avec toutes les méthodes possibles. J'avais déjà présenté ce mécanisme dans ma méthode de context engineering pour les agents IA : les Skills constituent une partie du contexte dynamique, chargé à la demande.

Une Skill n'est ni un prompt, ni un MCP

La confusion est compréhensible, car chaque mécanisme peut influencer le comportement de l'agent.

Un prompt peut demander à l'agent de relire une spec. Une Skill peut lui apprendre comment mener cette revue, quels cas limites rechercher et comment structurer son compte rendu.

Un serveur MCP peut lui donner accès à GitHub, à une base de données ou à un outil SEO. La Skill peut ensuite expliquer dans quel ordre utiliser ces capacités et comment interpréter leurs résultats. Ma page consacrée au développement de serveurs MCP pour les SaaS présente ce que ce standard permet de construire.

Une formule résume bien la différence :

Un outil donne à l'agent les moyens d'agir. Une Skill lui transmet une manière de travailler.

Mais une Skill peut aussi contenir des scripts. Elle ne doit donc pas être considérée comme un simple document sans conséquence.

Pourquoi voit-on autant de Skills publiées ?

Une méthode stockée dans une conversation reste prisonnière de cette conversation. Un fichier SKILL.md peut être relu, corrigé, versionné dans Git et partagé avec d'autres personnes.

Le format intéresse donc plusieurs profils :

• les éditeurs qui veulent expliquer à un agent comment utiliser correctement leur produit ;
• les développeurs qui publient une méthode spécialisée ;
• les équipes qui souhaitent partager les mêmes workflows ;
• les utilisateurs qui veulent enrichir leurs agents sans réécrire leurs instructions ;
• les créateurs qui rassemblent plusieurs Skills dans un même dépôt.

Cette portabilité explique l'apparition d'annuaires comme skills.sh, de dépôts GitHub spécialisés et de nombreuses listes communautaires.

Elle ne garantit pourtant pas qu'une Skill soit compatible avec tous les agents. Le cœur du format est commun, mais une Skill peut supposer la présence d'un outil, d'une commande, d'un chemin ou d'une fonctionnalité propre à Claude Code, Codex ou Cursor.

Je distingue donc trois niveaux :

1. Le format est compatible : l'agent sait découvrir et lire le fichier SKILL.md.
2. Les instructions sont portables : elles ne dépendent pas d'un comportement propre à un outil.
3. La Skill fonctionne réellement : ses scripts, outils et dépendances sont disponibles dans votre environnement.

Voir le logo de plusieurs agents sur une page ne remplace pas cette vérification.

Où trouver des Skills IA ?

Je commence toujours par la source la plus proche du sujet.

Pour un framework ou un produit, je cherche d'abord une Skill publiée par son éditeur ou par son équipe. Pour une méthode plus générale, je regarde le profil de l'auteur, son dépôt GitHub et les autres projets qu'il maintient.

Les principales sources sont aujourd'hui :

• les dépôts officiels de produits et frameworks ;
• le dépôt de Skills publié par Anthropic ;
• les annuaires comme skills.sh ;
• les dépôts GitHub regroupant plusieurs Skills ;
• les Skills internes créées pour une équipe ou un projet.

Un classement populaire peut aider à découvrir un projet, mais il ne constitue pas un audit. Avant d'installer une Skill, j'ouvre son dossier.

Ce que je vérifie avant d'installer une Skill

Le fichier SKILL.md est le premier élément à lire, pas le dernier.

La description correspond-elle à mon besoin ?

La description sert souvent de mécanisme de déclenchement. Elle doit dire ce que fait la Skill et dans quelles situations l'utiliser.

Une description comme « améliore le code » est trop vague. Elle risque de ne jamais être sélectionnée, ou de l'être sur presque toutes les tâches.

Une description précise ressemble plutôt à :

Utilise cette Skill pour relire une spec produit ou un PRD avant implémentation. Repère les décisions manquantes, les cas limites et les critères d'acceptation.

La documentation Agent Skills recommande d'ailleurs de tester les descriptions avec des demandes qui doivent déclencher la Skill et d'autres qui ne le doivent pas.

Les instructions sont-elles compréhensibles ?

Je cherche un workflow explicite, un résultat vérifiable et des limites claires. Une longue liste de principes génériques apporte peu de valeur si elle ne change aucune décision de l'agent.

Une bonne Skill ne se contente pas de demander « sois rigoureux ». Elle décrit les étapes de la rigueur attendue.

Le dossier contient-il des scripts ?

Je regarde l'ensemble de l'arborescence, pas uniquement SKILL.md.

Un script peut être légitime pour convertir un fichier ou appeler un outil local. Mais je vérifie :

• les commandes exécutées ;
• les fichiers lus ou modifiés ;
• les accès au réseau ;
• l'utilisation de variables d'environnement ;
• les dépendances téléchargées ;
• les endroits où des données pourraient être envoyées.

Une Skill s'exécute avec les permissions accordées à l'agent. Un texte malveillant ou un script caché peut donc chercher à lire des secrets, modifier des fichiers ou contourner vos instructions.

La source est-elle identifiable et maintenue ?

Je regarde l'auteur, la licence, l'historique des modifications et les issues du dépôt. Une Skill courte n'a pas besoin de milliers d'étoiles, mais je veux comprendre qui la publie et ce que j'installe.

Surtout, la facilité d'installation ne doit jamais être confondue avec la confiance.

Comment installer une Skill

Il existe deux approches principales : utiliser un outil d'installation ou placer manuellement le dossier au bon endroit.

Installer une Skill avec npx skills

Le CLI associé à skills.sh peut importer les Skills d'un dépôt GitHub :

npx skills add owner/repo

Vous remplacez owner/repo par le propriétaire et le nom du dépôt indiqués sur la page de la Skill. Lorsqu'un dépôt en contient plusieurs, vous pouvez cibler une Skill :

npx skills add owner/repo --skill nom-de-la-skill

Le CLI analyse le dépôt et vous permet de sélectionner la Skill et les agents concernés. Lisez malgré tout les fichiers sur GitHub avant de lancer la commande : npx télécharge et exécute un programme, puis l'installateur écrit dans vos dossiers locaux.

Cette méthode convient lorsque la source fournit explicitement la commande et que vous êtes à l'aise avec le terminal.

Installer le dossier manuellement

Une installation manuelle consiste à télécharger ou cloner le dossier de la Skill, puis à le placer dans un emplacement lu par votre agent.

Au moment où j'écris cet article, les principaux chemins globaux sur macOS sont :

Certains agents acceptent également des Skills propres à un projet, par exemple dans .agents/skills/. Elles restent alors versionnées avec le dépôt et ne s'appliquent qu'à ce projet.

Les emplacements et les mécanismes de détection évoluent encore. Vérifiez la documentation de votre agent si la Skill n'apparaît pas, en particulier après une mise à jour de l'outil.

Vérifier que la Skill se déclenche

Après l'installation, ouvrez une nouvelle conversation et formulez une demande naturelle correspondant à sa description.

Si la Skill est censée relire une spec produit, ne commencez pas par demander :

Utilise review-feature-spec.

Demandez plutôt :

Relis cette spec avant que nous commencions l'implémentation. Trouve les décisions manquantes, les cas limites et les critères d'acceptation.

Ce test vérifie le mécanisme le plus important : l'agent reconnaît-il le besoin sans que vous lui donniez le nom exact de la Skill ?

Je teste ensuite une demande proche qui ne doit pas la déclencher, par exemple une simple correction orthographique. Si la Skill intervient malgré tout, sa description est probablement trop large.

L'affichage varie selon les outils : certains indiquent la Skill chargée, d'autres rendent ce mécanisme moins visible. Dans tous les cas, vérifiez surtout que le workflow attendu apparaît dans le résultat.

Créer une première Skill pour comprendre le format

Utiliser une Skill publiée est le point d'entrée le plus rapide. En créer une petite permet toutefois de comprendre ce que vous installez.

Je vais prendre un exemple lié à mon travail de Product Engineer : relire une spec de fonctionnalité avant de confier son implémentation à un agent.

Créez ce dossier :

review-feature-spec/
└── SKILL.md

Puis ajoutez ce contenu :

---
name: review-feature-spec
description: Utilise cette Skill pour relire une spec produit, un PRD
  ou un ticket détaillé avant implémentation. Repère les décisions
  manquantes, les risques, les cas limites et les critères
  d'acceptation, puis propose un plan de validation sans modifier le code.
---

# Relire une spec de fonctionnalité

## Objectif

Rendre le périmètre, les décisions et la validation explicites
avant l'implémentation.

## Workflow

1. Lire la spec et identifier la source qui fait foi.
2. Résumer le problème utilisateur, le résultat attendu et le hors-périmètre.
3. Distinguer les décisions explicites, les hypothèses et les recommandations.
4. Repérer les informations manquantes qui modifieraient l'interface,
   les données ou l'architecture.
5. Vérifier le parcours principal, les erreurs, les permissions,
   l'accessibilité, les langues et les dépendances externes.
6. Transformer les exigences vérifiables en critères d'acceptation.
7. Proposer un plan de validation proportionné au risque.
8. Poser une question lorsqu'une décision manquante changerait l'implémentation.

## Format de sortie

### Résumé
### Décisions déjà prises
### Questions bloquantes
### Cas limites et risques
### Critères d'acceptation
### Plan de validation

## Règles

- Ne pas commencer l'implémentation.
- Ne pas inventer une exigence absente.
- Distinguer un fait, une hypothèse et une recommandation.
- Signaler les contradictions au lieu de les arbitrer silencieusement.

La spécification du format Agent Skills impose quelques règles au frontmatter, notamment un nom en minuscules et une description non vide. Elle recommande aussi de garder les instructions principales compactes et de déplacer les longues références dans des fichiers séparés.

Cette première version n'a besoin d'aucun script. Je peux la lire en quelques minutes, anticiper son comportement et l'améliorer lorsque j'observe un échec réel.

Dans mon workflow, la Skill pourrait relire les specs Markdown que je construis avec Codex ou Claude Code et que j'affiche dans Fude, mon lecteur Markdown pensé pour les agents IA.

Le vrai problème commence avec plusieurs agents

Installer une Skill est assez direct. En maintenir une liste dans Claude, Codex, Cursor et d'autres outils devient vite opaque et chronophage.

Chaque agent peut utiliser un dossier différent. Certains lisent aussi le chemin partagé ~/.agents/skills, d'autres non. Une Skill peut exister en version globale et dans un projet. Une copie est mise à jour pendant qu'une autre reste ancienne. Sur un deuxième Mac, il faut reconstruire le même environnement.

Au bout de quelques semaines, des questions très simples deviennent difficiles :

• Quelles Skills ai-je installées ?
• Dans quels agents sont-elles disponibles ?
• Quelle copie constitue la version de référence ?
• Une mise à jour existe-t-elle ?
• Que contient réellement cette Skill ?

Ces questions m'ont motivé à créer un outil dédié à la gestion des Skills.

Liblio.ai Sync, l'application pour gérer facilement ses Skills

Liblio.ai Sync est une application gratuite que je développe d’abord pour Mac, avec une version Windows prévue ensuite, pour installer, mettre à jour et visualiser ses Skills sans manipuler des dossiers cachés, des liens symboliques, Git ou des commandes dans le terminal.

La première version doit permettre :

• d'importer une Skill depuis un dossier local, une URL GitHub publique ou une commande skills.sh
• de conserver ses Skills dans un dossier Liblio.ai Sync local ou synchronisé par un service comme iCloud Drive, Google Drive ou Dropbox
• de les rendre disponibles dans vos outils comme Claude, Codex, Cursor, Antigravity, Devin et OpenCode
• de visualiser leur contenu et leur source
• de détecter les mises à jour et de demander confirmation avant de les installer
• de repérer et réparer certains problèmes de chemins ou de liens

L'application est en développement. L'objectif initial est de rendre visible et maîtrisable un environnement aujourd'hui dispersé dans plusieurs dossiers.

Liblio.ai Sync simplifiera la gestion des Skills, mais ne certifiera pas leur sécurité. La vérification de leur source, de leurs instructions et de leurs scripts restera donc nécessaire.

Les Skills deviennent une nouvelle couche de nos outils IA

Les Skills ne sont ni des applications complètes, ni un entraînement supplémentaire du modèle. Elles sont un format léger pour distribuer des instructions, des méthodes et des ressources que l'agent charge à la demande.

Pour commencer, je recommande une progression simple :

1. choisissez une Skill issue d'une source identifiable ;
2. lisez son SKILL.md et les scripts associés ;
3. installez-la dans un seul agent ;
4. testez une demande qui doit la déclencher et une autre qui ne le doit pas ;
5. observez si elle améliore réellement le résultat avant d'en ajouter dix autres.

Une collection impressionnante de Skills n'apporte rien si personne ne sait lesquelles sont actives, fiables ou à jour. Leur valeur vient moins de leur quantité que de la qualité des comportements qu'elles rendent répétables.

Ce travail de structuration et d'arbitrage est aussi au cœur du rôle de Product Engineer à l'ère de l'IA. C'est le type de workflow que je conçois dans mes missions de Product Engineering.

Et vous, quelles sont les premières Skills que vous avez installées dans vos agents IA ?

Questions fréquentes sur les Skills IA

Qu'est-ce qu'une Skill IA ?

Quelle différence entre une Skill, un prompt et un MCP ?

Où trouver des Skills IA ?

Peut-on utiliser la même Skill dans Claude Code, Codex et Cursor ?

Faut-il savoir programmer pour utiliser une Skill ?