AIDiveIntro: one repo, two packs, one stays
Superpowers and Matt Pocock's skills are the two skill packs most Claude Code developers weigh against each other, and this video measures them on the same feature, on one repo, with the bill read per stage. Superpowers (v6.4.2) ships fifteen skills and a SessionStart hook that forces them; Pocock's pack (v1.3.1) ships twenty-seven skills, no hook, and a seven-step Main Flow typed as slash commands. The one public measured comparison says Superpowers is far cheaper, and every switcher's blog says Pocock wastes fewer tokens. On these runs both were true at once: Superpowers left to its hook cost a quarter of the Main Flow, and Superpowers driven through its full loop cost almost twice the Main Flow, for the same five of five hidden tests every time. The question the video answers is which pack stays, and which single stage decides the bill.
Two opposite bets: a hook that forces skills vs no hook at all
Superpowers is a plugin with fifteen skills and one hook. At every session start the hook injects the whole using-superpowers skill (492 words) into the context, and that skill tells the model: "If you think there is even a 1% chance a skill might apply to what you are doing, you ABSOLUTELY MUST invoke the skill." The loop it sells runs through four skills: brainstorming, writing-plans, executing-plans, and a review at the end. Install it and the hook is supposed to route a request into that loop on its own.
Matt Pocock's pack is the opposite bet: twenty-seven shipped skills and no hook at all. Nothing is injected; every step is a slash command you type. The Main Flow reads grill-with-docs, to-spec, to-tickets, implement, code-review, pr, retro. The grill-with-docs skill is thirty-five words long and only calls two other skills; implement is a hundred and three words and carries a disable-model-invocation: true flag, so the model cannot load it on its own. Matt's own line on his loop, from the v1.3 changelog: "The agent loop is worse than a deterministic loop. But it is a good way to start with AFK work before your software factory is dialled in."
Both packs install either as a Claude Code plugin or as copied files, and Pocock's readme is blunt about it: pick one per agent, because installing both gives you every skill twice. Nobody had settled the comparison because the only measured head-to-head ran Pocock's pack with five of eight implementation workers never receiving the implement skill, and every switcher's post has opinions and no numbers.
The bench: ledgerly, one request, five hidden tests, and the bare baseline
The repo is ledgerly, an invented invoicing API in plain Node and TypeScript: a domain layer, a JSON file store with schema migrations, an HTTP layer, and thirty-four green tests. The feature request is three lines, typed the way a developer types it: add partial payments, expose the amount paid and the balance, keep the old /pay endpoint working, and remember there is production data in the store. A senior reading that expects five things the request never spells out: the money math, validation, migrating production files, the right error codes, and tests. Those five became hidden acceptance tests the worker never sees; the reference patch passes all five and the untouched repo passes none.
Every run is a fresh copy of the repo, a headless Sonnet 5.5 worker, the same tool allow list, and a scripted product owner: a second headless model with no tools that reads only the five requirements in plain words, answers tersely, and says "go on" when nothing is asked. Every token and skill call is logged per turn. Two limits are stated up front: headless means nobody steers mid-run, and the Superpowers hook fires on turn one only.
Bare Claude Code, with no pack, is the baseline every bar is measured against.
| Config (feature 1) | Hidden tests | Cost per run | Wall clock | Lines changed |
|---|---|---|---|---|
| bare, 3 runs | 5/5, 5/5, 5/5 | $0.34 mean ($0.47, $0.27, $0.29) | 84.5 s | 142 |
Superpowers: what the hook runs alone, and what the full loop costs
Left to its hook, Superpowers behaves like this: the request is pasted, the hook fires, the model opens brainstorming, asks a question or two, and codes. writing-plans ran zero times in three runs and executing-plans never. The result is five of five for about fifty cents and about two minutes, one and a half times bare for the same score, with brainstorming alone costing about twenty-two cents of that. Six one-turn probes showed the routing is random rather than a wiring fault: with the real plugin wiring brainstorming fired one time in three, with the bench's wiring two in three.
Driven by hand, with brainstorming, writing-plans and executing-plans typed as slash commands in Native mode (the default since 6.4.1), every run ran the whole loop. Five of five again, at about $3.74 and ten minutes a run: eleven times bare, seven and a half times the hook-routed run, for the same hidden score.
| Superpowers stage (feature 1 means) | Cost |
|---|---|
| brainstorming | $0.166 |
| writing-plans | $0.266 |
| executing-plans | $3.307 |
| of which the TDD build itself | $0.974 |
| of which the whole-branch reviewer subagent | $2.192 |
The reviewer is the stage that explains the loop's bill. The executing-plans skill dispatches it, in its own words, "on the most capable available model", and in every run that model was the top-tier one. The skill calls it the one fresh context the whole run buys and says not to skip it; on this feature it found nothing the tests had not already proven. On the second feature the same reviewer took $1.602 of a $3.21 run, so it is not a one-off but how the skill is written.
The Main Flow, stage by stage: cheap plans, an expensive build
Pocock's pack is driven the only way it can be: grill-with-docs asks its questions one at a time, about seven per run against one or two for Superpowers' brainstorming; to-spec writes the spec; to-tickets cuts it into tickets; implement builds every ticket in one turn and calls tdd and code-review on its own; pr writes the pull request text. Every run invoked the same four skills in the same order (grilling, domain-modeling, tdd, code-review): the pack is deterministic about its route. Twelve driver turns was the bench's cap, and two of three runs hit it before pr; the one complete run ended on a PR body, which no other pack left behind.
| Main Flow stage (feature 1 means) | Cost |
|---|---|
| grill-with-docs | $0.204 |
| to-spec | $0.118 |
| to-tickets | $0.143 |
| implement | $1.125 |
| code-review | $0.439 |
| pr | $0.041 |
The planning front half costs under fifty cents ($0.465); implement and code-review are three quarters of the bill. The total is about $2.04 and seven minutes a run, five of five every time: four times the hook-routed Superpowers run and forty-five percent less than the driven Superpowers loop. The diff is bigger, about 372 lines against 142 bare, with about 28 tests added against 5, and the token totals match the dollars: about 4.5 million tokens a run against half a million bare, most of it cache reads of a long context. What the Main Flow leaves behind is a spec, tickets and a PR body, which a team may value more than the forty cents they cost; and the twelve-turn cap is the bench's, a human would keep going.
A harder feature: credit notes, and the one bug anybody shipped
Five of five everywhere reads nothing, so a second request went on the same repo: credit notes, two lines with five implicit rules. Never over-credit an invoice and keep the report right; migrate production files; one gapless number sequence; the right error codes; and voiding a paid invoice through a credit note, with the old test rewritten rather than deleted. A first harder candidate was dropped because bare still scored five of five on it. Validation first: the reference patch passes all five, the untouched repo none, and a bare smoke run scored four of five, so the oracle had teeth this time.
| Config (feature 2) | Hidden tests | Cost per run | Tests added |
|---|---|---|---|
| bare, 2 runs | 4/5, 5/5 | $0.41 mean | 5 |
| Superpowers driven, 2 runs | 5/5, 5/5 | $3.21 mean | 33 |
| Main Flow, 2 runs | 5/5, 5/5 | $2.07 mean | 31 |
The one miss: bare run one took the credit-note number before validating the request, the way the existing issue route does, so a rejected request burned a number and CN-0004 was issued where CN-0002 was due. Auditors flag gaps. Both loops caught it the same way, with their TDD step writing a test for the sequence before the code existed; the second bare run also got it right, for forty-five cents. One miss in two bare runs is a data point, not a rate. What the loops buy here is the tests they leave behind, not a score.
Stacking both, and the marketplace trap
The loudest thread on the subject says two packs installed as routers collide on slash names, session hooks and skills competing for the same intent. Installed together in one project and run through the Main Flow, the Superpowers hook injected its text, the six Pocock commands were typed, and not one Superpowers skill was invoked: five of five, $2.33, inside the Main Flow's range. Two reasons: Pocock's user-invoked skills carry a flag that stops the model loading them on its own, and the two packs share no skill name. It is one run, though; in another session the hook could still pull a model-invoked Pocock skill.
The real trap is the version you get. The official Claude plugin marketplace pins Pocock's pack at 1.2.3, seventy-one commits behind upstream v1.3.1. That pinned copy has no implement-spec, no pr and no retro; two issues have been open since October 5, and on October 8 Matt asked Anthropic on X to bump it: "All my users are stuck on v1.2." The same marketplace pins Superpowers one patch behind (6.4.1 against v6.4.2). The installer gets the real release; the plugin gets whatever is pinned the day you install. Check the version line, not this video.
The stage map and the verdict: Superpowers stays
Superpowers stays. Left to its hook it is the cheapest guided path measured: about fifty cents for five of five, one and a half times bare. Its full loop is the most expensive thing measured, about $3.74, and almost all of the gap to the Main Flow is one stage, the whole-branch reviewer that executing-plans sends to the most capable model. Change that one line, or pass a cheaper model, and the loop lands near $1.55, under the Main Flow's $2.04. The stage that decides the bill is the review, not the planning: nobody's grill and nobody's brainstorm moved the number. The hook-routed path has a catch of its own, since the routing is random (one time in three with the plugin wiring); if brainstorming matters to you, type it.
The Main Flow earns the same score with more artefacts at four times the hook-routed bill. Its planning front half, grill-with-docs to to-tickets, costs under fifty cents and is the one thing worth borrowing: install Pocock's pack with the installer rather than the pinned plugin, and type grill-with-docs when a request is fuzzy. Stacking cost nothing on the run.
| Stage map | Decision |
|---|---|
| Superpowers hook-routed (brainstorming, TDD) | keep |
| Pocock's grill-with-docs, to-spec, to-tickets ($0.465) | borrow |
| executing-plans reviewer model line | change |
The limits, plainly: Sonnet 5.5 headless, two features, nineteen runs, a scripted product owner, one bug in nineteen runs, shipped by bare. A bigger feature or a team may weigh the spec and the tickets higher. The free resource is the bench itself: the invented repo, the hidden tests, the driver and the per-stage ledger script, so you can run both packs on your own feature before you lose a day migrating.
