Every few months, a new framework appears promising to make AI coding agents write better code. Three have risen above the noise in 2025 and 2026: Superpowers by Jesse Vincent, Agent Skills by Addy Osmani, and Matt Pocock's Skills. As of July 2026, their combined GitHub stars exceed 350,000.
But star counts do not tell you what these frameworks actually do, how they differ architecturally, or which one fits your work. After reading all three repos, their launch posts, their own comparison docs, and community discussions, here is what I found.
The Shared Problem They All Solve
AI coding agents default to the shortest path. They skip specs, rush to code, avoid writing tests, and skip security review. This is not a model limitation. The model is optimized to produce output quickly.
The result is code that looks correct but skips the practices that make software reliable. Senior engineers learned decades ago that process matters: spec before code, tests before features, review before merge. AI agents have not learned this, and so far no model improvement has taught it, because the model is optimizing for the wrong thing.
All three frameworks solve this by encoding engineering process into skills: structured markdown instructions that the agent reads and follows. The difference is which process, how strictly, and what trade-offs each one makes.
Superpowers: The Autonomous Pipeline
Created by: Jesse Vincent (obra), October 2025
Repo: as "teasing a spec out of the conversation."
2. Worktree isolation. After design approval, it creates a git worktree. This is a real architectural decision: parallel tasks get isolated workspaces and cannot clobber each other.
3. Writing plans. The design gets broken into small tasks, each 2 to 5 minutes of work. Vincent describes these plans as "clear enough for an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing to follow." Every task has exact file paths, complete code, and verification steps.
4. Subagent-driven development. This is Superpowers' signature feature. Instead of one agent doing everything, it dispatches a fresh subagent per task. A task reviewer then checks spec compliance and code quality before closing. Critical issues block progress.
5. Test-driven development. Strict RED-GREEN-REFACTOR enforced. Write a failing test, watch it fail, write minimal code, watch it pass, commit. Code written before tests gets deleted.
6. Code review. Between tasks, it reviews against the plan and reports issues by severity.
What makes Superpowers distinctive is autonomy. Vincent designed it for situations where you want to hand off a large chunk of work and come back later to a reviewed result. The subagent architecture means the main agent is managing workers, not doing the implementation itself. The trade-off is process weight: the full pipeline feels heavy for a one-line bug fix.
Agent Skills: The Full Lifecycle System
Created by: Addy Osmani, February 2026
Repo: :
"I'll write tests after the code works" — You won't. Tests written after the fact test implementation, not behavior.
"This is too simple to test" — Simple code gets complicated. The test documents the expected behavior.
"Tests slow me down" — Tests slow you down now. They speed you up every time you change the code later.
"I tested it manually" — Manual testing doesn't persist. Tomorrow's change might break it with no way to know.
"The code is self-explanatory" — Tests ARE the specification. They document what the code should do, not what it does.
"It's just a prototype" — Prototypes become production code. Tests from day one prevent the "test debt" crisis.
This is adversarial by design. It assumes the agent will try to cut corners and preempts each rationalization with a rebuttal baked into the skill itself.
Parallel review personas. The /ship command does not just run one review. It fans out four specialist reviewers independently: code-reviewer, security-auditor, test-engineer, and web-performance-auditor. Each runs its own analysis, then results merge into a go/no-go decision.
Osmani explicitly grounds the skills in Google's engineering practices. The README references Hyrum's Law in API design, the Beyonce Rule in testing, Chesterton's Fence in simplification, and trunk-based development in git workflow. These come from .
Agent Skills is also the only framework of the three that ships an eval framework in the repo. It runs in CI and checks that skills route correctly, descriptions carry the vocabulary users actually say, and no two skills collide on routing. If a skill stops triggering, CI catches it rather than you discovering the problem silently later.
Matt Pocock's Skills: The Requirements-First Toolkit
Created by: Matt Pocock (Total TypeScript), 2026
Repo:
SOCIAL SHARE CARD GENERATOR