Agent Skills: The Open-Source Framework With 82,000+ GitHub Stars That Makes AI Coding Agents Think Like Senior Engineers

AI coding agents are transforming software development, but they have a critical flaw: they default to the shortest path. Without guidance, agents skip specs, write minimal tests, ignore security reviews, and ship code that works but isn't production-ready.

Enter Agent Skills — an open-source framework that has exploded to 82,000+ GitHub stars by solving exactly this problem. Created by Addy Osmani, Engineering Lead on the Chrome team at Google, Agent Skills provides AI coding agents with the structured workflows, quality gates, and best practices that separate senior engineers from junior developers.

This isn't another prompt engineering trick. It's a complete methodology for making AI agents think like experienced software engineers — and it works with 70+ AI coding tools including Claude Code, Cursor, GitHub Copilot, Codex, and more.

What Is Agent Skills?

Agent Skills is a collection of 24 production-grade engineering skills that encode the workflows senior engineers use throughout the software development lifecycle. Each skill is a structured workflow with steps, verification gates, and anti-rationalization tables that prevent agents from cutting corners.

The framework maps to six phases of development:

• Define — Interview users, refine ideas, write specifications
• Plan — Break down specs into implementable tasks
• Build — Implement incrementally with test-driven development
• Verify — Test, debug, and prove the code works
• Review — Code review, security audit, performance optimization
• Ship — Deploy to production with proper monitoring

The Anti-Rationalization Approach

One of Agent Skills' most innovative features is its anti-rationalization tables. Every skill includes a table of common excuses agents use to skip steps, paired with documented counter-arguments:

This approach prevents agents from rationalizing their way out of best practices — a common failure mode that leads to technical debt.

How Agent Skills Works

Agent Skills provides eight slash commands that activate the right skills automatically:

Installation Is One Command

The framework works with any AI coding agent that accepts system prompts or instruction files. The fastest installation path uses the open skills CLI:

Native Integrations

For popular AI coding tools, Agent Skills offers native integrations:

• Claude Code — Install via plugin marketplace or local directory
• Cursor — Copy skills to .cursor/skills/
• GitHub Copilot — Use in .github/copilot-instructions.md
• Codex CLI — Install as native plugin (v0.122+)
• Gemini CLI — Install as native skills
• Windsurf — Add to rules configuration

The 24 Skills Breakdown

Here's a detailed look at the skills organized by development phase:

Define Phase

• interview-me — One-question-at-a-time interview that extracts what users actually want (not what they think they should want) until 95% confidence
• idea-refine — Structured divergent/convergent thinking to turn vague concepts into concrete proposals
• spec-driven-development — Write a PRD covering objectives, commands, structure, code style, testing, and boundaries before any code

Plan Phase

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

Build Phase

• incremental-implementation — Thin vertical slices: implement, test, verify, commit. Feature flags, safe defaults, rollback-friendly changes
• test-driven-development — Red-Green-Refactor, test pyramid (80/15/5), DAMP over DRY, Beyonce Rule
• context-engineering — Feed agents the right information at the right time
• source-driven-development — Ground every framework decision in official documentation
• doubt-driven-development — Adversarial review of every non-trivial decision: CLAIM → EXTRACT → DOUBT → RECONCILE → STOP
• frontend-ui-engineering — Component architecture, design systems, WCAG 2.1 AA accessibility
• api-and-interface-design — Contract-first design, Hyrum's Law, One-Version Rule

Verify Phase

• browser-testing-with-devtools — Chrome DevTools MCP for live runtime data
• debugging-and-error-recovery — Five-step triage: reproduce, localize, reduce, fix, guard

Review Phase

• code-review-and-quality — Five-axis review with severity labels (Nit/Optional/FYI)
• code-simplification — Chesterton's Fence, Rule of 500, reduce complexity while preserving behavior
• security-and-hardening — OWASP Top 10 prevention, auth patterns, secrets management
• performance-optimization — Measure-first approach, Core Web Vitals targets

Ship Phase

• git-workflow-and-versioning — Trunk-based development, atomic commits, change sizing (~100 lines)
• ci-cd-and-automation — Shift Left, Faster is Safer, feature flags, quality gates
• deprecation-and-migration — Code-as-liability mindset, migration patterns
• documentation-and-adrs — Architecture Decision Records, API docs
• observability-and-instrumentation — Structured logging, RED metrics, OpenTelemetry tracing
• shipping-and-launch — Pre-launch checklists, staged rollouts, rollback procedures

Specialist Personas

Agent Skills includes four pre-configured specialist personas for targeted reviews:

Real-World Example: Building a Payment Feature

Let's see Agent Skills in action with a practical example. Suppose you're building a payment processing feature:

Without Agent Skills

With Agent Skills

Key Benefits

• Production-Grade Output — AI agents produce code that meets senior engineer standards, not just "it works"
• Consistency Across Agents — Works with 70+ AI coding tools, ensuring consistent quality regardless of the underlying model
• Prevents Technical Debt — Anti-rationalization tables stop agents from skipping critical steps
• Structured Workflows — Clear phases (Define → Plan → Build → Verify → Review → Ship) prevent chaos
• Verification Gates — Every skill ends with evidence requirements — "seems right" is never sufficient
• Progressive Disclosure — Skills load supporting references only when needed, keeping token usage minimal
• Open Source — 82,000+ stars, active community, continuous improvements
• One-Command Installation — npx skills add addyosmani/agent-skills and you're ready

FAQ

1. What makes Agent Skills different from regular prompts?

Regular prompts are instructions. Agent Skills are structured workflows with steps, verification gates, and anti-rationalization tables. They don't just tell agents what to do — they enforce the discipline to do it consistently. Each skill includes documented counter-arguments for common excuses agents use to skip steps.

2. Does Agent Skills work with my AI coding tool?

Yes. Agent Skills works with 70+ AI coding agents including Claude Code, Cursor, GitHub Copilot, Codex, Cline, Windsurf, Gemini CLI, and more. Skills are plain Markdown files that any agent accepting system prompts or instruction files can use. Native integrations are available for popular tools.

3. Will Agent Skills slow down development?

No — it actually speeds up development by preventing rework. Yes, agents spend more time on specs, tests, and reviews, but this prevents bugs, security issues, and technical debt that would require expensive fixes later. The framework is designed for production code, not prototypes.

4. Can I use only specific skills instead of all 24?

Absolutely. Install individual skills with npx skills add addyosmani/agent-skills --skill <skill-name>. For example, if you only want code review and TDD: npx skills add addyosmani/agent-skills --skill code-review-and-quality --skill test-driven-development.

5. How does the anti-rationalization approach work?

Every skill includes a table of common excuses (rationalizations) agents use to skip steps, paired with documented counter-arguments. For example, when an agent thinks "I'll add tests later," the skill reminds it: "Tests are proof the code works. Code without tests is unverified." This prevents agents from rationalizing their way out of best practices.

6. Is Agent Skills suitable for small projects?

Yes, but be pragmatic. For a quick script or prototype, you might only need a few skills (test-driven-development, code-review-and-quality). For production applications, use the full lifecycle. The framework is flexible — use what makes sense for your project's maturity and risk tolerance.

7. Who created Agent Skills?

Agent Skills was created by Addy Osmani, Engineering Lead on the Chrome team at Google. He's a well-known figure in web development, author of popular open-source projects, and expert in web performance and engineering best practices.

8. How do I know if Agent Skills is working?

Every skill ends with verification requirements — concrete evidence that the work was done correctly. For example, test-driven-development requires passing tests, code-review-and-quality requires a review checklist, and shipping-and-launch requires a deployment checklist. "Seems right" is never sufficient.