addyosmani/agent-skills: Engineering Skill Packs for AI Coding Agents

addyosmani/agent-skills structures engineering workflows—clarify goals, break down tasks, implement in small steps, then prove quality with tests, review, and ship checks.

What Is agent-skills?

addyosmani/agent-skills is a collection of engineering skills and commands for AI coding agents. It splits requirements, planning, implementation, testing, review, and release into reusable workflows so agents follow a rhythm closer to real engineering teams.

Repository: github.com/addyosmani/agent-skills

What Problem It Solves

AI coding tools often fail not because they can’t write code, but because they skip engineering steps:

• Coding before requirements are clear.
• Changing many files with no plan.
• Shipping without verification—“looks fine” is enough.
• Skipping review, leaving complexity and security gaps.
• No pre-release checklist or rollback plan.

agent-skills makes those steps explicit. Agents don’t just answer questions—they run different skills across /spec, /plan, /build, /test, /review, and /ship.

Seven Commands for the Dev Lifecycle

Seven slash commands map to major software development phases:

The value is phase awareness. Writing code isn’t the only action—clarifying requirements, planning, verifying, reviewing, and releasing matter equally.

Skill Coverage

The README describes 24 skills: 23 lifecycle skills plus a using-agent-skills meta-skill.

Coverage includes:

• Requirements interviews and idea refinement.
• Spec-driven development.
• Planning and task breakdown.
• Incremental implementation.
• Test-driven development.
• Context engineering.
• Source-driven development.
• Skeptic-driven development.
• Frontend UI engineering.
• API and interface design.
• Browser debugging.
• Error recovery.
• Code review.
• Code simplification.
• Security hardening.
• Performance optimization.
• Git workflows.
• CI/CD and automation.
• Migration and deprecation.
• Documentation and ADRs.
• Observability.
• Release and deployment.

Agent personas include code reviewer, test engineer, security auditor, and web performance auditor for multi-perspective review.

How It Differs from Plain Prompts

Plain prompts are one-shot instructions—“write careful code,” “add tests,” “review like a senior engineer.” Helpful, but inconsistent.

agent-skills encodes engineering methods as executable flows:

• Steps per skill.
• Quality gates per phase.
• Common shortcuts and pushback.
• Evidence at the end—passing tests, build output, runtime data.
• Progressive loading so context isn’t flooded at once.

Agents often know best practices but drop them under pressure. Checkpoints beat a single line saying “follow best practices.”

Who It’s For

Best for people already using AI coding tools seriously—especially those who want agents in the full engineering loop, not just code generation.

Good fits:

• End-to-end feature delivery from requirements to release.
• Multi-file changes that need small, ordered tasks.
• Cross-cutting work—frontend, API, backend.
• Spec and plan before code changes.
• Agent-driven review, security, or performance checks.
• Teams standardizing how AI assistants work.

Overkill for tiny syntax questions; much more valuable when AI stays on a real project for hours or days.

Supported Tools

The README lists integrations including:

• Claude Code.
• Cursor.
• Antigravity CLI.
• Gemini CLI.
• Windsurf.
• OpenCode.
• GitHub Copilot.
• Kiro.
• Codex.
• Other agents that support rules files or skill directories.

Claude Code marketplace install:

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

Or clone locally and point at the plugin directory:

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

Gemini CLI example:

gemini skills install https://github.com/addyosmani/agent-skills.git --path skills

For Codex and others, these are Markdown instruction files. Any tool with system prompts, rules, or skill folders can adopt them.

Usage Notes

Skills discipline agents—they don’t replace your project judgment. Recommendations:

1. Don’t load every skill into context at once.
2. Let the meta-skill or current task pick the right skill.
3. For high-risk changes, favor spec, plan, test, and review together.
4. For frontend and security work, invoke UI, security, and performance skills explicitly.
5. Don’t accept plans alone—run tests or builds when code actually changes.

Skills aren’t magic; they’re work discipline: fewer skipped steps, fewer self-justifications, fewer “done” claims without evidence.

Recommended Flow

Treat it as an AI engineering pipeline:

1. /spec — goals, scope, acceptance criteria.
2. /plan — executable small tasks.
3. /build — incremental changes, not massive diffs.
4. /test — gather evidence.
5. /review — complexity, security, maintainability, regression risk.
6. /code-simplify when needed — reduce complexity.
7. /ship — pre-release checklist.

This controls quality better than “have AI write everything end to end.”

Summary

addyosmani/agent-skills isn’t about more prompt text—it’s about structured engineering. It helps AI coding agents skip fewer steps on real projects: clarify goals, plan, implement in small increments, then prove reliability with tests, review, and ship checks.

If you already use Claude Code, Codex, Cursor, Gemini CLI, or similar tools on real work, this repo is worth studying.