Work in progress
An opinionated, test-first development flow tuned for latest Opus models (claude-opus-5-5 at time of writing).
dietpowers is a fork of tim-hub/superpowers-slim by Tim Bai, itself a cut-down fork of obra/superpowers by Jesse Vincent and Prime Radiant.
I've been a happy (and grateful) Superpowers user for a while. Late 2025 models often felt like pair programming with an enthusiastic puppy, and the methodology and composable skills in the plugin brought needed discipline. But the model baseline has improved since, and I started to sense that aspects of the Superpowers workflow and implementation might be limiting my productivity. Specifically, I wanted:
- A clear path through the flow. Each skill hands on to the next in order, so no step gets skipped, and each review runs in a fresh context that hasn't seen the implementation.
- A spec that stays true. Decisions made after the spec is written go back into it.
- Rigorous review of specs and plans. A hostile review of the spec and the plan catches mistakes before they reach the code, reducing GIGO.
- Enabling focus on when hard problems arise. Questions come close together, so I can stay with an intricate problem mentally.
- Room to think inside a question. One decision at a time, in plain text with the reasoning alongside, so I can explore a tangent, question the options, propose my own, or pause and pick up later.
- Prompts written for the newest Opus models. The skills target only Claude Code and current Opus models, so the prompts and workflows can be tuned for them. (See below for details.)
I started from superpowers-slim because it had already done part of this work.
brainstorm purpose, research if it helps, design; spec written
adversarial-review (spec) hostile review; you decide what matters; fix; one fix check
write-plan tasks: paths, interfaces, tests; no code
adversarial-review (plan) hostile review; you decide what matters; fix; one fix check
execute-plan one task at a time, test first
adversarial-review (code) hostile review of the branch; you decide; fix; one fix check
prove-done fresh full run; each success criterion shown; spec changes listed
finish-branch full suite green, then merge, PR or keep
find-root-cause root cause, failing test, one fix at the source
handle-feedback feedback from people, such as PR comments
update-spec approved change to specified behavior, noted in the spec
triage-open-items open items: group, match the backlog, file, keep or drop
There is no session-start hook, so skills usually won't start on their own. Start a piece of work by typing the skill as a slash command, followed by what you want:
/dietpowers:brainstorm add a CSV export to the reports page
Each skill hands on to the next, and the flow asks before moving on after each review and after execution. Other steps can be started directly:
/dietpowers:adversarial-review the code on this branch against docs/dietpowers/2026-09-24-csv-export-plan.md
/dietpowers:find-root-cause the export test fails on empty reports
/dietpowers:triage-open-items
Ordered by how far each departs from what Superpowers users may expect.
- Imperative skill names.
brainstorm,write-plan,execute-plan,tdd,adversarial-review,prove-done,finish-branch,find-root-causeandhandle-feedbackreplace Superpowers' gerund-based naming convention;adversarial-review,update-specandtriage-open-itemsare new; the review skill is namedadversarial-reviewso it cannot be confused with Claude Code's built-in/review. Skills refer to each other by full name, such asdietpowers:adversarial-review, so bare names cannot collide with other commands. - The spec stays the source of truth. Any change to specified behavior, whether it comes up in planning, execution, review, debugging, PR feedback or from you, goes through one
update-specskill, which the other skills invoke once the spec is approved: you approve the change, only the affected sections change, a dated note under each changed section records what changed, why, and who approved it, and the spec change travels with the code change. A new goal or feature goes back tobrainstorminstead. Before finishing,prove-donepairs each success criterion with the test that shows it and lists every change since approval, so you see drift in one place. - Plan files don't have implementation code. Superpowers writes every line into the plan. In dietpowers, each task in the plan includes only paths, signatures, behaviors and tests, and names the code change that would make each test fail. Our rationale:
- Superpowers plan code is written without being run, then rewritten during execution.
- Opus 5.5 is "strongest on multistep work in a real repository, such as carrying a change through a large code base until its tests pass" (Anthropic).
- Plan defects are often missing decisions, such as an ignored error-handling convention. Paths, interfaces, behaviors and tests capture those; code review catches code bugs later.
- Shorter plans are faster to read and approve.
- Spec, plan and code each get a hostile review. An
adversarial-reviewskill reviews the spec, the plan and the code, each with its own checklist. The reviewer is a fresh subagent on the same model, which has not seen the conversation. - Code is reviewed once, over the whole branch, with a test-suite run and a check for tests that cannot fail.
- Fixes are checked once more, then the loop stops. Code fixes start with a failing test. Once every finding is decided and fixed, one fix check looks only at the fixes; anything it finds comes to you, and no further review runs. In subagent-driven mode, Superpowers allows up to five fix rounds per task.
- Progress through the workflow is guided. After each step, the flow asks whether to continue to the next, with the exception of reviews, which are automatic.
- Brainstorming aims for the simplest well-grounded spec. When outside practice matters it runs a short, cited research round (see
brainstormbelow), always offers the simplest approach and one built on existing libraries or patterns, pushes back on requests with a simpler route, asks only questions that change the design, and writes a spec with fixed sections: constraints, inputs and failure behavior, testable success criteria. - Research and context travel with the work. The spec records the docs, library versions, API details and existing code it relies on, each with the specific fact used. The plan carries those facts once, in a References section, and each task names the references and files it needs. The executor reads both the plan and the spec. In superpowers-slim the plan had no link to the spec and the executor read only the plan, so research reached it only if the plan happened to repeat it.
- Questions come one at a time, in plain text, with the problem, the options, a recommendation and a reason in one message, ending with a
Reply withline. You can answer with an option, your own idea, a question or an aside. - Reviews, brainstorms and triage can pause and resume. Reply
pauseto any finding, design question or triage question; say "resume" later, even in a new session, and the flow picks up from a tracker file in.dietpowers/trackers/. That directory ignores itself in git, so nothing in it is ever committed. - Shared prompt text lives once. Text several skills use, such as the tracker rules and the recommendation checks, is written once in
shared/and read by each skill that needs it. - Later work has one queue. Anything worth doing later, found at any point in the flow, goes to one open-items list instead of the spec's Out of scope section; a triage skill works through it with you against your backlog.
- Prompts tuned for Opus 5.5. Skill and reviewer prompts were grounded against Anthropic's Prompting Claude Opus 5.5 guide. See What changed in each skill.
Taken from the superpowers-slim README. It largely based these changes on Anthropic's post The new rules of context engineering for Claude 5 generation models (July 2026).
- Claude Code only. Upstream supports eleven agent tools.
- 9 skills instead of 14. It deleted
using-superpowers,using-git-worktrees,subagent-driven-development,dispatching-parallel-agentsandwriting-skills. - No session-start hook. Nothing is injected into every session. Each skill loads only when invoked.
- Inline execution. The session that holds the plan implements it, one task at a time. Superpowers' subagent-driven development sends a fresh implementer and reviewers to every task; superpowers-slim dropped it because "that runtime cost dominates everything else these skills do." Superpowers' own 6.4 release later measured its inline mode at about twice as fast and half the cost. dietpowers keeps inline execution and reviews the whole branch once at the end.
- 71% less prose. Each skill is numbered steps. Iron Law fences, rationalization tables and red-flag lists are gone.
- Fewer examples. The good/bad code pairs and worked examples were removed, because the post says examples narrow what the model explores.
- Detail in separate files.
SKILL.mdholds the steps; longer reference material sits in files that load only when the model follows a pointer to them.
/plugin marketplace add slowernet/dietpowers
/plugin install dietpowersFor local development:
claude --plugin-dir /path/to/dietpowers --plugin-dir /path/to/dietpowers/devEvery skill that asks you anything gained the same rule: one question at a time, in plain text rather than the question tool, recommended option first with a reason, ending with a Reply with line. Before long work, such as dispatching a reviewer or writing a spec or plan, and after each of your answers, the model says in one line what it will do next. Most also gained a line asking for short messages that lead with the question or outcome. Code steps always commit on the feature branch, asking once to create it if you are on the base branch. The spec and plan skills ask once per piece of work before their first commit ("I'll work on branch <name>. May I commit the spec and plan to it as we go?"), and the plan records the answer in a Commits: line; if you decline, the spec and plan stay on disk and finish-branch proposes their commits at the end. Nothing is pushed or merged without asking, and nothing is committed to main or master. Every description now says what the skill produces as well as when to use it, and the skills you start directly have an argument hint. When any skill finds later work that the current work does not include, it adds it to an open-items list in .dietpowers/trackers/open-items.md without asking, and says so in one line.
brainstorm(wasbrainstorming)- Description says what it produces and when to use it; "You MUST" and the summary of steps are gone.
- Opens with why the spec matters and a preference for the simplest well-grounded design.
- Reads context beyond what the request names.
- Asks only questions that change the design and records routine calls as assumptions; covers input limits, failure and rerun behavior.
- Pushes back when the request seems mistaken or a simpler change would do.
- Research step after the purpose questions. If outside research would not help the design, it says
No research: <reason>and carries on (replyresearch anywayto override). Otherwise it proposes about three questions; ongo, a subagent answers them with a cited finding per fact, using about five tool calls per question, and suggests a separate deep-research when that is not enough. The spec cites the facts the design uses. Either way, brainstorm prefers what current documentation recommends and avoids what it marks deprecated or insecure. - Approaches must include the simplest one and one built on an existing library or pattern.
- One design approval replaces approval after each section; the self re-read is gone because a review follows.
- Writes
docs/dietpowers/YYYY-MM-DD-<topic>-spec.mdwith fixed sections, including testable success criteria and References. - When a request spans several subsystems, adds the other parts as open items, each to get its own spec later; a suggested deep-research becomes an open item too.
- Hands off to
adversarial-reviewinstead ofwriting-plans. - Records each question, the approaches and the design in a tracker, so you can reply
pauseand resume later.
adversarial-review(new; replacesrequesting-code-review)- Reviews a spec, plan or code with a matching prompt, in a fresh subagent on the same model that reads its own prompt file, and waits for its report. It reads the work from disk, so it does not need anything committed.
- The reviewer grades each finding blocker, major or minor. Minor findings with one obvious fix are fixed with a one-line notice; every blocker and major, and any finding it wants to reject or fix more than one way, comes to you one at a time with a recommendation.
- A finding you defer is either added to the open-items list (add to open items) or left in the review tracker (leave here), as you choose.
- Before offering options for a finding, reads
shared/making-recommendations.md: offers only options that are correct across the system, says why a proposed fix is not offered, and recommends the clearest correct option. - Records every finding, the evidence, the question and your decision in a tracker, so you can reply
pauseand resume later. - Edits a spec or plan under review directly; code fixes start with a failing test; a fix that changes the approved spec goes through
update-spec. - Once every finding is decided and fixed, runs one fix check that looks only at the fixes, then stops.
- Reports outcome first, then asks whether to continue, revise (a new review run of the revision) or stop. The spec and plan carry no review notes; the tracker is the record, and
finish-branchcopies it into the pull request. spec-reviewer.md(wasbrainstorming/spec-document-reviewer-prompt.md, which nothing used): rewritten as a hostile review with nine checks, including input limits, failure behavior, over-complex designs, reference facts, and security and data access (untrusted input, permissions, unbounded reads, missing transactions, deprecated or insecure practices).plan-reviewer.md(waswriting-plans/plan-document-reviewer-prompt.md, also unused): rewritten as a hostile review with eight checks, including tests that cannot fail, missing task context, and security and data access (N+1 queries, unbounded reads, skipped permission checks, deprecated APIs).code-reviewer.md(wasrequesting-code-review/code-reviewer.md): the general "senior reviewer" prompt is replaced by claude-adversarial-review, plus a test-suite run, a check for tests that cannot fail, a check of departures recorded in the plan, a check of the seams between plan tasks, a check for deprecated or insecure practices, and a read-only rule. It reviews every change since the base branch, committed or not, instead of the last commit.
write-plan(waswriting-plans)- No implementation code and no TDD micro-steps.
- Header:
Spec: <path> @ <commit>marking the approved spec (or@ uncommitted),Base:branch,Commits:approved or held back, then goal, architecture, Global Constraints and shared References. - A spec that spans several subsystems goes back through
update-spec, which removes all but one from the spec and adds each as an open item carrying its removed text; one plan per spec. - Each task: Files, Interfaces, Context, Behavior, and Tests naming the change that would make each fail, plus the command to run them.
- Names an existing file for each new one to imitate.
- The banned-phrase list, the self re-read and the subagent-era lines are gone.
- Writes
docs/dietpowers/YYYY-MM-DD-<topic>-plan.mdand hands off toadversarial-review.
execute-plan(wasexecuting-plans)- Reads the plan and the spec.
- Builds each task with
tdd, uses the plan's checkboxes as its task list, and usesfind-root-causefor unclear failures. - Makes routine calls itself and records each as a
Departure:line under its task in the plan; asks only about changes to interfaces, requirements or other tasks, and routes changes to specified behavior throughupdate-spec. - Names the stops it should and should not make.
- Works on the plan's branch; the optional worktree step is gone.
- Stops and asks when a declined spec change leaves a task unbuildable.
- Ends with a short report, then asks before code review; it used to go straight to finishing.
tdd(wastest-driven-development)- Explains why the test comes first.
- Starts from the plan's Tests.
- Code must work for every valid input, including those no test covers; a test is never weakened to get green, and a test that is wrong because the spec is wrong goes through
update-spec. - Returns to the skill whose steps it is working within, or to
execute-planwhile the plan has unticked tasks; only on its own does it hand off toadversarial-review. writing-good-tests.md: the separate checklists are merged into one closing checklist, and it gains a contents line; the quotes from Superpowers' author are gone. New: expected values taken from the spec or requirement before reading the implementation; deterministic, isolated, straight-line tests with clear failure messages; an order of preference for test doubles (real, then fake, then stub or mock), asserting outcomes before calls; the spec's input limits and failure behavior in the mutation check; and the project's existing suite takes precedence.
prove-done(wasverification-before-completion)- Runs at the end of a finished, reviewed branch instead of before any commit, and returns to
handle-feedbackwhen that skill invoked it; otherwise it hands on tofinish-branch. - Runs the full suite, linter and build fresh.
- Lists every change to the spec since approval, from its
Changednotes checked against git history from the plan'sSpec:commit when there is one. - Pairs each current success criterion with the test or command that shows it, and never passes a criterion the code and spec disagree on; it asks you which side should change, fixes code through
tddand runs again, and with no spec uses the review's requirements. - Hands on to
finish-branchonly when everything passed; otherwise it reports what is unmet and stops. - The paragraph about paraphrases and "expressions of satisfaction" is gone.
- Runs at the end of a finished, reviewed branch instead of before any commit, and returns to
finish-branch(wasfinishing-a-development-branch)- Reuses
prove-done's run instead of running the suite again. - Stops on failing tests or unmet success criteria.
- When the spec and plan were held back, proposes their commits before the menu and creates them only after you approve; declining leaves only "keep".
- On a merge conflict, aborts the merge; if tests fail after a local merge, offers to undo it with your confirmation.
- Asks the integration menu as one question, recommending the pull request unless you've said otherwise.
- Writes the PR description from the run: what changed and why with a spec link, the commits grouped by plan task, each success criterion with its evidence, the spec's
Changednotes, the review record from this branch's trackers (fixed findings with their evidence; deferred, won't-fix, rejected and duplicate findings with their reasons), and anything left open. After a local merge, the final report lists the deferred, won't-fix and rejected findings. - When a pull request is already open, pushes (after your approval) instead of showing the menu, and returns to the skill that invoked it.
- When there are open items, asks "Triage them now?" before the menu or the push; on the PR-feedback path
handle-feedbackasks it instead, after posting its replies. - Hands off to
handle-feedbackwhen PR comments arrive.
- Reuses
handle-feedback(wasreceiving-code-review)- Opens with why: feedback is a claim to check, answered with changes and evidence.
- Starts by finding the pull request, its comments, and the spec and plan it links, so it works in a fresh session.
- Scoped to feedback from people and pull requests.
- An item that could be read two ways blocks only itself and what depends on it.
- Changes to specified behavior go through
update-spec; each fix starts with a test that reproduces the problem. - Commits each fix with its test; asks one question, "Push the fixes and post these replies?"; posts in-thread only after
prove-doneandfinish-branchhave pushed the fixes; then, when there are open items, asks "Triage them now?".
update-spec(new)- The one way specified behavior changes once you have approved the spec: states the change, gets approval, edits only the affected sections plus the plan's matching tasks, Global Constraints and References, adds a dated
Changednote under each edited section, and commits with the code. - A declined change edits nothing, and the calling skill drops it, or stops and asks when it cannot go on without it.
- With no approved spec, says so and stops.
- For a new goal or feature, asks whether to add it as an open item and carry on, or to pause and start it with
brainstorm. - Called from
write-plan,execute-plan,adversarial-review,tdd,handle-feedback,find-root-causeandprove-done, or directly by you.
- The one way specified behavior changes once you have approved the spec: states the change, gets approval, edits only the affected sections plus the plan's matching tasks, Global Constraints and References, adds a dated
triage-open-items(new)- Works through
.dietpowers/trackers/open-items.md: groups related items and merges duplicates, reads the backlog (from your project instructions or memory, asking once if neither says) and recommends, per item, file new, add to #N, keep or drop. - Asks one item at a time and carries out each answer before the next; items with an outcome leave the list, kept items stay for the next triage.
- Commits nothing; can be paused and resumed like a review.
- Works through
find-root-cause(wassystematic-debugging)- Opens with why the cause comes before the fix.
- A bug in the spec goes through
update-specbefore the fix. - Returns to the skill whose steps it is working within, or to
execute-planwhile the plan has unticked tasks; otherwise commits and hands off toadversarial-reviewinstead oftest-driven-development. defense-in-depth.md("validate at EVERY layer") is replaced byguards-after-a-fix.md: validate at system boundaries, and add an internal guard only where the bug showed the boundary can be bypassed, with a test.root-cause-tracing.mdloses its diagrams, "NEVER" nodes and session anecdote (739 to 375 words).condition-based-waiting.mdis trimmed, and its 666-word example file, written for one specific project, is gone. It now lives inshared/, sincetdduses it too.find-polluter.shstops with an error when the pollution exists before any test runs, instead of reporting "all tests clean"; runs test paths containing spaces as one file; is run from the project root by its full path; and no longer calls itself a bisection script.
- Anthropic, Prompting Claude Opus 5.5: the primary guide.
- Anthropic, Prompting Claude Opus 5: fallback from the above.
- Anthropic, Prompting best practices.
- Anthropic, The new rules of context engineering for Claude 5 generation models.
- Claude Code skills documentation and Anthropic's skill authoring best practices.
- claude-adversarial-review.
- obra/superpowers release notes and issues #2017 and #2112.
- Google, Software Engineering at Google: Unit Testing and Test Doubles.
- Kent Beck, Test Desiderata.
- From Business Requirements to Test Assertions and VibeCheck, 2026 preprints, not yet peer reviewed.
- Birgitta Böckeler, Understanding Spec-Driven Development.
See AGENTS.md. Run bash tests/skills/check-skills.sh after any skill edit.
To trial the flow, also load dev/ (--plugin-dir /path/to/dietpowers/dev), which logs problems with the skills to .dietpowers/problems.md in the project you are working on.
MIT, see LICENSE. The upstream projects keep their copyright.