Agent-skills d’Addy Osmani : la nouvelle norme de production pour les agents IA

14 000 étoiles GitHub en quelques semaines. Le projet agent-skills d’Addy Osmani, ancien ingénieur senior de Google Chrome aujourd’hui chez Anthropic, encode 20 compétences d’ingénierie et 7 commandes slash dans un format que tous les agents IA peuvent consommer. L’objectif : transformer des assistants rapides mais brouillons en collaborateurs qui suivent vraiment les standards d’un ingénieur senior. Voici pourquoi cette publication change la manière dont les équipes pilotent leurs agents IA en 2026, et comment l’adopter sans tout réécrire.

Temps de lecture : 12 min

Pourquoi un ingénieur de Google a créé agent-skills

Addy Osmani a passé une grande partie de sa carrière chez Google, notamment comme directeur de l’ingénierie sur Chrome et Web Platform. En 2026, il rejoint Anthropic et observe une fracture entre la vitesse d’écriture de code des agents IA et la rigueur d’ingénierie attendue en production. Une fonctionnalité peut être livrée en deux minutes, mais sans tests, sans spécification écrite, sans revue de code et sans documentation de décision. Ce constat a déclenché la création d’agent-skills, un projet open source qui formalise les workflows qu’un ingénieur senior suit naturellement.

Le constat : la vitesse sans discipline

Les agents IA produisent du code rapidement, mais ils empruntent par défaut le chemin le plus court. Ils ignorent souvent l’écriture d’une spécification, la décomposition en tâches, l’écriture de tests préalables ou la documentation des décisions architecturales. La rationalisation classique, « j’ajouterai les tests plus tard », crée une dette technique à vitesse machine. Cette dérive est documentée dans plusieurs retours d’expérience publiés sur Rushi’s blog et dans la newsletter substack d’Osmani.

L’ambition : un standard transposable

Plutôt que de réinventer un framework propriétaire, agent-skills reprend les principes éprouvés du livre Software Engineering at Google et les traduit en fichiers Markdown que n’importe quel agent peut lire. La licence MIT autorise l’usage commercial, le fork et la modification. Cette ouverture explique pourquoi des équipes très différentes adoptent le projet, des startups solo aux grandes équipes plateforme. La logique de skills réutilisables rejoint celle que nous décrivons dans notre guide complet des commandes Claude Skills.

Comment sont structurés les 20 skills

Le cœur du projet repose sur six phases du cycle de développement logiciel, chacune contenant plusieurs skills atomiques. La séquence DEFINE → PLAN → BUILD → VERIFY → REVIEW → SHIP impose une discipline de bout en bout. Chaque skill suit la même anatomie : une frontmatter de métadonnées, une description, des conditions de déclenchement, des étapes de processus, une table d’anti-rationalisation et des exigences de preuves de sortie.

Les six phases d’agent-skills et leurs skills associés

Phase	Objectif	Exemples de skills
DEFINE	Cadrer le besoin avant le code	spec-writing, requirements-clarification, ADR
PLAN	Découper en tâches contextualisées	planning-and-task-breakdown, dependency-tracking
BUILD	Implémenter par tranches verticales	incremental-implementation, test-first-development
VERIFY	Apporter des preuves d’exécution	verification-evidence, test-coverage
REVIEW	Auditer code, sécurité, performance	code-review-and-quality, security-audit
SHIP	Déployer avec traçabilité	release-checklist, post-deployment-monitoring

Frontmatter, conditions de déclenchement et preuves

Le frontmatter d’un skill contient son nom, sa description et la liste des outils requis. Les conditions de déclenchement décrivent quand le skill doit s’activer automatiquement. Cette mécanique de progressive disclosure permet à l’agent de charger uniquement les références utiles, ce qui économise des tokens. À la fin, des évidences exigées (tests qui passent, sortie de build, données de runtime) ferment la boucle. Une simple confirmation orale n’est jamais suffisante.

Trois personas spécialisées et quatre checklists

Au-delà des 20 skills principaux, le projet propose trois personas d’agents spécialisés : un reviewer de code orienté Senior Staff Engineer, un ingénieur QA centré sur la stratégie de tests et un auditeur sécurité. Quatre checklists complètent la mécanique pour les revues, les déploiements et les audits. Les développeurs qui pilotent déjà Claude Code en mode skills et sub-agents peuvent activer ces personas comme des subagents nominaux.

L’arme secrète : la table d’anti-rationalisation

L’élément le plus original d’agent-skills est la table d’anti-rationalisation présente dans chaque skill. Elle liste les excuses classiques qu’un agent IA pourrait invoquer pour sauter une étape, et propose une réfutation argumentée. Cette table est lue par l’agent avant qu’il puisse engager un raccourci, ce qui réduit considérablement les rationalisations stéréotypées.

