Addy Osmani's Agent Skills: 24 Production-Grade Engineering Skills for AI Coding Agents (2026 Guide)

AI coding agents default to the shortest path. They skip specs, write code without tests, ignore security reviews, and ship without documentation. The result is prototype-quality code that breaks in production. The agent is fast, but the work is not reliable. For teams that need production-grade output from AI agents, there has been no structured way to enforce engineering discipline.

Agent Skills, created by Addy Osmani (Google Chrome team), is a free, open source pack of 24 production-grade engineering skills for AI coding agents. Each skill encodes a structured workflow with steps, verification gates, and anti-rationalization tables. Skills cover the full development lifecycle: define, plan, build, verify, review, and ship. Works with Claude Code, Cursor, Codex, GitHub Copilot, Cline, and 70+ other agents. 87,200+ stars on GitHub, MIT license.

In this guide, you'll learn what Agent Skills is, how it works, and how to install it in under one minute.

What is Agent Skills?

Agent Skills is a collection of 24 production-grade engineering skills that AI coding agents follow consistently across every phase of development. Skills encode the workflows, quality gates, and best practices that senior engineers use when building software, packaged so AI agents follow them consistently.

The pack includes 23 lifecycle skills plus one meta-skill that maps incoming work to the right skill. Each skill follows a consistent anatomy:

• Frontmatter: Name, description, and triggering conditions
• Overview: What this skill does
• When to Use: Triggering conditions
• Process: Step-by-step workflow
• Rationalizations: Common excuses agents use to skip steps, with counter-arguments
• Red Flags: Signs something is wrong
• Verification: Evidence requirements (tests passing, build output, runtime data)

Key design choices: skills are workflows agents follow, not reference docs they read. Every skill includes an anti-rationalization table (for example, "I will add tests later" with a documented counter-argument). Verification is non-negotiable: every skill ends with evidence requirements. "Seems right" is never sufficient.

Who is it for?

• Teams using AI coding agents in production: If your agents write code that ships to production, you need them to follow the same discipline senior engineers use. Agent Skills enforces specs, tests, security reviews, and documentation.
• Developers new to AI-assisted coding: If you are starting with Claude Code or Cursor and want your agent to follow best practices from day one, Agent Skills gives you 24 structured workflows out of the box.
• Engineering managers: If you manage a team using AI agents and want consistent quality across all agent output, Agent Skills standardizes the workflow so every agent follows the same process.
• Open source maintainers: If you maintain a project that accepts AI-generated PRs, Agent Skills ensures contributors' agents write specs, tests, and documentation before submitting.

What makes Agent Skills different from custom prompts or .cursorrules?

• 24 structured skills across the full lifecycle: Define (interview-me, idea-refine, spec-driven-development), Plan (planning-and-task-breakdown), Build (incremental-implementation, test-driven-development, context-engineering, source-driven-development, doubt-driven-development, frontend-ui-engineering, api-and-interface-design), Verify (browser-testing-with-devtools, debugging-and-error-recovery), Review (code-review-and-quality, code-simplification, security-and-hardening, performance-optimization), Ship (git-workflow-and-versioning, ci-cd-and-automation, deprecation-and-migration, documentation-and-adrs, observability-and-instrumentation, shipping-and-launch).
• 8 slash commands that map to the development lifecycle: /spec (spec before code), /plan (small atomic tasks), /build (one slice at a time), /test (tests are proof), /review (improve code health), /webperf (measure before optimize), /code-simplify (clarity over cleverness), /ship (faster is safer).
• Anti-rationalization tables: Every skill includes a table of common excuses agents use to skip steps, with documented counter-arguments. The agent cannot talk its way out of writing tests.
• Verification gates with evidence requirements: Every skill ends with evidence requirements. Tests must pass. Build output must exist. Runtime data must be collected. "Seems right" is never sufficient.
• 4 specialist personas: code-reviewer (Senior Staff Engineer standard), test-engineer (QA Specialist), security-auditor (Security Engineer), web-performance-auditor (Web Performance Engineer).
• 7 reference checklists: definition-of-done, testing-patterns, security-checklist, performance-checklist, accessibility-checklist, observability-checklist, orchestration-patterns.
• Works with 70+ agents: Claude Code, Cursor, Codex, GitHub Copilot, Cline, Antigravity CLI, Gemini CLI, Windsurf, OpenCode, Kiro, and more. One install command, any agent.
• Based on Google engineering practices: Skills bake in best practices from Google's engineering culture, including concepts from Software Engineering at Google and Google's engineering practices guide. Hyrum's Law, the Beyonce Rule, test pyramid, change sizing, Chesterton's Fence, trunk-based development, Shift Left, and feature flags.
• Free and open source: MIT license. 87,200+ stars, 60 contributors. Maintained by Addy Osmani (Google Chrome team).

