Deep Comparison of AI Agent Skill Frameworks: Matt Pocock Skills, Superpowers, and Agent Skills

Overview

This article compares three AI‑agent skill frameworks— Matt Pocock Skills , Superpowers , and Agent Skills —to help developers and tech leads select a solution that fits their workflow, token budget, tooling preferences, and quality requirements.

Core Comparison Matrix

Dimension                Matt Pocock Skills   Superpowers          Agent Skills
--------------------------------------------------------------------------
Positioning               Engineering practice   Programming workflow   Production‑grade skills
Author background         TypeScript educator     Community driven     Google engineer
Core philosophy          Deep alignment + feedback   Systematic workflow   Structured lifecycle + verification gates
Skill count               ~16 directories        Upstream + forks      20 core skills + 3 agents + 4 checklists
Skill granularity          Coarse (methodology)   Medium (process)      Fine (workflow step)
Learning curve            Low (≈30 min)          Medium                Medium
Token consumption (rel.)  Low‑Medium            Medium‑High           Low‑Medium
Tool support               Claude Code (primary) 10+ IDE/CLI plugins   8+ IDE/CLI tools
Community size             39 k★                 172 k★                25.7 k★
Documentation quality       Excellent              Excellent             Excellent
Chinese support            English only          Community Chinese forks  English only
Unique advantage           Deep alignment + architecture   Full workflow chain + plugin ecosystem   Verification gates + anti‑rationalization

Detailed Feature Comparison

Matt Pocock Skills

/grill-me

– deep alignment before coding /grill-with-docs – alignment with documentation /tdd – test‑driven development (red‑green‑refactor) /diagnose – systematic debugging /triage – issue classification /to-prd – generate product requirement document /to-issues – split plan into vertical slices /improve-codebase-architecture – architecture optimisation /caveman – minimise token usage (≈75 % reduction) /write-a-skill – create a new skill

Superpowers

brainstorming

– idea generation → specification writing-plans – create implementation plan executing-plans – execute plan step‑by‑step test-driven-development – TDD workflow systematic-debugging – four‑stage debugging requesting-code-review / receiving-code-review – code‑review workflow

Plugin directories for Claude, Cursor, Codex, etc. verification-before-completion – final verification step dispatching-parallel-agents – parallel agent execution using-git-worktrees – Git worktree support

Agent Skills

Lifecycle commands: /spec, /plan, /build, /test, /review, /ship, /code-simplify 20 core skills covering idea refinement, spec‑driven development, incremental implementation, UI engineering, security hardening, performance optimisation, CI/CD, documentation, etc.

Three expert agents: code‑reviewer, test‑engineer, security‑auditor Four reference checklists: testing patterns, security checklist, performance checklist, accessibility checklist

Anti‑rationalisation design – each skill lists common excuses and rebuttals; verification gates require concrete evidence

Architecture Highlights

Matt Pocock Skills – document‑driven structure ( CONTEXT.md, ADRs) with independent skill directories loaded on demand.

Superpowers – plugin‑based architecture separating skills and commands; synchronises with upstream while allowing local Chinese forks.

Agent Skills – lifecycle‑driven (DEFINE → PLAN → BUILD → VERIFY → REVIEW → SHIP); verification gates embedded; supports multiple IDE/CLI tools via .claude/commands/ and .gemini/commands/.

Token Consumption (Relative)

Framework          Initial load   Per interaction   Optimisation tips
-------------------------------------------------------------------
Matt Pocock Skills   Low‑Medium      Low               Load skills on demand; use /caveman to trim context
Superpowers          Medium‑High    Medium            Split long workflows; use sub‑agents
Agent Skills         Low‑Medium      Low‑Medium        Progressive disclosure; activate only needed phases (/spec → /ship)

Pros and Cons

Matt Pocock Skills

✅ Deep alignment, feedback loops, architecture awareness, low learning curve, model‑agnostic, highly composable.

❌ Limited tool support (Claude Code), only ~16 skills, no Chinese documentation, small community, no formal skill format.

Superpowers

✅ Complete end‑to‑end workflow, broad IDE/CLI coverage, large active community, mature methodology, Chinese community forks.

❌ Medium learning curve, higher token usage, contribution policy can be opaque, medium skill granularity, fork management overhead.

Agent Skills

✅ Structured lifecycle, anti‑rationalisation, strict verification, Google engineering culture, progressive disclosure, expert agents, multi‑tool support.

❌ Medium learning curve, no Chinese documentation, smaller community, fine‑grained skill set may require selection effort, Google‑centric practices may not fit all teams.

Scenario Recommendations

Personal developer – use Matt Pocock Skills for quick onboarding, deep alignment, and TDD‑based quality.

Small team (3‑10) – choose Superpowers for its full workflow chain, extensive plugin ecosystem, and Chinese support.

Mid‑large team (10+) – adopt Agent Skills for structured lifecycle, verification gates, and expert agent reviews.

Enterprise project – combine all three: Matt Pocock Skills for deep alignment, Agent Skills for production‑grade workflow, Superpowers for tool coverage.

Combination Strategies

Matt Pocock + Agent Skills

1. Deep alignment (Matt Pocock Skills):
   /grill-with-docs → ensure AI understands requirements
2. Structured development (Agent Skills):
   /spec → /plan → /build → /test → /review → /ship
3. Architecture optimisation (Matt Pocock Skills):
   /improve-codebase-architecture

Superpowers + Agent Skills

1. Structured development (Agent Skills):
   /spec → /plan → /build → /test → /review → /ship
2. End‑to‑end workflow (Superpowers):
   brainstorming → writing-plans → executing-plans
3. Expert review (Agent Skills agents):
   code‑reviewer → test‑engineer → security‑auditor

All Three Combined

1. Deep alignment (Matt Pocock Skills): /grill-with-docs
2. Structured lifecycle (Agent Skills): /spec → /plan → /build → /test → /review → /ship
3. Full workflow & tool coverage (Superpowers): brainstorming → writing-plans → executing-plans (use superpowers‑zh for Chinese forks)

Decision Factors

Team size (individual → small → mid‑large → enterprise)

Token budget (see token consumption table)

Tool preference (Claude‑only vs multi‑IDE)

Need for Chinese documentation

Learning cost (low → medium)

Quality requirements (basic → production‑grade)

References

Matt Pocock Skills – https://github.com/mattpocock/skills Superpowers – https://github.com/obra/superpowers (Chinese fork: https://github.com/jnMetaCode/superpowers-zh)

Agent Skills – https://github.com/addyosmani/agent-skills Google Engineering Practices – https://google.github.io/eng-practices/ Software Engineering at Google –

https://abseil.io/resources/swe-book