← Back to Home

Agent Skills — Production-Grade Engineering Workflows for AI Coding Agents

2026-06-11

Agent Skills — Production-Grade Engineering Workflows for AI Coding Agents

AI coding agents are incredibly productive, but they default to the shortest path — skipping specs, tests, security reviews, and the engineering practices that make production software reliable. Agent Skills is an open-source skill pack (52K+ ⭐ on GitHub) by Addy Osmani that fixes this by encoding senior engineering workflows into structured, verifiable skills that any AI agent can follow.

Whether you use Claude Code, Cursor, Gemini CLI, Windsurf, or plain system prompts, Agent Skills brings the discipline of Google's engineering culture — spec-driven development, test-driven development, code review standards, and trunk-based git workflows — directly into your agent's decision loop.

Architecture

Agent Skills Workflow

The Agent Skills architecture follows a simple but powerful pattern. Each skill is a single Markdown file with a consistent internal structure: frontmatter defining its name and purpose, step-by-step process instructions, anti-rationalization tables that block common shortcuts, and verification gates the agent must satisfy before declaring success.

The system is organized into six lifecycle phases (Define → Plan → Build → Verify → Review → Ship), each containing multiple skills. A meta-skill (using-agent-skills) determines which skill applies based on the current task. Slash commands provide quick access, and the system also auto-detects context — designing an API triggers api-and-interface-design, building UI triggers frontend-ui-engineering, and so on.

When needed, skills pull in supplementary reference checklists (testing patterns, security checklist, performance checklist, accessibility) and can dispatch to 4 specialist agent personas for targeted reviews.

What Is Agent Skills?

Agent Skills is a collection of 24 structured skills (23 lifecycle skills + 1 meta-skill) packaged as plain Markdown files that AI coding agents can consume. Each skill is a complete workflow with:

  • A clear frontmatter (name, description, use conditions)
  • A step-by-step process the agent follows
  • Anti-rationalization tables — common excuses agents use to skip steps, with documented counter-arguments
  • Verification gates — evidence requirements the agent must meet before proceeding
  • Red flags — signs something is wrong and needs attention

The skills cover the full development lifecycle: Define → Plan → Build → Verify → Review → Ship.

Why Is It Trending?

Agent Skills has exploded in popularity (52K+ stars since February 2026) because it solves a real problem: AI agents produce a lot of code, but the quality is inconsistent. Developers are discovering that giving agents structured workflows — not just prompts — dramatically improves output quality, test coverage, and security posture.

The pack also integrates with 7 slash commands (/spec, /plan, /build, /test, /review, /code-simplify, /ship) that map directly to development phases, and an auto mode (/build auto) that generates a plan and implements every task autonomously with verification at every step.

Key Skills

Meta — Discover Which Skill Applies

  • using-agent-skills: Maps incoming work to the right skill; defines shared operating rules

Define — Clarify What to Build

  • interview-me: One-question-at-a-time interview to extract real requirements
  • idea-refine: Divergent/convergent thinking for vague concepts
  • spec-driven-development: Full PRD before any code — objectives, structure, testing boundaries

Plan — Break It Down

  • planning-and-task-breakdown: Decompose specs into small, verifiable tasks with acceptance criteria

Build — Write the Code

  • incremental-implementation: Thin vertical slices — implement, test, verify, commit
  • test-driven-development: Red-Green-Refactor with test pyramid (80/15/5)
  • context-engineering: Feed agents the right context at the right time
  • source-driven-development: Ground every framework decision in official documentation
  • doubt-driven-development: Adversarial fresh-context review of non-trivial decisions
  • frontend-ui-engineering: Component architecture, design systems, accessibility
  • api-and-interface-design: Contract-first design, Hyrum's Law, error semantics

Verify — Prove It Works

  • browser-testing-with-devtools: Live runtime data — DOM, console, network, performance
  • debugging-and-error-recovery: Five-step triage: reproduce, localize, reduce, fix, guard

Review — Quality Gates Before Merge

  • code-review-and-quality: Five-axis review, change sizing (~100 lines)
  • code-simplification: Chesterton's Fence, Rule of 500, reduce complexity
  • security-and-hardening: OWASP Top 10, auth patterns, secrets management
  • performance-optimization: Measure-first — Core Web Vitals, bundle analysis

