agent-skills/docs/comparison.md at main · addyosmani/agent-skills · GitHub

Addy Osmani · article · 2026-07-28 Reader 🖥️

Agent Skills Agentic SDLC Multi-Agent Orchestration Scope Discipline Test-Driven Development

agent-skills, Superpowers, and Matt Pocock's skills all encode good agentic-engineering discipline but optimize for different moments in the work — full product-lifecycle governance with human checkpoints (agent-skills), autonomous reasoning-heavy execution (Superpowers), or a sharp personal daily toolkit (Matt Pocock) — and while the piece insists 'none of them is best in the abstract,' its own structure (author's project profiled first-person, most elaborated column, sole cited empirical case study, broadest 'reach for X' pitch) quietly tilts the honest map toward agent-skills.

practical · technical reference / comparison documentation (repo docs page), structured as an at-a-glance table plus per-project prose profiles and decision guidance — Framed as neutral cartography ('an honest map of how they're shaped differently... we'd rather be fair than flattering'), but it is written by the maintainer of one of the three projects, about that project, in first person ('agent-skills - this project'). It functions simultaneously as documentation and as competitive positioning.

Structure

Part	Role
TL;DR framing	sets the non-competitive premise
'At a glance' table	seven-row comparison matrix (core idea, organizing principle, lifecycle coverage, entry points, tooling reach, distinctive mechanisms, best for)
Per-project profiles	three short prose sections, one per project, in each project's 'own terms'
'A real head-to-head' (Om Mishra case study)	single external, non-Anthropic, non-author data point
'When to pick which'	explicit decision guidance mapped to work-type
Combining-frameworks guidance	practical warning against running two meta-skill routers simultaneously
Sources	links to both other repos and to Om Mishra's write-up

Key terms

meta-skill router (using-agent-skills)
A dedicated skill inside agent-skills whose job is to read an incoming task and route it to the correct lifecycle-phase skill, functioning as the project's organizing mechanism.
review personas
Named, specialized review roles (code-reviewer, security-auditor, test-engineer, web-performance-auditor) that /ship fans out in parallel and merges into one go/no-go verdict.
Common Rationalizations table / Red Flags
A structured table baked into every agent-skills skill enumerating the excuses an agent might give for skipping a step, each pre-rebutted, plus a companion list of warning signs.
worktree isolation
Superpowers' use of git worktrees so that fresh subagents executing parallel tasks don't collide on the same working files.
lifecycle phases (Define→Plan→Build→Verify→Review→Ship)
The full product-development lifecycle, decomposed into six named phases each mapped one-to-one to a slash command, and to agent-skills' organizing principle as a whole.
skills-that-write-skills
A distinctive Superpowers mechanism (mentioned only in the table, not elaborated in prose) where skills can generate or modify other skills.

Propositions

