Six “Senior Dev” Skill Packs for Claude Code, Tested: Pick One, Not Six

The Claude Skills Field Guide, Part 1 of 5: 30 popular agent skills in five groups, one group per post, each ending with a pick-by-use-case guide. The rule behind the series: don’t install all 30. Install what fits your work.

Ask a coding agent for a CSV export and you get one, with extras: a helper nobody needed, an option you’ll never use, forty lines of tests for twenty of code. Ask it to fix a one-cent rounding bug and it may never write the test that keeps it fixed. Ask for something vague, like “add budgets”, and it guesses what you meant and builds that.

What’s missing is the judgment a senior engineer brings first: is this the real problem, what’s the smallest change that solves it, and how will we know it works?

Six popular skill packs promise to package that judgment: Superpowers, Matt Pocock’s skills, ECC (Everything Claude Code), the Karpathy-inspired guidelines, Ponytail and Addy Osmani’s Agent Skills. They overlap heavily. We read all six, measured what each costs before it does anything, and ran the two most opposite ones, Superpowers and Ponytail, against plain Claude Code on three small tasks. Each pack changes behaviour in the direction it promises. Each also costs you something, and the costs differ a lot.

What a “senior dev” skill pack actually is

A skill is a folder with a SKILL.md file: a name, a description, then instructions. Claude Code keeps only the descriptions in context and reads the instructions when a task matches (we covered the basics in an earlier post[1]). A plugin bundles skills with slash commands, subagents and hooks, scripts that run on events such as session start, with your permissions.[2] So a pack can change your agent in two ways: on demand, when the model decides to load a skill, or always on, when a session-start hook injects instructions into every conversation. The six mix the two very differently, and that matters more than their feature lists.

The six, in one paragraph each

All six are public on GitHub; tested with versions as of early November 2026.

Superpowers (Jesse Vincent and Prime Radiant, v7.0.2) calls itself “a complete software development methodology for your coding agents.”[3] Its 15 skills form a pipeline: brainstorm what you want, plan the work in 2–5 minute tasks, enforce test-driven development (TDD: write a failing test, then make it pass), have subagents implement and review each task, then finish the branch. A session-start hook loads its router skill into every session, and the README calls the workflows “mandatory workflows, not suggestions.”[3] It’s in Anthropic’s official marketplace.

Matt Pocock’s skills (plugin v1.3.2) take the opposite stance. The README says approaches like GSD, BMAD and Spec-Kit “take away your control”; these skills are “small, easy to adapt, and composable.”[4] The best known, /grill-me, has the agent interview you about a plan until every branch is resolved. Others cover TDD, debugging, review, specs and a project glossary.

ECC (Affaan Mustafa, v2.2.3) is the largest by far: 314 skills, 71 subagents and 98 slash commands, plus rules, hooks and AgentShield, a scanner for your agent configuration.[5] A guided installer (npx ecc-universal@2.2.3 setup) picks hook profiles; a paid GitHub App covers private repos from $19 per seat per month.[5]

The Karpathy-inspired guidelines (forrestchang) are the smallest: four principles drawn from Andrej Karpathy’s public complaints about LLM-written code, namely “Think Before Coding”, “Simplicity First”, “Surgical Changes” and “Goal-Driven Execution”.[6] Install them as a plugin or as a CLAUDE.md. The skill's front matter says MIT, but the repo has no LICENSE file.

Ponytail (Dietrich Gebert, v5.3.3) calls itself “lazy senior dev mode.”[7] It climbs a ladder and stops at the first rung that works (does this need to exist, is it already in the codebase, does the standard library do it), never cuts validation or security, and ends every reply with what it skipped. We covered it, and JetBrains’ independent test, in an earlier post.[1]

Agent Skills (Addy Osmani, plugin v0.6.15) maps 25 skills to a lifecycle (define, plan, build, verify, review, ship) with nine slash commands such as /spec, /plan, /build and /ship, and four specialist subagents for code review, security, testing and web performance.[8]

Before they do anything, they cost you context

An enabled plugin is part of every session, not only the ones where you use it.[2] Its descriptions and any injected instructions go out with every request. To size that, we ran Claude Code 2.1.317 headless with Claude Sonnet 5.5 (no MCP servers, no user settings), asked it to reply with one word with each pack loaded via --plugin-dir, and read the input tokens from the result. Two runs per pack agreed to within about 160 tokens.

