🚀 Compétences d’agent IA : skills réutilisables
Découvrez comment créer des compétences d’agent IA réutilisables : workflow agentique, automatisation par l’IA, sécurité et déploiement multi-clients sans confusion.

Agents IA : transformez les tâches répétées en compétences réutilisables
Si vous avez déjà dû re-détailler à un agent comment relire une modification, préparer un déploiement ou appliquer les conventions d'un projet, vous voyez le problème. Ce n'est pas seulement le temps passé à écrire des consignes. Le vrai coût, c'est la perte de contexte : une procédure peut rester « collée » à une conversation, alors que le savoir-faire d'une équipe dépend de quelques personnes disponibles.
C'est lĂ que les compĂ©tences d'agent IA — souvent appelĂ©es skills — changent la donne. L'idĂ©e est simple : formaliser des tâches rĂ©pĂ©tables dans des fichiers versionnĂ©s. Comme ça, les instructions deviennent lisibles, rĂ©visables et rĂ©utilisables par diffĂ©rents agents. En revanche, ce n'est pas une baguette magique pour rendre les agents interchangeables : outils, accès et permissions restent attachĂ©s Ă l'environnement qui exĂ©cute l'agent.
Cette distinction compte, parce qu'elle évite de confondre une consigne et une capacité réelle. Dans cet article, on va voir comment choisir un cas d'usage, organiser plusieurs compétences, séparer les règles du contexte projet, et ajouter des contrôles humains et techniques. L'objectif : automatiser une partie du travail sans perdre la main sur les décisions, les accès et les résultats.
Pourquoi créer des compétences d'agent IA réutilisables ?
Une compétence d'agent, c'est un ensemble d'instructions organisé autour d'un fichier SKILL.md. Ce fichier décrit une tâche précise : quand l'agent doit la lancer, et comment produire un résultat exploitable. Le répertoire peut aussi contenir des références ou des ressources utiles.
Le gain ne vient pas du fait « d'écrire des instructions dans un fichier ». Il vient du fait de pouvoir les relire, les corriger et les réutiliser au même endroit. Une procédure transmise jusque-là à l'oral peut devenir une base de travail partagée : tout le monde sait ce que l'agent est censé faire, et l'équipe peut faire évoluer les consignes quand les pratiques changent.
Une tâche précise, pas une description générale du métier
Une bonne compétence a un périmètre clair, des entrées identifiées et un résultat attendu. « Aider l'équipe à développer plus vite » ne dit pas grand-chose. « Vérifier qu'une modification répond à la demande initiale, puis produire des constats étayés par le code modifié » est déjà beaucoup plus testable.
Prenez un exemple : un agent de vérification indépendant. Au lieu de demander à l'agent qui a généré le code de s'auto-évaluer, la compétence peut charger un vérificateur distinct. La règle est simple : l'auto-vérification ne remplace pas une vérification indépendante. Le vérificateur reçoit la demande initiale et les modifications, puis doit appuyer ses constats sur des éléments observables.
Un en-tête minimal ressemble à ça :
---
name: verification-independante
description: Vérifie les changements générés par une IA et étaye chaque constat.
---
Ensuite, le fichier précise les conditions de déclenchement, ce qui doit être inspecté, et le format de sortie. Et c'est important : une compétence utile indique aussi ses limites (par exemple, examiner un diff sans exécuter le programme ni lancer les tests).
Quand le format est-il adapté ?
Les skills fonctionnent bien pour des travaux bornés et répétables, surtout quand la tâche bénéficie d'un jugement réutilisable : appliquer une checklist de mise en production, préparer une migration, vérifier des changements, ou construire un pipeline de métriques.
En revanche, ça ne remplace ni une application complète, ni une procédure métier réglementée. Et le coût n'est pas « magiquement nul » : il faut maintenir les fichiers, les tester sur des cas variés, et revoir les résultats. Une compétence non contrôlée peut juste rendre une mauvaise pratique plus facile à répéter.
Comment structurer plusieurs compétences dans un workflow ?
Une tâche complexe n'a pas besoin de devenir une compétence monolithique. Si une chaîne de traitement comporte plusieurs étapes, séparez-les quand chaque étape a sa propre responsabilité et peut évoluer sans bloquer le reste. Le bénéfice est concret : vous localisez plus facilement les erreurs, et vous gardez les consignes plus faciles à maintenir.
Imaginons un pipeline qui produit des indicateurs à partir de données de support. La demande porte sur le nombre d'incidents créés et résolus. Avant de construire le pipeline, une compétence d'initialisation inspecte le projet : elle repère les tables sources, les conventions de nommage et la plateforme utilisée. Elle consigne ensuite ces informations dans un manifeste, que les autres compétences utiliseront.
La compétence de construction coordonne alors l'ensemble : de la demande initiale jusqu'à une proposition de pull request. Elle s'appuie sur une compétence pour accéder aux données, et sur une autre pour appliquer les règles de qualité de l'équipe. Le résultat attendu peut inclure le code du pipeline, les modifications de schéma et les tests, et une personne examine ce qui a été décidé avant intégration.
Des responsabilités explicites et des entrées partagées
Chaque compétence doit pouvoir être comprise sans avoir à relire tout le workflow. Une répartition possible :
- Initialisation : découvrir les éléments du projet et produire un manifeste à valider.
- Accès aux données : fournir un chemin commun pour interroger la plateforme.
- Contrôle qualité : appliquer des règles explicites au code ou aux schémas.
- Construction : coordonner les étapes et préparer les changements pour revue.
Les compétences partagent le contexte au lieu de le redécouvrir chacune de leur côté. Si la convention de nommage change, on ajuste le manifeste (ou la compétence concernée) plutôt que de réécrire tout le processus. Oui, il y a une limite : multiplier des petites compétences peut aussi créer des dépendances et rendre la coordination pénible. Le bon réflexe : découpez seulement si ça rend les responsabilités plus lisibles ou les changements plus localisés.
Prévoir un résultat vérifiable à chaque étape
Un workflow solide dit ce qui doit être vrai avant de passer à l'étape suivante. Par exemple, la compétence de construction ne devrait pas « supposer » qu'un schéma a été validé si cette validation n'a pas eu lieu. Elle peut vérifier qu'un état explicite existe dans le manifeste, ou demander une décision humaine.
Cette approche évite de traiter une suite de prompts comme un processus fiable « par défaut ». Le workflow doit décrire les entrées, les sorties, les dépendances et les points d'arrêt. Si plusieurs personnes doivent examiner une proposition, le résultat doit être assez structuré pour montrer ce qui a été décidé, ce qui reste incertain, et sur quelles données l'agent s'est appuyé.
Comment séparer instructions et contexte projet ?
Une compĂ©tence rĂ©utilisable ne devrait pas enfermer en dur le nom de toutes les bases de donnĂ©es, les tables d'une Ă©quipe donnĂ©e ou les conventions d'un seul dĂ©pĂ´t. Sinon, le fichier dĂ©crit plutĂ´t une configuration locale qu'une mĂ©thode. Et Ă chaque nouveau projet, il faudra le modifier — avec le risque de crĂ©er des variantes difficiles Ă maintenir.
La bonne séparation : distinguer les règles de travail de ce qui dépend du projet. Les instructions expliquent comment faire. Le manifeste décrit les infos propres au projet : tables disponibles, environnement de données, conventions repérées, paramètres nécessaires. Les compétences lisent ce manifeste au moment de l'exécution.
Distinguer ce qui est observé de ce qui est une règle
Une compétence d'initialisation peut examiner les schémas et le code existants. Mais une pratique « vue » dans un dépôt n'est pas automatiquement une règle à conserver. Elle peut être obsolète, accidentelle, ou en contradiction avec une décision métier récente.
C'est pour ça que les informations dĂ©couvertes doivent rester visibles et rĂ©visables. Le manifeste sert de point de contrĂ´le : l'agent peut proposer une configuration, mais une personne valide ou corrige quand un jugement mĂ©tier est nĂ©cessaire. Les standards de l'Ă©quipe, eux, doivent ĂŞtre prĂ©sentĂ©s comme des règles assumĂ©es — par exemple dans une compĂ©tence de contrĂ´le qualitĂ©.
Cette séparation aide aussi la gouvernance des données. Dans une entreprise française soumise au RGPD, une instruction ne suffit pas à autoriser l'accès à des données personnelles. Le manifeste peut mentionner une source, mais la base de données, les rôles d'accès, la durée de conservation et les restrictions de traitement doivent être gérés par les systèmes et les responsables concernés. Les obligations ne disparaissent pas parce qu'on délègue à un agent.
Un test pratique de portabilité
Posez-vous une question simple : une autre équipe pourrait-elle réutiliser ces compétences avec son propre manifeste, sans réécrire les consignes centrales ? Si la réponse est non, les détails du projet sont probablement trop intégrés aux instructions.
Attention aussi à l'autre excès : le manifeste ne doit pas devenir un fourre-tout. Gardez ce dont vous avez besoin pour exécuter et vérifier, dans un format clair, avec une responsabilité explicite de mise à jour. Trop peu de contexte pousse l'agent à deviner ; trop de contexte augmente le risque d'avoir des informations obsolètes ou contradictoires. La « bonne quantité », c'est celle qui permet de choisir une action sans vendre une supposition comme un fait.
Comment garder le contrôle sur l'exécution ?
Un fichier d'instructions ne donne pas, à lui seul, les outils, les identifiants ou les autorisations à un agent. Une compétence peut décrire comment interroger une base de données ; elle ne peut pas accorder l'accès à cette base. C'est l'environnement d'exécution qui reste responsable : outils disponibles, secrets et permissions.
Cette séparation est centrale pour la sécurité. Par exemple, si un manifeste sélectionne DuckDB pour une démonstration locale, ça ne veut pas dire que son interface en ligne de commande est installée, ni que les données sont accessibles. Le manifeste décrit le moteur attendu ; l'hôte fournit l'environnement et les accès. Même logique pour un entrepôt de données en entreprise ou un système utilisé par une équipe financière.
Ajouter des points de validation lĂ oĂą le risque change
Découpez le workflow en phases, avec des vérifications avant chaque transition. Pour une modification de schéma, une approbation humaine peut être nécessaire avant application. Ce contrôle a du sens quand l'action a un effet durable, touche des données sensibles, ou nécessite un jugement métier.
Le piège, c'est d'être uniforme : demander une approbation à chaque étape sans enjeu crée de la friction et finit par encourager les contournements. À l'inverse, laisser l'agent modifier directement une structure de production sans validation transforme une erreur de consigne en incident opérationnel. Le niveau de contrôle doit suivre l'impact possible, pas le « niveau d'autonomie » affiché par l'outil.
Faire porter les garanties par les bons systèmes
Pour vérifier du code, un agent indépendant peut produire un résultat PASS, FAIL ou PARTIAL, avec des éléments précis à l'appui. Mais si le contrôle ne fait qu'examiner un diff, il ne prouve pas que le code s'exécute correctement. Il faut distinguer analyse statique, tests, contrôles de sécurité, et revue humaine.
Et les consignes de la compétence ne remplacent pas les exigences de CI. Si un échec doit bloquer une fusion, cette règle doit vivre dans les contrôles et règles du dépôt. Si le résultat est juste informatif, le dire clairement. Une architecture responsable combine instructions pour guider l'agent, tests pour vérifier les changements, et règles d'accès pour limiter ce qu'il peut faire.
La limite est nette : si votre processus exige un état partagé fiable, une interface stable, une piste d'audit, une exécution longue, ou des permissions appliquées indépendamment du modèle, une application ou un service dédié est souvent plus adapté. Les skills peuvent compléter, mais pas remplacer ces garanties.
Comment déployer les compétences sur plusieurs agents ?
La portabilité des instructions ne suffit pas : les agents peuvent ne pas se comporter exactement pareil. Les clients peuvent fournir des modèles, des outils, des formats et des permissions différents. Résultat : un même fichier peut être interprété différemment, ou ne pas être chargé du tout.
Pour éviter de maintenir plusieurs copies à la main, gardez une source de référence commune, par exemple skills/*/SKILL.md, puis générez les fichiers attendus pour chaque client. Un script de packaging peut produire les formats adaptés aux environnements utilisés et proposer un mode de vérification pour l'intégration continue. L'idée : maintenir une source, sans supposer que tous les clients partagent le même format.
Vérifier la chaîne de bout en bout
Après installation, ne vous contentez pas de vérifier que le fichier existe. Testez chaque compétence dans le client ciblé et contrôlez qu'elle :
- est reconnue pour le cas d'usage attendu ;
- charge bien les références nécessaires ;
- dispose des outils et accès requis dans cet environnement ;
- respecte les étapes d'approbation prévues ;
- produit les éléments de preuve attendus.
Ces vérifications doivent couvrir les erreurs fréquentes : manifeste absent, outil indisponible, réponse partielle, information de projet contradictoire ou refus d'accès. Un test réussi en local ne prouve pas que tout fonctionnera pareil chez un autre client ou sur un poste « d'entreprise ».
Mettre en place une maintenance proportionnée
Les compétences évoluent avec le code, les normes internes et les outils. Traitez-les comme des configurations importantes : revue de changement, historique dans le système de gestion de versions, tests sur des cas représentatifs. Commencez petit : cas nominal, entrée incomplète, et situation où l'agent doit s'arrêter plutôt que deviner.
La portabilité se mesure donc à plusieurs niveaux : les instructions peuvent être réutilisables, tandis que les outils, les accès et les garanties restent spécifiques à l'hôte. C'est une frontière saine, pas un défaut à corriger « avec plus de magie ». Elle permet de partager le savoir-faire sans prétendre que les permissions et les résultats sont identiques partout.
Commencez par la tâche que vous expliquez le plus souvent. Dites clairement ce qu'elle reçoit, ce qu'elle doit produire, où elle s'arrête, et ce qu'un réviseur doit pouvoir vérifier. Puis faites-la tester par une autre personne (ou un autre agent), corrigez les ambiguïtés, avant d'intégrer le tout à un processus plus large.
Conclusion
Les compétences d'agent IA sont vraiment utiles quand elles transforment un travail répétitif en instructions versionnées, claires et révisables. Leur valeur dépend moins de leur « complexité » que de la qualité du périmètre : une tâche identifiable, un contexte explicite, un résultat vérifiable et des limites assumées.
SĂ©parez les consignes du contexte projet, partagez les chemins d'exĂ©cution via les compĂ©tences adaptĂ©es, et placez les contrĂ´les lĂ oĂą les systèmes peuvent les faire respecter. Commencez petit, testez avec un autre agent, et gardez une validation humaine quand les dĂ©cisions engagent des donnĂ©es, des utilisateurs ou la production. C'est comme ça qu'un savoir-faire rĂ©utilisable devient un processus maĂ®trisĂ© — et pas une couche d'automatisation opaque.