What you need before you start

• An AI coding agent: Claude Code, Cursor, Codex, GitHub Copilot, Cline, or any of the 70+ supported agents.
• Node.js and npx: For the one-command install via the skills CLI.
• A project directory: Agent Skills works in your project directory and applies to the codebase you are working in.

Step-by-step installation

Step 1: Install all 24 skills (any agent, one command)

npx skills add addyosmani/agent-skills

This installs all 24 skills into your agent's skills directory. The skills CLI supports 70+ agents and auto-detects which one you are using.

Step 2: Browse before installing (optional)

npx skills add addyosmani/agent-skills --list

Step 3: Install individual skills (optional)

# Five-axis review before merge
npx skills add addyosmani/agent-skills --skill code-review-and-quality

# Requirements interrogation, one question at a time
npx skills add addyosmani/agent-skills --skill interview-me

# Red-green-refactor, enforced
npx skills add addyosmani/agent-skills --skill test-driven-development

Step 4: Use slash commands in your agent

Once installed, use the slash commands in your AI agent:

/spec       # Spec before code
/plan       # Small, atomic tasks
/build      # One slice at a time
/test       # Tests are proof
/review     # Improve code health
/webperf    # Measure before you optimize
/code-simplify  # Clarity over cleverness
/ship       # Faster is safer

Skills also activate automatically based on what you are doing. Designing an API triggers api-and-interface-design. Building UI triggers frontend-ui-engineering.

Step 5: Use /build auto for autonomous implementation

/build auto

This generates the plan and implements every task in a single approved pass. You approve the plan once, then it runs autonomously. It removes the human stepping between tasks, not the verification: every task is still test-driven and committed individually, and it pauses on failures or risky steps.

Common errors and how to fix them

Error	What it means	How to fix it
Skills not found by agent	The skills were installed in the wrong directory or the agent does not scan that skills folder.	Verify the skills exist in your agent's skills directory (~/.claude/skills/ for Claude Code, ~/.cursor/skills/ for Cursor). Restart the agent to refresh the skills list.
Individual skill missing references	A per-skill install copies only skills/<name>/, not the repo-level references/ directory.	Use a whole-repo integration, clone the repository, or copy the needed checklist into a references/ directory inside the installed skill.
npx skills command not found	The skills CLI is not installed or npx is not available.	Ensure Node.js and npm are installed. The skills CLI is invoked via npx, which comes with npm.
Agent ignores skill workflow	The agent is not loading the skill or the skill's triggering conditions are not met.	Check that the skill is installed correctly. Use the slash command explicitly (for example, /test) to force activation.

Agent Skills vs custom .cursorrules vs Ponytail

Feature	Agent Skills (Addy Osmani)	Custom .cursorrules	Ponytail
Number of skills	24 structured workflows	1 file	1 skill (lazy coding)
Lifecycle coverage	Full (define, plan, build, verify, review, ship)	Varies	Code output only
Anti-rationalization	Yes (every skill)	No	No
Verification gates	Yes (evidence required)	No	No
Slash commands	8	No	Chat commands
Agent compatibility	70+ agents	Cursor only	Claude Code, Cursor
Based on	Google engineering practices	Custom	YAGNI philosophy
Best for	Teams who want production-grade agent output	Quick project-specific rules	Reducing code bloat

Bottom line: Agent Skills is the most comprehensive open source engineering skills pack for AI coding agents. By encoding 24 structured workflows with verification gates and anti-rationalization tables, it transforms AI agents from prototype-quality code generators into production-quality engineering assistants. The fact that it works with 70+ agents (Claude Code, Cursor, Codex, Copilot, Cline) with a single install command makes it the universal standard. If you are using AI coding agents and want production-grade output, this is the first thing you should install. At 87,200+ stars, the community has already validated this as the go-to skills pack for AI-assisted development.

3 alternatives worth checking out

• Ponytail (github.com/DietrichGebert/ponytail): An agent skill that forces AI coding assistants to write minimal code. While Agent Skills covers the full development lifecycle, Ponytail focuses on one thing: making the agent write less code. They complement each other perfectly. Use Agent Skills for the full workflow and Ponytail to keep code output lean.
• Superpowers (github.com/obra/superpowers: Another popular agent skills pack. Superpowers focuses on giving agents persistent memory and tool-use capabilities. While Agent Skills focuses on engineering workflows, Superpowers focuses on agent capabilities. See the honest comparison in the Agent Skills docs for when to use each.
• Google Skills (github.com/google/skills: Official agent skills for Google products and technologies. If you work with Google Cloud, Android, or other Google products, these are ready-to-use skills that follow the same Agent Skills standard. Use Google Skills for Google-specific work and Agent Skills for general engineering.

---

Found this guide useful? Check out more developer tools and AI tools on Sudo Scout.