• Plain Claude Code: Extra input tokens per request: 0 (≈37,300 baseline); What’s in it: system prompt and built-in tools
• Karpathy guidelines (plugin): Extra input tokens per request: ≈100; What’s in it: one skill description
• Matt Pocock’s skills: Extra input tokens per request: ≈880; What’s in it: skill descriptions
• Ponytail: Extra input tokens per request: ≈1,600–1,750; What’s in it: descriptions plus its rules, injected at session start
• Superpowers: Extra input tokens per request: ≈2,180; What’s in it: descriptions plus its router skill, injected at session start
• Agent Skills: Extra input tokens per request: ≈3,540; What’s in it: 25 skill, 9 command and 4 agent descriptions
• ECC (raw plugin, default hooks): Extra input tokens per request: ≈17,000; What’s in it: 314 skills, 71 agents, 98 commands

Most packs add a few hundred to a few thousand tokens, small next to Claude Code’s own 37,000. ECC adds about 17,000, roughly 46% on top, on every request. Its installer offers smaller profiles and its README says to install rules selectively;[5] we loaded it untuned, so a tuned install should cost less (we didn’t measure one).

The Karpathy plugin is cheap because only its description loads; the rules reach the model only if it chooses to load the skill. JetBrains found an earlier Ponytail skill never activated on its own.[9] We didn’t test Karpathy’s activation, but CLAUDE.md is the dependable route if you want the principles every time.

Three tasks, three behaviours

We ran Superpowers (process first) and Ponytail (least code first) against plain Claude Code on a tiny Python ledger app, with hidden acceptance tests the agent never saw: three runs per arm on the first two tasks, two on the third.

Task 1: a well-specified feature. “Add an export subcommand that writes transactions on or after --since to CSV, formatting amounts the way the balance command does." The prompt told the agent nobody would answer questions.

• Hidden checks passed: Plain: 15/15; Ponytail: 15/15; Superpowers: 15/15
• Source lines added (median): Plain: 24; Ponytail: 18; Superpowers: 27
• Test lines added (median): Plain: 25; Ponytail: 14; Superpowers: 26
• Cost per run (median): Plain: $0.063; Ponytail: $0.067; Superpowers: $0.090

All nine runs were correct, including CSV quoting and a clean bad-date error. Ponytail’s was tightest: it handed the existing date parser to argparse as the type converter, so bad dates became usage errors with no extra code. Superpowers cost about 40% more.

Get Sateesh Valluru’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Task 2: a bug report. “My balance is off by a cent: a 19.99 transaction prints 19.98.” The cause sat in a shared parser, int(float(text) * 100), which also fed a monthly report the bug report didn't mention.

• Fixed the root cause (shared parser): Plain: 3/3; Ponytail: 3/3; Superpowers: 3/3
• Monthly report also correct: Plain: 3/3; Ponytail: 3/3; Superpowers: 3/3
• Added a regression test: Plain: 3/3; Ponytail: 0/3; Superpowers: 3/3
• Loaded a debugging skill: Plain: –; Ponytail: –; Superpowers: 3/3 (systematic-debugging)
• Cost per run (median): Plain: $0.057; Ponytail: $0.061; Superpowers: $0.089

Every run fixed the shared parser with exact decimal arithmetic, so the monthly report was fixed too. The difference was the test. Ponytail added none in three runs, but each reply said so plainly (“I didn’t add a regression test for 19.99”), as its “say what you skipped” rule promises. Its README says logic with “a parser, money or security” leaves a small test behind;[7] a one-line money-parsing fix apparently didn’t count. Superpowers loaded its debugging skill every time, wrote the test, and cost about 55% more.

Task 3: a vague request. “Add monthly budgets to the ledger, so I can see when I’m overspending.” This time we left out the note about running unattended.

• What happened: Plain: Built it (2/2); Ponytail: Built a smaller version (2/2); Superpowers: Asked one question, wrote no code (2/2)
• Source lines added: Plain: 49–50; Ponytail: 20; Superpowers: 0

Plain Claude Code built a budget command, about 50 lines plus tests. Ponytail built a 20-line version with one limit flag and listed what it skipped (one run took the limit in raw cents, which works but is clumsy). Superpowers loaded its brainstorming skill, read the repo and stopped, on v7.0.2 too. Both times it named the one thing that changes the design: transactions have no category, so a budget can only be one overall limit unless you add categories. Then it asked.

Interactively, it’s the question a senior engineer would ask. In an unattended or CI run, it’s a stall, which is why the first two prompts said nobody would answer.

What the test doesn’t tell you

This was a light test, and its limits matter:

• Three tiny tasks, two or three runs each. Enough to see personalities, not effect sizes. Superpowers is built for multi-hour planned work, which we didn’t test.
• Four packs were research-only. We measured their context cost but didn’t run their workflows.
• Vendor numbers are vendor numbers. Ponytail reports 53% less code, 41% less time and 26% lower cost across 39 tasks on Opus 5.5.[7] JetBrains measured an earlier version at about a 10% median cost cut.[9] On our tasks, on Sonnet 5.5, Ponytail cost about the same as plain Claude Code and wrote less code.
• --plugin-dir isn't a marketplace install. Real installs can enable different hooks.

