Agent workflow skills compared: Superpowers, Pocock

A coding agent with no process will write the feature before anyone agreed on what it does, report that the tests pass without running them, and stage every file in the folder. Several open projects give the agent a method instead. If you want a complete methodology, install Jesse Vincent's Superpowers or Matt Pocock's skills: both go deeper on every step than mine. I wrote workflow for design-heavy client work. It is a short loop with written gates (clarify, plan, test first, one implementer and one reviewer per task, verify, report) that hands each step to the design skills, adds the git and reporting rules I want from every agent, and points to those two collections for the deeper version.

The contenders

Skill set	Author	Licence	Best at	Lacks
Superpowers	Jesse Vincent (Prime Radiant)	MIT	A complete method that triggers on its own: brainstorm, plan, a subagent per task with review, TDD, verification	A light touch; its skills are mandatory workflows by design
skills	Matt Pocock	MIT	Small skills you combine: grilling, spec then tickets, TDD, bug diagnosis, code review, domain modelling	One end-to-end loop; you choose the order yourself
Spec Kit	GitHub	MIT	Spec-driven development with documents as artifacts, across many agents	A small footprint: it needs a CLI, Python 3.11 and uv
BMAD Method	BMad Code	MIT; the BMad name is a trademark	A full agile method from a vague idea to working software, sized to the work	Stability today: v7 is a preview alpha, and both release lines need uv
workflow	Molveau Studio	MIT	A short loop with written gates, status and result reports, routing to the design skills	Depth on each step; it sends you to Superpowers and Matt's skills for that

Each one, fairly

Superpowers, by Jesse Vincent

Superpowers is a methodology more than a collection. When the agent sees you are building something, it steps back to ask what you are trying to do, shows the spec in chunks short enough to read, then writes a plan clear enough for a junior engineer with no context. Once you say go, subagent-driven development takes over: a fresh agent per task, its work inspected and reviewed before the next one starts. Red-green TDD, worktrees, systematic debugging and verification before completion round it out. The agent checks for a relevant skill before any task, and the README calls them mandatory workflows. Install it if you want that discipline everywhere; it is on Anthropic's official plugin marketplace. My skill keeps the same shape for implementation, one implementer and one reviewer per task.

Matt Pocock's skills

Matt's repo makes the opposite design choice: small skills you combine. His README argues that frameworks which own the process take control away from you and make bugs in the process hard to fix. grill-me and grilling interview you until a plan holds up, to-spec and to-tickets turn it into a spec and then tickets, and tdd, diagnosing-bugs, codebase-design and code-review cover the build. domain-modeling keeps a shared vocabulary and decision records in the repo. Install it if you want to keep the process in your hands and pick a tool per task.

Spec Kit, by GitHub

Spec Kit makes the specification the source of truth. A CLI, specify, sets up the project, then commands run in the agent's chat: /speckit-constitution once per project, then /speckit-specify, /speckit-plan, /speckit-tasks and /speckit-implement for each feature, with each result reviewed before the next. Bug fixing and idea assessment come as extensions, and presets let an organisation enforce its own standards. It works with many coding agents, which suits a team that uses more than one. It needs Python 3.11 or newer and uv.

BMAD Method, by BMad Code

BMAD covers the whole effort, from what to build to how it changes as you learn, and sizes the process to the work: small changes go straight to build, complex work gets planning depth. The stable line, v6.12, installs with npx bmad-method install. Version 7 ships as skills and plugins but is a preview alpha, and its README warns of breaking changes between updates. Both lines need uv. Install it if your team wants a named agile method with its own vocabulary and is willing to adopt it end to end.

What workflow adds

• One loop with gates. Inspect, clarify, plan, implement test-first, review, verify, report. Each step waits on a written gate: no plan until outcome, rules, scope, states and success criteria are confirmed; no next task until its reviewer passed it on spec, then on quality; no "done" without fresh verification output.
• Routing to the domain skills. A table hands each step to the skill that holds the craft: ui for screens and the mockup loop, ux for copy and accessibility, motion for animation, anti-slop before any UI is called done, design-grill for a deep audit, french-typography for French copy.
• Status and result reports. A STATUS block at checkpoints and a RESULT block at the end, which keep seven delivery states apart: implemented, tested, reviewed, committed, pushed, merged, deployed. "Done" always names which one is true.
• Git hygiene. Branch from an up-to-date main, one feature per branch, stage exact paths and never git add ., and nothing pushed, merged or deployed without the decision owner's go for that change.
• Mockup-first UI. For a new or restyled screen, the decision owner approves a mockup before code. Type checks, lint, tests and the build run before any AI reviewer reads the change.
• A small footprint. One SKILL.md and four reference files, self-contained. It links to Superpowers and Matt's skills as optional depth, with one rule from experience: one planning system per feature, because two produce two sources of truth.

Install

The skill alone, with the skills CLI:

npx skills add molveau/skills -s workflow

The playbooks bundle (saas, vitrine and workflow):

npx skills add molveau/skills -s saas -s vitrine -s workflow

In Claude Code, all eleven skills as one plugin:

/plugin marketplace add molveau/skills
/plugin install molveau-skills@molveau

Every skill and bundle is on the skills page, and the source is at github.com/molveau/skills. Related reading: the Claude Code skills I use, design audit skills, UI skills.

Checklist

• One planning system per feature, whichever collection it comes from.
• Outcome, scope, states and success criteria are written and confirmed before the plan.
• Every feature and every bugfix starts with a failing test.
• Each task has one implementer and one reviewer, spec first, then quality.
• "Done" follows a command run in this session, and the report names the delivery state.
• Nothing is pushed, merged or deployed without an explicit go.