Source: obra/superpowers · Maintainer: community: Jesse Vincent (Prime Radiant) · License: MIT · Checked: 24 October 2026
What is the receiving code review skill?
The receiving code review skill tells a coding agent what to do when review feedback arrives: check each point against the actual code before changing anything, ask about anything unclear, and push back with reasons when a suggestion is wrong. It replaces the agent's habit of agreeing with everything and then implementing it blindly.
It ships in Superpowers, the open source skill library by Jesse Vincent and Prime Radiant, where the README lists it as "Responding to feedback". The skill's description reads: "Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation".
Its core principle: "Verify before implementing. Ask before assuming. Technical correctness over social comfort." As of 24 October 2026, its skills.sh page listed about 221,000 installs (snapshot, 24 October 2026).
What does it do?
The folder holds one file, SKILL.md. It triggers whenever the agent receives review feedback, and especially when that feedback is unclear or looks technically doubtful.
The agent follows a six-step response pattern: read all the feedback without reacting, restate each requirement in its own words or ask, verify it against the codebase, evaluate whether it is sound for this codebase, respond with an acknowledgment or reasoned pushback, and implement one item at a time with a test after each.
The rules that change behavior most:
- No performative agreement. "You're absolutely right!", "Great point!" and thanks of any kind are on the forbidden list. When feedback is correct, the agent states the fix ("Fixed. [Brief description of what changed]") or just makes it.
- Clarify before implementing anything. If you say "fix 1 to 6" and items 4 and 5 are unclear, the agent asks about them before touching 1, 2, 3 or 6, because items may be related.
- Treat sources differently. Feedback from you is trusted and implemented once understood. Feedback from outside reviewers gets five checks: is it correct here, does it break something, is there a reason for the current code, does it work on all supported platforms, and does the reviewer have full context.
- YAGNI check. If a reviewer asks to "implement properly", the agent first searches the codebase for real usage. If nothing calls the code, it proposes removing it instead.
- Fix in a set order. Blocking issues such as breaks and security first, then simple fixes like typos and imports, then complex refactors, testing each fix and checking for regressions.
- Reply in the thread. On GitHub, it answers inline review comments in the comment thread, not as a top-level PR comment, using the replies endpoint for review comments that GitHub's REST docs describe.
If the agent pushed back and turns out to be wrong, the skill wants a short factual correction, not a long apology or a defense.
How do you install the receiving code review skill?
As part of Superpowers in Claude Code. The Superpowers README 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:receiving-code-review. The README also documents a second route through obra/superpowers-marketplace 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 receiving-code-review
Add -g to install for all projects. The folder lands in .claude/skills/receiving-code-review/ in your project, or ~/.claude/skills/receiving-code-review/ with -g. Codex and Cursor read the same SKILL.md format; see Codex skills and Cursor skills.
How is it different from other code review skills?
Most review skills cover writing the review. This one covers what happens after.
| Skill | Side of the review | What it does |
|---|---|---|
Superpowers receiving-code-review |
Responding | Verifies feedback, asks, pushes back, fixes one item at a time |
Superpowers requesting-code-review |
Asking for review | Dispatches a reviewer subagent with the commit range and requirements |
| Matt Pocock's code review skill | Reviewing | Checks a diff against your repo's standards and the original spec |
They fit together. A reviewer subagent from requesting-code-review, or from the code review skill, produces findings; receiving-code-review decides which ones to act on and how. The requesting-code-review SKILL.md makes review mandatory after each task in subagent-driven development, after a major feature and before merging to main, so in the full Superpowers flow this skill runs often.
How do you use it?
It loads when the agent receives review feedback, so pasting a review or pointing it at PR comments is usually enough. You can also name it.
Example prompts (suggestions, not quotes from the repo):
Here's the review from the PR. Go through it with receiving-code-review: verify each point before changing code./superpowers:receiving-code-review Address the inline comments on PR #212 and reply in each thread.The reviewer wants a caching layer for this endpoint. Check whether anything actually calls it first.Fix items 1 to 6 from my notes. Ask me about anything unclear before you start.
Requirements: none beyond your project's tests. For GitHub thread replies the skill uses gh api, so the GitHub CLI needs to be installed and signed in to an account with access to the repo.
Tips and limits
From the files, not from testing:
- Expect blunter replies. The skill forbids thanks and praise in responses. If your team expects a softer tone in PR threads, say so in your instructions; Superpowers says your instructions take precedence over its skills.
- It treats you as the tie-breaker. If outside feedback conflicts with decisions you made earlier, the agent stops and asks you rather than choosing.
- Review comments are outside input. The agent reads text that other people wrote. Review what it plans to change, especially on public repos.
- Nothing runs on its own. There are no bundled scripts; GitHub replies go through
gh apiwith your credentials. - Audits. As of 24 October 2026, skills.sh showed Snyk as Warn: its audit, dated 15 September 2026, flagged medium risk from third-party content exposure (indirect prompt injection), because the skill ingests outside review comments. Gen Agent Trust Hub and Socket showed Pass.
- License. Superpowers is MIT, so you can copy and edit the skill 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; for a repo with many skills it shows a list to pick from, so you can take requesting-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
- Code review skill: Matt Pocock's two-axis review that produces the findings this skill responds to.
- Verification before completion skill: proves each fix with fresh test output before claiming it's done.
- Systematic debugging skill: root cause first when a review points to a real bug.
- Code review prompts: prompts for asking an AI to review your code.