Don’t stack them

The authors themselves warn against doubling up. Matt Pocock says to pick one install method, “because installing both gives you every skill twice.”[4] ECC says not to stack a manual install on the plugin.[5] Agent Skills doesn’t wire its own router hook in Claude Code, because Claude Code already routes skills and a second router would sit on top.[8]

Across packs it’s worse: Superpowers, Agent Skills, ECC and Matt Pocock’s skills each have their own TDD skill, review flow and idea of when to plan, so two installs give one model two sets of instructions for the same step. We didn’t test a stacked setup; we’d expect conflicts, not extra benefit.

Then there’s trust: skills are instructions, and hooks run as you.[2] Superpowers’ optional visual companion loads a logo that reports the plugin version to Prime Radiant (opt out with SUPERPOWERS_DISABLE_TELEMETRY).[3] Ponytail writes a local ledger and sends data out only if you configure a webhook.[7] Read the hooks before you install.

Pick by the problem you actually have

• Over-building: too much code, too many abstractions: Start with: Ponytail; Watch out for: Ask for a regression test on bug fixes; it may skip one and tell you
• Guessing what you meant on vague work: Start with: Superpowers (brainstorming) or Matt Pocock’s /grill-me; Watch out for: Superpowers stops to ask, so it doesn't suit unattended runs
• You want a full, opinionated pipeline (spec → plan → TDD → review → merge): Start with: Superpowers; Watch out for: About 40–55% higher cost on small tasks in our runs; it is built for longer work
• You want small tools you pick per task and keep control of the process: Start with: Matt Pocock’s skills; Watch out for: One setup command per repo
• You want lifecycle slash commands your team can share: Start with: Agent Skills; Watch out for: ≈3,500 tokens of descriptions in every session
• You want guardrails for almost no cost: Start with: Karpathy guidelines, as a CLAUDE.md; Watch out for: As a plugin skill, it may not load on its own
• You want a whole harness (agents, rules, hooks, security scan) and will tune it: Start with: ECC; Watch out for: ≈17,000 tokens per request untuned; use a smaller profile

Try one, on a branch of real work, and look at the diff and the bill. The CSV export from the opening is the honest picture: no pack turned wrong code into right code, because all nine runs were right. Each changed which extras you got: fewer lines, a missing test, or a question before any code. Choose the pack whose extras you actually want.

Next, Part 2: research and understanding. Skills that map your codebase, read the web or summarise the last 30 days of discussion, and how far to trust what they hand back.

How we tested: Claude Code 2.1.317, Claude Sonnet 5.5, headless, no MCP servers or user settings, a fresh repo per run, plugins via --plugin-dir (Superpowers 2ce8aa1 = v7.0.1, Task 3 re-checked at 22f0b46 = v7.0.2; Ponytail 96608e0). Total API cost about $2.70. Fixtures, prompts, hidden tests, scripts and per-run diffs are kept in the article's evidence folder.

References

1. “Make Claude Code Feel Lighter: Four Extensions Worth Trying, and What the Numbers Actually Say”, this blog, 12 Oct 2026. https://medium.com/@satvallu/make-claude-code-feel-lighter-four-extensions-worth-trying-and-what-the-numbers-actually-say-9602063681da
2. Claude Code docs, “Plugins overview” (accessed 10 Oct 2026). https://code.claude.com/docs/en/plugins
3. obra/superpowers, README and RELEASE-NOTES (v7.0.1, 21 Oct; v7.0.2, 3 Nov 2026). https://github.com/obra/superpowers
4. mattpocock/skills, README. https://github.com/mattpocock/skills
5. affaan-m/ECC (formerly everything-claude-code), README (v2.2.3). https://github.com/affaan-m/ECC
6. forrestchang/andrej-karpathy-skills, README and `skills/karpathy-guidelines/SKILL.md`. https://github.com/forrestchang/andrej-karpathy-skills
7. DietrichGebert/ponytail, README, `skills/ponytail/SKILL.md` and `benchmarks/results/2026–10–07-agentic.md` (v5.3.3). https://github.com/DietrichGebert/ponytail
8. addyosmani/agent-skills, README and `hooks/session-start.sh`. https://github.com/addyosmani/agent-skills
9. Denis Shiryaev, “Ponytail Skill for Claude Code: Does It Cut Tokens”, JetBrains AI Blog, July 2026. https://blog.jetbrains.com/ai/2026/07/ponytail-skill-claude-tested/