Ship — Deploy With Confidence

  • git-workflow-and-versioning: Trunk-based development, atomic commits
  • ci-cd-and-automation: Shift Left, feature flags, quality gates
  • deprecation-and-migration: Code-as-liability, migration patterns
  • documentation-and-adrs: Architecture Decision Records
  • observability-and-instrumentation: RED metrics, OpenTelemetry, structured logging
  • shipping-and-launch: Pre-launch checklists, staged rollouts, rollback procedures

Prerequisites

  • An AI coding agent (Claude Code, Cursor, Gemini CLI, Windsurf, OpenCode, Copilot, or any agent that accepts Markdown instructions)
  • Git (to clone the repository)
  • (Optional) One of the supported IDE plugins or CLI tools

Installation

Claude Code (Recommended)

# Via marketplace
/plugin marketplace add addyosmani/agent-skills
/plugin install agent-skills@addy-agent-skills

# Or if you get SSH errors, use HTTPS
/plugin marketplace add https://github.com/addyosmani/agent-skills.git
/plugin install agent-skills@addy-agent-skills

# Local install
git clone https://github.com/addyosmani/agent-skills.git
claude --plugin-dir /path/to/agent-skills

Other Platforms

Platform Installation
Cursor Copy any SKILL.md into .cursor/rules/
Antigravity CLI agy plugin install https://github.com/addyosmani/agent-skills.git
Gemini CLI gemini skills install ... --path skills
Windsurf Add skill contents to Windsurf rules config
OpenCode Uses agent-driven skill execution via AGENTS.md
GitHub Copilot Use agents/ as Copilot personas
Codex / Any agent Plain Markdown — works with any instruction system

Usage

Starting a New Feature

# 1. Define what to build
/spec
  → Writes a full PRD covering objectives, structure, code style, testing boundaries

# 2. Plan the implementation
/plan
  → Decomposes the spec into small, verifiable tasks

# 3. Build incrementally
/build
  → Implements one slice at a time, testing and verifying each

# 4. Run tests
/test
  → Proves everything works with evidence

# 5. Review the code
/review
  → Five-axis review before merge

Auto Build Mode

/build auto
→ Generates the plan and implements every task in a single approved pass
→ Each task is still test-driven and committed individually
→ Pauses on failures or risky steps

Architecture Details

The internal structure of every skill is consistent:

Component Purpose
Frontmatter Name, description, use conditions
Overview What the skill does and why
When to Use Triggering conditions
Process Step-by-step workflow the agent follows
Anti-rationalization Tables of common excuses + documented counter-arguments
Verification Evidence requirements — tests passing, build output, runtime data
Red Flags Signs something is wrong

Key design principles:

  • Process, not prose. Skills are workflows agents follow, not reference docs they read.
  • Anti-rationalization. Every skill includes a table of common excuses agents use to skip steps with documented counter-arguments.
  • Verification is non-negotiable. "Seems right" is never sufficient — every skill ends with evidence requirements.
  • Progressive disclosure. The SKILL.md is the entry point; supporting references load only when needed, keeping token usage minimal.

Resources

← Retour à l'Accueil

Agent Skills — Des Workflows d'Ingénierie de Qualité pour les Agents de Code IA

2026-06-11

Agent Skills — Des Workflows d'Ingénierie de Qualité pour les Agents de Code IA

Les agents de code IA sont incroyablement productifs, mais ils empruntent par défaut le chemin le plus court — en sautant les spécifications, les tests, les revues de sécurité et les pratiques d'ingénierie qui rendent un logiciel de production fiable. Agent Skills est un pack de compétences open-source (52K+ ⭐ sur GitHub) créé par Addy Osmani qui résout ce problème en encodant des workflows d'ingénierie senior dans des compétences structurées et vérifiables que tout agent IA peut suivre.

Que vous utilisiez Claude Code, Cursor, Gemini CLI, Windsurf ou de simples invites système, Agent Skills apporte la discipline de la culture d'ingénierie de Google — développement piloté par les spécifications, développement piloté par les tests, standards de revue de code et workflows git trunk-based — directement dans la boucle de décision de votre agent.