Exemple : la rationalisation des tests reportés

Le skill de tests inclut l’excuse « j’ajouterai les tests plus tard » avec la réfutation suivante : les tests écrits après l’implémentation testent le comportement du code et non ses exigences, ce qui produit des tests fragiles qui passent aujourd’hui et cassent au premier refactor. La table couvre aussi les rationalisations de simplification (« ce code est complexe, je vais le simplifier ») en s’appuyant sur le principe de Chesterton’s Fence : comprendre pourquoi un code existe avant de le modifier.

Pourquoi cette mécanique fonctionne

Les agents IA ne sont pas malhonnêtes, mais ils suivent la pression du contexte. Quand la fenêtre de tokens se remplit ou quand des instructions contradictoires apparaissent, ils privilégient la sortie la plus économique. Pré-écrire les contre-arguments dans le skill change la donne car l’agent a déjà digéré la réfutation avant de pouvoir produire la rationalisation. Sans être infaillible, cette technique réduit nettement les coupes de coin selon les retours collectés.

Trois modes d’installation pour tous les agents IA

Agent-skills se distingue par sa portabilité. Osmani propose trois modes d’adoption qui couvrent presque tous les scénarios. Le projet ne dépend ni d’un SDK, ni d’un runtime particulier, juste de la capacité de l’agent à lire des fichiers Markdown.

Mode 1 : marketplace de plugins Claude Code

Pour les utilisateurs de Claude Code, l’installation se fait en deux commandes via la marketplace de plugins. L’agent récupère les commandes slash (/spec, /plan, /build, /test, /review, /ship, /code-simplify) et active automatiquement les skills pertinents en fonction du contexte. C’est le chemin recommandé pour démarrer rapidement, sans configuration manuelle.

Mode 2 : copie directe dans l’outil cible

Pour les utilisateurs de Cursor, les skills sont copiés dans le dossier .cursor/rules/. Gemini CLI dispose de son propre chemin d’installation. Codex, Aider, Windsurf, OpenCode ou tout système qui accepte un system prompt peut consommer les fichiers Markdown bruts. La portabilité ne dépend pas du tooling mais du workflow encodé dans les skills.

Mode 3 : lire les skills comme une spécification

Même sans installation, les skills constituent une description documentée de ce qu’est une bonne ingénierie assistée par agent. Lire le skill code-review-and-quality.md et appliquer son framework à cinq axes au sein d’une équipe humaine est déjà une victoire. Cette approche se rapproche de la philosophie défendue par Jesse Vincent dans Superpowers, qui promeut le partage explicite des méthodes plutôt que la réinvention permanente.

Quel impact pour les équipes en 2026

L’adoption d’agent-skills dépasse les usages individuels. Plusieurs équipes rapportent une réduction notable de la dette technique générée par les agents IA. Le simple fait d’imposer la phase DEFINE avant le code change la nature des sorties produites par Claude, GPT ou Gemini.

Réduction de la dette technique générée par IA

Sans cadre, les agents produisent rapidement des montagnes de code testé sur le happy path mais qui s’effondre dès qu’un utilisateur réel interagit avec lui. Agent-skills impose la rédaction d’une spec, la décomposition en tâches mesurées (cinq fichiers maximum par tâche), l’incrémental avec tests et la revue avant ship. Cette discipline transforme un agent rapide en collaborateur fiable, comme le détaille notre catalogue des LLM apps open source.

Standardisation cross-équipes

Pour les organisations qui pilotent dix ou cent développeurs, agent-skills offre une grammaire commune. Tous les agents suivent les mêmes phases, produisent les mêmes types d’évidences et passent par les mêmes gates de vérification. Les revues humaines deviennent plus rapides car le format des outputs est prévisible. Les ADR (Architecture Decision Records) accumulés deviennent un patrimoine durable de l’équipe, indépendant du modèle IA utilisé.

Compatibilité avec les architectures multi-agents

Le projet s’articule particulièrement bien avec les architectures multi-agents que nous avons détaillées dans notre guide n8n MCP avec Claude. Les trois personas spécialisées (reviewer, QA, sécurité) peuvent être instanciées en parallèle sur des git worktrees distincts. Chaque agent travaille dans son périmètre, lit ses skills dédiés et produit ses preuves sans collision avec les autres.

Mettre agent-skills en pratique en moins d’une heure

L’adoption d’agent-skills suit un parcours simple, mais les premières heures déterminent la suite. Voici la méthode utilisée par plusieurs équipes que nous accompagnons en cabinet.

Étape 1 : auditer ses workflows actuels

Avant d’installer quoi que ce soit, lister les phases que l’équipe traite déjà. Spec écrite ? Décomposition en tâches ? Tests pré-implémentation ? Revue formalisée ? Cette cartographie identifie les trois ou quatre skills qui apporteront le plus de valeur immédiate. Notre Diagnostic IA gratuit intègre désormais une grille adaptée pour ce type d’audit.