explicitThree 'skills for coding agents' collections — agent-skills, Superpowers, and Matt Pocock's skills — optimize for different moments in the work rather than one being objectively superior; none is 'best in the abstract.'conf: high
explicitagent-skills organizes the entire product lifecycle (Define→Plan→Build→Verify→Review→Ship) as skills routed through a meta-skill, whereas Superpowers concentrates on the core build loop (brainstorm→plan→execute) and Matt Pocock's skills are one expert's personal, curated daily toolkit rather than an exhaustive framework.conf: high
extendsLoop Engineering · p4 — Loop-engineering's five building blocks name 'Skills' as one primitive in the abstract; this document supplies three concrete, competing implementations of that primitive with different organizing principles.
explicitEvery agent-skills skill carries a 'Common Rationalizations' table and 'Red Flags' section as its most distinctive mechanism, framed as the project's answer to the excuse-generation problem in LLM agents.conf: high
extendsAgent Skills · p7 — Reframes the anti-rationalization table/Red Flags mechanism (established as agent-skills' core discipline in the earlier Osmani piece) as the project's key comparative differentiator against Superpowers and Matt Pocock's skills.
explicitagent-skills' /ship command fans out multiple named review personas (code-reviewer, security-auditor, test-engineer, web-performance-auditor) in parallel and merges their verdicts into a single go/no-go decision.conf: high
explicitSuperpowers bets on autonomy and heavy upfront reasoning — Socratic brainstorming before code, fresh subagents that execute and undergo two-stage review (spec compliance, then code quality), and git-worktree isolation for parallel work — with TDD discipline strict enough that it will delete prematurely written code to hold the RED→GREEN→REFACTOR line.conf: high
supportsLoop Engineering · p7 — Superpowers' two-stage subagent review (spec compliance, then code quality) is a concrete instantiation of the loop-engineering principle that the drafting sub-agent and the checking sub-agent should be separated because a model is 'too nice grading its own homework.'
explicitBecause these are markdown skills, not runtimes, individual skills can be cherry-picked across frameworks even though a framework's meta-skill router cannot safely coexist with another framework's router in the same session.conf: high
explicitRunning two frameworks' meta-skills as simultaneous active routers causes command-name collisions and competing TDD philosophies, producing unpredictable behavior rather than combined benefit — so exactly one framework should be the primary router, with skills from the others borrowed à la carte.conf: high
explicitA single controlled experiment (Om Mishra: same model, same repo, same prompt, only the skill framework changed) found agent-skills reached working code faster (~8 vs ~12 minutes) and ran more validation passes (7 vs 5, including the full test suite), catching an out-of-scope compatibility issue the feature-specific tests missed; Superpowers still invested more upfront architectural reasoning, which the experimenter prefers as his daily driver for exploratory or evolving production work.conf: medium
implicitThe document frames itself as fair and neutral ('we'd rather be fair than flattering,' an open invitation to file corrections) while structurally favoring agent-skills: it is the only project introduced in first person ('this project'), it receives the most elaborated profile, it is the only project anchored to an external empirical case study, and its 'reach for X' recommendation is strictly broader (lifecycle + parallel review/security/perf + multi-tool reach) than the corresponding pitches for the other two.conf: medium
implicitMulti-tool reach (how many agent harnesses a skill set runs across — Claude Code, Cursor, Gemini CLI, Antigravity, OpenCode, Windsurf, Copilot, Codex, Factory Droid) is presented as a comparison axis in its own right, implying portability across harnesses is a distinguishing, non-default property of a skill framework rather than something skills automatically have.conf: medium
implicitcontestedBy making 'reach for agent-skills' the recommendation with the broadest lifecycle-phase and mechanism coverage, the comparison implicitly treats more upfront structure (more phases, more named mechanisms, more review personas) as the more sophisticated shape — a framing in tension with Anthropic's own internal finding that skill quality comes from iterative, failure-driven refinement of a few lines (the 'Gotchas' section), not from broader upfront design.conf: medium
contradictsLessons from building Claude Code: How we use skills · p16 — This comparison's breadth-favoring recommendation logic (more phases/mechanisms = the stronger 'reach for X' case) is in tension with Anthropic's internal finding that skill quality comes from iterative, failure-driven refinement of a few lines rather than broader upfront lifecycle design.

Arguments

agent-skills is the strongest choice when you want a guided lifecycle with a human checkpoint at each phase, parallel review/security/perf passes before merge, and coverage that extends past the build loop into security, performance, CI/CD, and launch. strength: medium

Explicit premises:

agent-skills covers the broadest lifecycle (idea refinement through launch), unlike Superpowers (deep on the core build loop only) or Matt Pocock's skills (a personal toolkit).
agent-skills carries distinctive anti-rationalization + Red Flags mechanisms in every skill.
agent-skills fans out parallel review personas at /ship.
One controlled experiment found agent-skills produced faster completion and deeper validation (catching an out-of-scope bug).
agent-skills runs across the most agent tools of the three.

Implicit premises:

Broader lifecycle-phase coverage and more validation passes are the right things to optimize for, independent of task type.
A single practitioner's single-task anecdote generalizes to typical work.
Tooling reach (number of supported harnesses) matters to the reader's decision independent of which harness they actually use.

Inferences:

Narratives

Om Mishra's controlled same-model/same-repo/same-prompt comparison of Superpowers vs. agent-skills, cited via a LinkedIn write-up, showing agent-skills finished faster and ran more validation passes (catching an out-of-scope compatibility bug) while Superpowers invested more upfront architectural reasoning.
→ Supplies the document's only quantitative-feeling evidence, converting an otherwise self-reported comparison into something with an external, third-party data point — while the document itself flags it as 'one developer's single-task experiment, not a benchmark.'

Questions addressed

✅ How does agent-skills differ from Superpowers and Matt Pocock's skills?
Via the at-a-glance table and per-project prose profiles: different organizing principles, lifecycle coverage, entry points, tooling reach, and distinctive mechanisms.
✅ Which framework should I use?
Conditionally: 'reach for X' guidance keyed to the shape of the work (guided lifecycle vs. long autonomous stretches vs. sharp daily toolkit) — 'pick the tool to the task.'
✅ Can these frameworks be combined?
Yes for individual skills (cherry-pick à la carte, since these are markdown files, not runtimes), but no for meta-skill routers — only one framework should be the active router at a time to avoid command collisions and conflicting philosophies.
⭕ Is the comparison itself unbiased, given the author maintains one of the three projects being compared?

Gaps

incompleteThe document leans on the 'using-agent-skills' meta-skill router as agent-skills' defining organizing mechanism but, exactly as in the author's earlier standalone piece on the project, never explains how the router actually decides which lifecycle-phase skill to invoke, nor what happens when it misclassifies a task — a gap already flagged in extract-agent-skills-osmani#g2 and left unresolved here despite this document building its entire comparative case on that mechanism's existence.
Read next: extract-agent-skills-osmani#g2 for the original statement of this gap; would need the agent-skills repo's actual router implementation/prompt to close.
misinformedThe document frames itself as an 'honest map' written to be 'fair rather than flattering,' but the structural asymmetry undercuts the disclaimer: agent-skills is the only project profiled in first person ('this project'), receives the most elaborated column and prose section, is the sole project anchored to an external case study, and is the only one whose 'reach for X' recommendation spans governance, parallel review, security, performance, and the widest tool reach simultaneously. The fairness gesture (linking to both other repos, inviting corrections) is real but doesn't offset the coverage and evidence asymmetry in the document's own structure.
Read next: Compare directly against the Superpowers and Matt Pocock's skills repos' own documentation to see whether their self-descriptions would produce an equally broad 'reach for X' case if written by their own maintainers.
incompleteOm Mishra's experiment — the document's only quantitative-feeling evidence — is explicitly caveated as a single developer's single-task run, not a benchmark: no repetition, no variance, no independent or blinded review of the resulting code, and it measures only speed and validation-pass count, not downstream code quality, maintainability, or defect rate. It says nothing about whether agent-skills' faster completion trades off against the changeability/comprehension concerns this corpus raises elsewhere about AI-generated code.
Read next: extract-osmani-loop-engineering#p12 (comprehension debt grows as a loop ships more code the human didn't write) and the corpus's technical-debt/changeability concepts — neither is engaged by this comparison's speed-and-validation-pass framing.
illogicalThe comparison's recommendation logic implicitly treats more upfront structure — more lifecycle phases, more named mechanisms, more review personas, more supported tools — as the more sophisticated or capable shape, since agent-skills' 'reach for X' pitch is the broadest of the three. That framing is in tension with Anthropic's own internal account of what actually makes skills effective: their best skills 'began as a few lines and a single gotcha' and improved through iterative, failure-driven refinement rather than broad upfront design, and a skill that straddles multiple categories confuses the agent rather than serving it better. This comparison never engages that alternative axis of quality (depth of iterative hardening vs. breadth of upfront lifecycle coverage).
Read next: extract-claude-code-how-we-use-skills#p2 (skills that straddle categories confuse the agent) and #p16 (skill quality driven by iterative refinement from failures, not upfront design) — directly in tension with this document's breadth-favoring recommendation logic.