Architecture

Architecture Agent Skills

L'architecture d'Agent Skills suit un modèle simple mais puissant. Chaque compétence est un fichier Markdown unique avec une structure interne cohérente : un frontmatter définissant son nom et son objectif, des instructions de processus étape par étape, des tables d'anti-rationalisation qui bloquent les raccourcis courants, et des portes de vérification que l'agent doit satisfaire avant de déclarer le succès.

Le système est organisé en six phases du cycle de vie (Définir → Planifier → Construire → Vérifier → Réviser → Livrer), chacune contenant plusieurs compétences. Une méta-compétence (using-agent-skills) détermine quelle compétence s'applique en fonction de la tâche en cours. Les commandes slash fournissent un accès rapide, et le système détecte également le contexte automatiquement — la conception d'une API déclenche api-and-interface-design, la construction d'une UI déclenche frontend-ui-engineering, etc.

Lorsque nécessaire, les compétences font appel à des listes de contrôle de référence supplémentaires (patrons de test, checklist de sécurité, checklist de performance, accessibilité) et peuvent déléguer à 4 personae d'agents spécialisés pour des revues ciblées.

Qu'est-ce qu'Agent Skills ?

Agent Skills est une collection de 24 compétences structurées (23 compétences du cycle de vie + 1 méta-compétence) conditionnées sous forme de fichiers Markdown que les agents de code IA peuvent consommer. Chaque compétence est un workflow complet avec :

  • Un frontmatter clair (nom, description, conditions d'utilisation)
  • Un processus étape par étape que l'agent suit
  • Des tables d'anti-rationalisation — excuses courantes que les agents utilisent pour sauter des étapes, avec des contre-arguments documentés
  • Des portes de vérification — exigences de preuve que l'agent doit satisfaire avant de continuer
  • Des drapeaux rouges — signes que quelque chose ne va pas

Les compétences couvrent l'ensemble du cycle de vie du développement : Définir → Planifier → Construire → Vérifier → Réviser → Livrer.

Pourquoi ce Projet Est-il Tendance ?

Agent Skills a connu une explosion de popularité (52K+ étoiles depuis février 2026) car il résout un vrai problème : les agents IA produisent beaucoup de code, mais la qualité est incohérente. Les développeurs découvrent que donner des workflows structurés aux agents — et pas seulement des invites — améliore considérablement la qualité des résultats, la couverture de test et la posture de sécurité.

Le pack s'intègre également avec 7 commandes slash (/spec, /plan, /build, /test, /review, /code-simplify, /ship) qui correspondent directement aux phases de développement, et un mode automatique (/build auto) qui génère un plan et implémente chaque tâche de manière autonome avec vérification à chaque étape.

Compétences Clés

Méta — Découvrir Quelle Compétence S'applique

  • using-agent-skills: Oriente le travail entrant vers la bonne compétence ; définit les règles de fonctionnement partagées

Définir — Clarifier ce Qu'il Faut Construire

  • interview-me: Interview question par question pour extraire les vrais besoins
  • idea-refine: Pensée divergente/convergente pour les concepts vagues
  • spec-driven-development: PRD complet avant tout code — objectifs, structure, limites de test

Planifier — Décomposer le Travail

  • planning-and-task-breakdown: Décompose les spécifications en tâches vérifiables avec critères d'acceptation

Construire — Écrire le Code

  • incremental-implementation: Tranches verticales fines — implémenter, tester, vérifier, commiter
  • test-driven-development: Rouge-Vert-Refactor avec pyramide de test (80/15/5)
  • context-engineering: Fournir le bon contexte au bon moment
  • source-driven-development: Ancrer chaque décision framework dans la documentation officielle
  • doubt-driven-development: Revue contradictoire à contexte frais des décisions non triviales
  • frontend-ui-engineering: Architecture de composants, systèmes de design, accessibilité
  • api-and-interface-design: Design contract-first, Loi de Hyrum, sémantique d'erreur

Vérifier — Prouver que ça Marche

  • browser-testing-with-devtools: Données d'exécution live — DOM, console, réseau, performance
  • debugging-and-error-recovery: Triage en cinq étapes : reproduire, localiser, réduire, corriger, protéger

Réviser — Portes de Qualité Avant le Merge

  • code-review-and-quality: Revue sur cinq axes, taille de changement (~100 lignes)
  • code-simplification: Clôture de Chesterton, Règle de 500, réduction de complexité
  • security-and-hardening: OWASP Top 10, patrons d'auth, gestion des secrets
  • performance-optimization: Mesure d'abord — Core Web Vitals, analyse du bundle

Livrer — Déployer en Toute Confiance

  • git-workflow-and-versioning: Développement trunk-based, commits atomiques
  • ci-cd-and-automation: Shift Left, feature flags, portes de qualité
  • deprecation-and-migration: Code comme passif, patrons de migration
  • documentation-and-adrs: Architecture Decision Records
  • observability-and-instrumentation: Métriques RED, OpenTelemetry, logs structurés
  • shipping-and-launch: Listes de pré-lancement, déploiements progressifs, procédures de rollback

Prérequis

  • Un agent de code IA (Claude Code, Cursor, Gemini CLI, Windsurf, OpenCode, Copilot, ou tout agent acceptant des instructions Markdown)
  • Git (pour cloner le dépôt)
  • (Optionnel) Un des plugins IDE ou outils CLI supportés

Installation

Claude Code (Recommandé)

# Via le marketplace
/plugin marketplace add addyosmani/agent-skills
/plugin install agent-skills@addy-agent-skills

# Ou en cas d'erreurs SSH, utilisez HTTPS
/plugin marketplace add https://github.com/addyosmani/agent-skills.git
/plugin install agent-skills@addy-agent-skills

# Installation locale
git clone https://github.com/addyosmani/agent-skills.git
claude --plugin-dir /chemin/vers/agent-skills

Autres Plateformes

Plateforme Installation
Cursor Copiez SKILL.md dans .cursor/rules/
Antigravity CLI agy plugin install https://github.com/addyosmani/agent-skills.git
Gemini CLI gemini skills install ... --path skills
Windsurf Ajoutez le contenu des compétences à la config Windsurf
OpenCode Utilise l'exécution pilotée par agent via AGENTS.md
GitHub Copilot Utilisez agents/ comme personae Copilot
Codex / Tout agent Markdown simple — fonctionne avec tout système d'instructions

Utilisation

Démarrer une Nouvelle Fonctionnalité

# 1. Définir ce qu'il faut construire
/spec
  → Écrit un PRD complet couvrant les objectifs, la structure, le style de code, les limites de test

# 2. Planifier l'implémentation
/plan
  → Décompose la spécification en tâches vérifiables

# 3. Construire par incréments
/build
  → Implémente une tranche à la fois, testant et vérifiant chacune

# 4. Exécuter les tests
/test
  → Prouve que tout fonctionne avec des preuves

# 5. Réviser le code
/review
  → Revue sur cinq axes avant le merge

Mode Construction Automatique

/build auto
→ Génère le plan et implémente chaque tâche en un seul passage approuvé
→ Chaque tâche est toujours test-driven et commitée individuellement
→ Pause en cas d'échec ou d'étape risquée

Détails de l'Architecture

La structure interne de chaque compétence est cohérente :

Composant Objectif
Frontmatter Nom, description, conditions d'utilisation
Aperçu Ce que fait la compétence et pourquoi
Quand l'utiliser Conditions de déclenchement
Processus Workflow étape par étape que l'agent suit
Anti-rationalisation Tables d'excuses courantes + contre-arguments documentés
Vérification Exigences de preuve — tests passant, sortie de build, données d'exécution
Drapeaux rouges Signes que quelque chose ne va pas

Principes de conception clés :

  • Processus, pas prose. Les compétences sont des workflows que les agents suivent, pas des documents de référence.
  • Anti-rationalisation. Chaque compétence inclut une table des excuses courantes que les agents utilisent pour sauter des étapes, avec des contre-arguments documentés.
  • La vérification est non-négociable. "Ça semble correct" n'est jamais suffisant — chaque compétence se termine par des exigences de preuve.
  • Divulgation progressive. Le fichier SKILL.md est le point d'entrée ; les références de support ne se chargent que lorsque nécessaire, minimisant l'utilisation de tokens.

Ressources