Source: obra/superpowers · Maintainer: community: Jesse Vincent (Prime Radiant) · License: MIT · Checked: 24 October 2026
What is the requesting code review skill?
The requesting code review skill tells a coding agent to stop at set points and send its work to a fresh reviewer subagent, with a git commit range, a short description and the plan or requirements it was meant to meet. The reviewer reports issues by severity, and the agent fixes the serious ones before moving on.
It ships in Superpowers, the open source skill library by Jesse Vincent and Prime Radiant. The skill's description reads: "Use when completing tasks, implementing major features, or before merging to verify work meets requirements".
Its core principle is four words: "Review early, review often." As of 24 October 2026, its skills.sh page listed about 261,800 installs (snapshot, 24 October 2026).
What does it do?
The Superpowers README puts it at step six of the workflow: it "Activates between tasks. Reviews against plan, reports issues by severity. Critical issues block progress."
The SKILL.md makes review mandatory in three places:
- After each task in subagent-driven development.
- After completing a major feature.
- Before merging to main.
It also lists optional moments: when stuck, before refactoring (as a baseline check) and after fixing a complex bug.
The folder holds two files:
SKILL.md: when to ask for review, how to dispatch the reviewer and what to do with the findings.code-reviewer.md: the prompt template the reviewer subagent receives.
How the request works
The agent records two commits, a base and a head, so the reviewer sees exactly the work in question:
BASE_SHA=$(git rev-parse HEAD~1) # or: git merge-base origin/main HEAD
HEAD_SHA=$(git rev-parse HEAD)
It then dispatches a general-purpose subagent with the template filled in. There are four placeholders: a description of what was built, the plan or requirements, the base SHA and the head SHA. In Claude Code, general-purpose is one of the built-in subagents, and each subagent runs in its own context window, per the subagents docs.
The skill is firm that the reviewer gets crafted context, not your conversation. Its rationalizations table explains why the coordinating agent shouldn't review the diff itself: doing it inline uses up the context window it needs to keep driving the work, while a subagent keeps the diff in its own context and returns only the findings.
What the reviewer is told
The code-reviewer.md template casts the subagent as a senior code reviewer and sets several rules:
- The spec is a vision document. Where the plan is silent, the reviewer judges by what a reasonable user would expect. A spec's silence is not permission.
- Declined to judge. Before its verdict, the reviewer lists everything it set aside as out of scope, one line each with a reason, so nothing is dropped silently.
- Read-only. No changes to the working tree, index, HEAD or branch. Other revisions go in a separate
git worktree. - No sub-reviewers. The reviewer does the whole review itself and never spawns more subagents.
- Five areas to check. Plan alignment, code quality, architecture, testing (real behavior, not mocks) and production readiness, including migrations and backward compatibility.
The report has a fixed shape: strengths, issues under Critical, Important and Minor with file and line references, recommendations, and an assessment that answers "Ready to merge?" with Yes, No or With fixes.
What the agent does with the findings
The SKILL.md gives a simple rule set: fix Critical issues immediately, fix Important issues before proceeding, note Minor issues for later, and push back with reasoning if the reviewer is wrong. Its red flags include skipping review because the change is simple and proceeding with unfixed Important issues.
How do you install the requesting code review skill?
As part of Superpowers in Claude Code. The README's install section installs it from Anthropic's official marketplace:
/plugin install superpowers@claude-plugins-official
Plugin skills are namespaced as /plugin-name:skill-name per the Claude Code skills docs, so it appears as /superpowers:requesting-code-review. The README also documents the obra/superpowers-marketplace route and installs for Codex, Cursor, Gemini CLI and other agents.
Just this skill. The skills CLI copies one folder, as shown on the skills.sh page:
npx skills add https://github.com/obra/superpowers --skill requesting-code-review
Add -g to install for all projects. The folder lands in .claude/skills/requesting-code-review/ in your project, or ~/.claude/skills/requesting-code-review/ with -g. Codex and Cursor read the same SKILL.md format; see Codex skills and Cursor skills.
How does it fit with other review skills?
Review has three sides, and Superpowers and other libraries cover them with separate skills.
| Skill | Side of the review | What it does |
|---|---|---|
Superpowers requesting-code-review |
Asking | Dispatches a read-only reviewer subagent with a commit range and the plan |
Superpowers receiving-code-review |
Responding | Verifies each finding against the code, asks, pushes back, fixes one item at a time |
| Matt Pocock's code review skill | Reviewing | Checks a diff against your repo's standards and the original spec |
In the full workflow they chain: this skill produces findings, and receiving-code-review decides which ones to act on and how. The subagent driven development skill reviews every task with its own reviewer prompt and uses this skill's code-reviewer.md template for its final whole-branch review.
How do you use it?
In the plugin it fires between tasks. Standalone, ask for a review when a task or feature is done, or name the skill.
Example prompts (suggestions, not quotes from the repo):
/superpowers:requesting-code-review Review the last commit against Task 3 in docs/plan.md.The CSV import feature is done. Request a code review of everything since we branched from main.Before I merge this branch, dispatch a reviewer with the requirements from issue #84.I'm stuck on this caching bug. Get a fresh review of the last two commits before we keep going.
Requirements: a git repository with committed work, since the reviewer reads git diff between two SHAs, and an agent that can dispatch subagents. A plan file or written requirements makes the plan alignment check meaningful.
Tips and limits
From the files, not from testing:
- Commit before you ask. The review covers a commit range. Uncommitted changes aren't in it.
- Each review costs a fresh context. The reviewer reads the full diff in its own window. Review after every task adds up on long plans.
- The reviewer can be wrong. The skill expects pushback with code or tests as proof; pair it with receiving-code-review for that half.
- It praises first. The template asks the reviewer to acknowledge what was done well before listing issues.
- No scripts run. The skill is instructions and a prompt template; the reviewer runs read-only git commands.
- Audits. As of 24 October 2026, skills.sh showed Pass from Gen Agent Trust Hub, Socket and Snyk.
- License. Superpowers is MIT, so you can copy and edit the skill and template if you keep the copyright notice.
Save it in your Kipt library
In Kipt, open Skills and paste the skill's GitHub folder link into the import box. Kipt reads the SKILL.md and code-reviewer.md; for a repo with many skills it shows a list to pick from, so you can take receiving-code-review in the same import. You can also drop the folder or a .zip. Your skills live in your own private GitHub repo and install into Claude Code or Codex with one command:
npx skills add https://github.com/<you>/<repo>.git --all -g
Kipt is not affiliated with Jesse Vincent, Prime Radiant or Superpowers.
Similar skills
- Receiving code review skill: the other half, for acting on the reviewer's findings.
- Code review skill: Matt Pocock's review against repo standards and the spec.
- Subagent driven development skill: runs a plan with a review after every task and this skill's template at the end.
- Finishing a development branch skill: what happens once review passes and the branch is ready.