Agent Skills — Production-Grade Engineering Skills for AI Agents
Structured workflows, quality gates, and senior-engineer practices for AI coding agents across the full development lifecycle.
Evidence shows the skill pack primarily provides instructional workflows, not directly executing high-risk operations. Skills like incremental-implementation emphasize small commits and rollback-friendly changes, security-and-hardening emphasizes least privilege and secrets management, but user confirmation for each action is not explicitly required. Data flow transparency is limited; no detailed explanation of how skills collect or process user data. Dependency security: uses npx and external tools, but no dependency audit provided. External effects: skills may trigger git commits, deployments, etc., but no explicit restrictions. Rollback: git-workflow and shipping skills mention rollback procedures. Source attribution: README clearly lists creators and contributors.
Skill content is self-consistent, with consistent structure across skills, but no runtime test results provided. Dependency availability: relies on external tools like Claude Code, npx, but version compatibility not specified. Failure messages: skills include debugging and error recovery processes, but no specific error message examples.
Audience clearly AI coding agents, scenarios cover full development lifecycle. Capability boundaries clear, skills describe use cases. Trigger conditions defined in skill frontmatter, but no precise trigger words. Environment fit good, supports multiple agents and IDEs with installation guides.
Information architecture clear, README provides full directory and skill list. Installation notes detailed, covering multiple tools. Naming stable, skill names consistent. Examples and FAQ present, but no FAQ section. Known limitations mentioned in README (e.g., single-skill install path issue). License MIT, versioning via git and changelog not explicit. Maintenance responsibility clear, team listed.
Output usability high, skills provide structured workflows and verification steps. Marginal value high, provides production-grade engineering practices. Cost-benefit: skills are static files, low installation and usage cost, but require agent support.
Claims traceable, README references Google engineering practices and external resources. Cross-source corroboration limited, no independent verification. Fact-inference separation: skills distinguish verification steps from inferences.
- The skill pack does not explicitly require user confirmation for each action, may auto-execute git commits etc., use with caution.
- Relies on external tools and npx installation, no dependency audit provided, supply chain risk.
- Data flow transparency insufficient, no explanation of how skills handle user data.
What does this agent do, and when should you use it?
Agent Skills is a collection of 24 skills (23 lifecycle skills plus 1 meta-skill) packaged as Markdown that encode senior engineering practices. Each skill has steps, verification gates, and anti-rationalization tables, organized across six phases: Define, Plan, Build, Verify, Review, Ship. It provides 8 slash commands (e.g., /spec, /plan, /build, /test, /review, /webperf) as entry points that automatically activate the right skills. It can be installed into 70+ agents (Claude Code, Cursor, Codex, Copilot, etc.) via the skills CLI, with native integrations for many tools. It also includes 4 agent personas (e.g., code-reviewer, test-engineer) and 7 reference checklists (e.g., definition-of-done, security-checklist). Licensed under MIT.
Agent Skills supplies AI coding agents with a set of executable engineering workflows. It reads the user's request or current context, triggers the appropriate skill automatically based on activity, or is invoked explicitly via slash commands. For example, /spec runs the spec-driven-development skill, guiding the agent to write a PRD (objectives, commands, structure, code style, testing, boundaries) before code; /plan decomposes the spec into small verifiable tasks; /build performs incremental implementation (implement, test, verify, commit per vertical slice); /test enforces red-green-refactor TDD (80/15/5 test pyramid); /review performs a five-axis code review; /ship executes pre-launch checklists. Skills are defined as SKILL.md files, support progressive disclosure, and can pull in supplementary checklists from the references/ directory. Each skill ends with evidence requirements—tests passing, build output, runtime data—never just "seems right."- When starting a new project or feature, use /spec to write a PRD, ensuring requirements and boundaries are clear before coding.
- When breaking down a complex task, use /plan to decompose specs into small, verifiable tasks with acceptance criteria and dependency ordering.
- When implementing logic or fixing bugs, use /build and /test to enforce test-driven development with the red-green-refactor loop.
- Before merging any change, use /review to run a five-axis code review, checking quality, change size, and review speed norms.
- When auditing web performance, use /webperf to invoke the web-performance-auditor persona, measuring Core Web Vitals and guiding optimization.
- When preparing a production release, use /ship to execute pre-launch checklists, feature flag lifecycle, staged rollouts, and rollback procedures.
What are this agent's strengths and limitations?
- Includes 24 structured skills covering the full lifecycle from spec to ship, each with steps and verification gates.
- Embeds Google engineering culture best practices (e.g., Hyrum's Law, Chesterton's Fence, trunk-based development) with anti-rationalization tables to prevent agents from skipping steps.
- Supports 70+ agents via the skills CLI, with native integrations for many tools (Claude Code, Cursor, Codex, Gemini CLI, etc.), making adoption easy.
- Provides 4 expert agent personas (e.g., code-reviewer, security-auditor) and 7 reference checklists to deepen specific scenarios.
- Installing a single skill does not copy the repo-level references/ directory, so supplementary checklists are unavailable (issue #361); manual workaround needed.
- For teams with large legacy codebases, full-lifecycle adoption may be heavy; incremental rollout is recommended (documented in adoption guide).
- Some skills (e.g., doubt-driven-development) may require cross-model escalation, adding external API cost or latency.
- Primarily tailored to the JavaScript/TypeScript ecosystem (testing patterns, examples); other languages may require adaptation.
How do you install or deploy this agent?
The fastest way is via the skills CLI (supports 70+ agents):
npx skills add addyosmani/agent-skills # install all 24 skills
npx skills add addyosmani/agent-skills --list # browse before installingOr install individual skills:
npx skills add addyosmani/agent-skills --skill code-review-and-qualityFor Claude Code, use marketplace install:
/plugin marketplace add addyosmani/agent-skills
/plugin install agent-skills@addy-agent-skillsFor Cursor, copy skills to .cursor/skills/; for Codex, use codex plugin marketplace add addyosmani/agent-skills and codex plugin add agent-skills@agent-skills; for other agents, see docs for detailed guides.
How do you use this agent?
After installation, skills trigger automatically based on your activity or via slash commands. For example, in Claude Code type /spec to start the spec phase, or /build auto to auto-generate a plan and execute all tasks (with one-time approval). Skills are plain Markdown and work with any agent that accepts system prompts or instruction files. See docs/getting-started.md and docs/adoption-guide.md for full workflow and adoption strategies.
How does this agent compare with similar options?
Positioned alongside Superpowers (obra/superpowers) and Matt Pocock's skills (mattpocock/skills). The docs/comparison.md provides an honest side-by-side look at how the three differ and when to reach for each, including a link to a controlled head-to-head experiment.
FAQ
How are these skills different from generic prompts or rules files?
Can I install only some skills instead of all?
npx skills add addyosmani/agent-skills --skill <skill-name> to install a single skill. Note that single installs do not include the references/ directory, which may make some skills less functional.