Étape 2 : installer le mode adapté

Claude Code donne le démarrage le plus rapide grâce à la marketplace officielle. Cursor demande une copie manuelle dans .cursor/rules/. Pour les équipes mixtes (plusieurs outils en parallèle), la copie dans un dossier .ai/skills/ versionné dans Git assure la cohérence. Les détails de configuration sont documentés dans le repo officiel.

Étape 3 : itérer sur deux semaines

La première semaine, observer comment l’agent applique les skills. La deuxième semaine, ajuster les frontmatters pour mieux correspondre au contexte de l’équipe. Forker le repo permet de modifier sans casser le projet upstream. Plusieurs équipes ajoutent des skills personnalisés (déploiement Kubernetes, conformité RGPD, accessibilité WCAG) en suivant le même format que les skills officiels. Cette approche modulaire rappelle la philosophie des 66 experts fullstack de Jeff Allan.

Limites actuelles et perspectives

Agent-skills n’est pas une recette magique. Ses limites doivent être connues avant l’adoption pour éviter les déceptions et calibrer les attentes.

Les agents trouvent encore des contournements

Malgré les tables d’anti-rationalisation, les agents IA peuvent inventer de nouvelles excuses non couvertes par les skills. Quand le contexte se remplit ou que des instructions contradictoires arrivent en cours de session, les coupes de coin réapparaissent. La rigueur reste une discipline, pas un automatisme. Les équipes performantes complètent agent-skills par des revues humaines régulières.

La courbe d’apprentissage initiale

Les premières semaines exigent un investissement réel. Lire les 20 skills, comprendre la philosophie Google sous-jacente (Hyrum’s Law, Beyonce Rule, Shift Left) et adapter les frontmatters au contexte interne demande au moins une journée par développeur engagé. Les équipes qui sautent cette phase d’appropriation reviennent rapidement à leurs anciens réflexes.

L’évolution prévisible

Le projet est très actif sur GitHub avec des contributions hebdomadaires. Osmani a annoncé l’arrivée de skills sur l’observabilité et le coût des LLMs. Les marketplaces de plugins Claude Code et Cursor devraient gagner en variété, ce qui rendra les skills plus faciles à découvrir. Les équipes qui adoptent maintenant prendront un avantage de maturité que les retardataires devront combler en accéléré. La dynamique observée rappelle celle des frameworks de tests comme JUnit ou de l’architecture logicielle orientée services à leur émergence : une fois adoptés, ces standards deviennent invisibles tant ils sont naturalisés.

Une convergence avec les pratiques DevOps matures

L’esprit d’agent-skills rejoint les enseignements du mouvement DevOps et de l’extreme programming : feedback rapide, tests systématiques, intégration continue, code review obligatoire. La nouveauté est l’application de ces principes au pilotage d’agents IA, là où les équipes traditionnelles les appliquaient à leurs développeurs humains. Cette translation rend les pratiques d’ingénierie senior accessibles à des équipes qui n’auraient pas eu les ressources de former chaque junior à ces standards.

Méthodologie HDVMA pour intégrer agent-skills

Notre approche en cabinet s’articule en quatre phases. Phase 1 : audit de quatre heures pour identifier les skills prioritaires. Phase 2 : installation et configuration adaptée à la stack de l’équipe. Phase 3 : accompagnement sur deux sprints (quatre semaines) avec mesure d’impact. Phase 4 : transfert de compétences pour l’autonomie. Cette méthode permet à une équipe de cinq à quinze développeurs de tirer un retour sur investissement mesurable dès le deuxième sprint.

Vous voulez calibrer ce déploiement pour votre équipe ? Appelez Eric au 06 25 34 34 25 ou réservez un Diagnostic IA gratuit.

Questions fréquentes

Qu’est-ce que agent-skills d’Addy Osmani ?

Agent-skills est un projet open source publié sous licence MIT par Addy Osmani, ancien ingénieur senior de Google Chrome aujourd’hui chez Anthropic. Il contient 20 compétences d’ingénierie et 7 commandes slash qui encodent les workflows d’un ingénieur senior pour les agents IA. Le projet a dépassé 14 000 étoiles GitHub en quelques mois et fonctionne avec Claude Code, Cursor, Gemini CLI, Windsurf, GitHub Copilot, Kiro et tout outil capable de lire des fichiers Markdown avec frontmatter.

Quelles sont les six phases du cycle agent-skills ?

