Rigorous Code Review Reception
Verify review feedback before changing code, then act on technical evidence.
The skill requires understanding, verification, clarification, and technical pushback before implementation, reducing blind changes and overreach. It does not specify sensitive-data handling, least-privilege boundaries, confirmation for external side effects, rollback, or data-flow disclosure, so points are deducted.
The workflow is internally consistent and covers clarification, technical checking, incremental implementation, and regression checks; it also requires stating when verification is unavailable. However, failure handling for tool errors, malformed input, or missing repository context is underspecified, and static review cannot establish execution reproducibility, so the score remains limited below the static cap.
The trigger and intended audience are reasonably clear: agents receiving code-review feedback. Non-fit scenarios, input/output contracts, semantic false-trigger boundaries, Chinese-language support, and mainland-China environment fit are not described, so points are deducted.
The document is readable and layered, with workflow rules, forbidden behaviors, source-specific handling, examples, and common mistakes. Repository context supplies MIT licensing, a version, and community/update channels, but the target skill lacks its own versioning, changelog, dependency notes, FAQ, and explicit maintenance ownership, so points are deducted.
It provides a directly usable framework for interpreting, verifying, challenging, and implementing review feedback item by item. There is no skill-specific verified output format, representative execution evidence, or comparative benefit evidence, and static review cannot confirm outcomes, so points are deducted.
The SKILL.md rules, pseudocode, and examples are auditable, and the README describes repository-level testing infrastructure. The supplied tests do not cover the target skill's key behaviors, and no execution or independent reproduction was performed, so only limited credit is justified.
- The skill guides code changes and GitHub thread replies but does not define confirmation, permission scope, or rollback requirements for external writes.
- The instruction to ask when verification is unavailable is high-level and lacks diagnosable handling for timeouts, unavailable tools, or conflicting review comments.
- The repository test evidence mainly covers plugins and other components; it does not establish the behavior or effectiveness of receiving-code-review itself.
- No Chinese localization or mainland-China network reachability is documented.
What does this skill do, and when should you use it?
This skill gives coding agents a disciplined process for handling code review feedback. It prioritizes technical verification over performative agreement by requiring the agent to read the complete feedback, restate the requirements, inspect the codebase, and assess whether each suggestion fits the project. Unclear items must be clarified before any implementation, while incorrect or unnecessary suggestions should receive technical pushback. Once the feedback is understood and validated, changes are implemented and tested one item at a time.
Reads the complete review feedback; restates each technical requirement; checks the current codebase, actual usage, compatibility concerns, and regression risks; evaluates suggestions for technical correctness and YAGNI; asks for clarification when an item is unclear; provides technical reasoning when pushing back; implements feedback in the order of blocking, simple, and complex fixes; tests each change individually; and replies to GitHub inline review comments in their existing comment threads.
- A developer receives several review comments and needs to clarify ambiguous requirements before changing code.
- A team receives external architectural or compatibility feedback and must verify it against the current codebase.
- A reviewer requests a supposedly professional feature that may be unused, requiring a YAGNI check before implementation.
- A maintainer needs to apply review feedback incrementally while testing each fix and checking for regressions.
- A developer suspects a review suggestion would break existing behavior and needs evidence-based technical pushback.
What are this skill's strengths and limitations?
- Defines a concrete read-understand-verify-evaluate-respond-implement-test workflow.
- Explicitly discourages blind implementation and performative agreement.
- Covers codebase usage, compatibility, regression risk, and YAGNI checks.
- Addresses both human-partner feedback and external reviews.
- It is a behavioral guide, not a dedicated code-analysis or test-running script.
- Specific test commands, repository tools, and permissions are not defined in the SKILL.md.
- GitHub thread replies require the GitHub CLI and network access, with no authentication setup documented.
- The source provides no standalone test results for this individual skill.
How do you install this skill?
This skill is part of the obra/superpowers repository and is installed with the Superpowers collection. In Claude Code, run /plugin install superpowers@claude-plugins-official. In Codex CLI, run /plugins, search for superpowers, and select Install Plugin. The source does not document standalone installation or manual copying for this individual skill.
How do you use this skill?
After installing Superpowers in a supported coding agent, provide a review task such as: Review these comments against the current codebase, clarify any unclear items, verify each suggestion, then implement and test them one at a time. If any item is unclear, ask for clarification before implementing other items.