Le projet structure le cycle de développement logiciel en six phases ordonnées : DEFINE pour cadrer le besoin avec une spec écrite, PLAN pour décomposer en tâches contextualisées, BUILD pour implémenter par tranches verticales, VERIFY pour produire des évidences mesurables, REVIEW pour auditer la qualité et la sécurité, et SHIP pour déployer avec traçabilité. Cette séquence force l’agent à respecter un ordre de travail proche de celui d’un ingénieur senior expérimenté.

Comment fonctionne la table d’anti-rationalisation ?

Chaque skill inclut une table listant les excuses classiques que les agents IA invoquent pour sauter une étape, accompagnées de réfutations argumentées. Par exemple, « j’ajouterai les tests plus tard » est contré par l’argument que les tests post-implémentation valident le code écrit et non les exigences initiales, créant des tests fragiles. Cette pré-écriture des contre-arguments empêche l’agent de produire la rationalisation puisqu’il l’a déjà lue avant. La technique réduit nettement les coupes de coin observées en production.

Quels outils sont compatibles avec agent-skills ?

La compatibilité est très large car les skills sont de simples fichiers Markdown avec frontmatter. Claude Code dispose d’une marketplace officielle pour installer le projet en deux commandes. Cursor accepte les skills dans .cursor/rules/. Gemini CLI a son propre chemin d’installation. GitHub Copilot, Kiro, Windsurf, Aider, OpenCode et Codex peuvent consommer les fichiers via leurs system prompts respectifs. La portabilité est l’un des piliers du projet, ce qui permet à une équipe d’unifier ses standards même si chaque développeur utilise un outil différent.

Quels principes Google sous-tendent agent-skills ?

Le projet s’inspire ouvertement du livre Software Engineering at Google. On y retrouve Hyrum’s Law (avec assez d’utilisateurs, tout comportement observable d’un système devient une dépendance), Chesterton’s Fence (comprendre pourquoi un code existe avant de le modifier), la Beyonce Rule (si vous tenez à un comportement, écrivez un test pour lui) et le Shift Left (déplacer la qualité au plus tôt dans le cycle). Ces principes étaient peu accessibles aux agents IA avant la formalisation par Osmani.

Combien de temps faut-il pour adopter agent-skills ?

Pour un développeur seul, l’installation prend quinze minutes via Claude Code et la première utilisation productive vient après deux ou trois sessions de travail réelles. Pour une équipe de cinq à dix personnes, comptez une journée d’audit pour identifier les skills prioritaires, puis deux sprints (quatre semaines) pour absorber la philosophie et adapter les frontmatters. Les équipes qui sautent l’appropriation reviennent rapidement aux anciens réflexes.

Agent-skills remplace-t-il la revue humaine ?

Non, et le projet ne le revendique pas. Les skills produisent des outputs plus structurés et plus auditables, ce qui rend les revues humaines plus rapides et plus ciblées. Les rationalisations stéréotypées sont éliminées en grande partie, mais les agents IA inventent encore de nouveaux contournements quand le contexte se remplit. La discipline de revue reste indispensable, surtout pour les changements architecturaux et les zones critiques de sécurité.

Peut-on créer ses propres skills personnalisés ?

Oui, c’est même fortement encouragé. La licence MIT autorise tout fork et modification. Les équipes ajoutent fréquemment des skills sur le déploiement Kubernetes, la conformité RGPD ou l’accessibilité WCAG en suivant le même format que les skills officiels (frontmatter, conditions de déclenchement, étapes, anti-rationalisation, preuves). Cette extensibilité explique le succès du projet auprès des équipes plateforme et DevOps qui ont des contraintes très spécifiques.

Quelle différence avec les sub-agents Claude Code natifs ?

Les sub-agents de Claude Code sont des instances parallèles avec leur propre contexte, alors qu’agent-skills sont des fichiers de méthode lisibles par n’importe quel agent. Les deux sont complémentaires : les trois personas d’agent-skills (reviewer, QA, sécurité) s’instancient parfaitement comme sub-agents Claude Code. Cette articulation est détaillée dans notre guide Claude Code best practices, où nous montrons comment combiner skills, subagents et orchestration multi-agents pour des projets de production.

Quel retour sur investissement attendre ?

Les retours communautaires convergent sur trois bénéfices mesurables. La dette technique générée par les agents diminue de 30 à 50 % grâce à la phase DEFINE imposée avant le code. Les régressions causées par des changements transverses baissent d’environ 40 % grâce à la limite de cinq fichiers par tâche. Le temps de revue humaine se réduit de 25 à 35 % car les outputs sont plus prévisibles. Ces gains se manifestent dès le deuxième sprint, à condition que l’équipe adopte sérieusement la philosophie sans se contenter d’installer les fichiers.

À propos de l’auteur

Carte auteur

Eric Christophe Dirigeant HDVMA, Eric accompagne les équipes techniques dans l’adoption raisonnée des agents IA pour la production logicielle. LinkedIn