Continuous Code Review
Dispatch focused reviews after tasks, major features, and before merges to catch problems early.
The evidence constrains review context and explicitly requires read-only inspection without modifying the working tree, index, HEAD, or branch state, reducing privilege and data-exposure risk. Points are deducted because user confirmation, sensitive-code handling, subagent data boundaries, feedback rollback, and concrete source attribution are not specified; unverified publisher identity is not independently penalized.
The workflow is internally coherent: obtain Git SHAs, dispatch a general-purpose reviewer, and process feedback by severity; the template also defines read-only behavior and structured output. Points are deducted for dependence on an available general-purpose subagent, Git, and the referenced template, plus missing handling for command failure, unavailable subagents, malformed inputs, and diagnostic failure feedback; static review caps this at 10.
The skill clearly targets review after tasks, major features, before merges, and optionally when stuck or refactoring, with mandatory and optional triggers distinguished. Points are deducted because non-fit boundaries, input requirements, host-environment compatibility, and Chinese-language support are not defined; invocation is reasonably precise but assumes an agent with subagent capability.
The documentation is well organized and includes triggers, steps, placeholders, workflow integration, red flags, and a complete reviewer template; repository context supplies MIT licensing and a package version. Points are deducted because the skill itself lacks installation/dependency notes, changelog or versioning guidance, named maintenance responsibility, and an explicit update path, while reachability of the referenced template is assumed.
The skill turns code review into a structured assessment against requirements, Git ranges, quality, architecture, testing, and production readiness, with severity-based remediation guidance. Points are deducted because the example is illustrative rather than execution evidence, and fixing and verifying findings still requires further agent or user work; static review caps this at 7.
The skill provides auditable base/head SHAs, diff commands, explicit review criteria, and a structured output format, giving limited traceability. Points are deducted because it includes no skill-specific test suite, real CI coverage, or third-party execution evidence, so independent reproduction remains limited; static review caps this at 5.
- The skill sends code-diff and requirements context to a subagent; confirm that proprietary data, credentials, or other sensitive content stays within approved boundaries.
- It depends on Git, subagent dispatch, and the code-reviewer.md template, without defining fallback behavior or diagnostic errors when those dependencies are unavailable.
- The mandatory-review policy adds process cost; users should confirm that it fits the repository and merge workflow.
What does this skill do, and when should you use it?
This skill is the code-review request component of Superpowers, a software development methodology, rather than an implementation tool. It calls for review after every task in subagent-driven development, after major features, and before merging to main. The reviewer receives deliberately scoped context so evaluation centers on the work product and requirements. Feedback is classified as Critical, Important, or Minor and informs whether work should be fixed, paused, or continued.
Runs git rev-parse to obtain a base commit SHA and the current commit SHA; dispatches a general-purpose code-review subagent using the code-reviewer.md template; supplies the work description, plan or requirements, BASE_SHA, and HEAD_SHA; receives review feedback and applies severity-based handling by fixing Critical issues immediately, fixing Important issues before proceeding, noting Minor issues for later, or technically challenging incorrect feedback.
- A team using subagent-driven development wants a review after each engineering task.
- A developer has completed a major feature and wants an independent check before continuing.
- A contributor is preparing to merge to main and needs requirements-focused review.
- A developer is stuck, planning a refactor, or has fixed a complex bug and wants a fresh perspective.
What are this skill's strengths and limitations?
- Defines clear review points after tasks, major features, and before merges.
- Keeps the reviewer focused by supplying crafted context instead of the full session history.
- Provides explicit severity-based handling and blocks progress on Critical issues.
- Ships as part of Superpowers, which the README identifies as MIT-licensed.
- Requires a general-purpose subagent and the code-reviewer.md template.
- The supplied material does not document standalone installation.
- The skill requests review and guides follow-up; it does not implement fixes or provide review-test evidence.
- It relies on Git commit SHAs, and support for non-Git workflows is not documented.
How do you install this skill?
The skill is located at skills/requesting-code-review/SKILL.md in obra/superpowers; the supplied material does not document a standalone installation method. The README says to install the Superpowers collection separately for each coding-agent harness. For Codex CLI, it documents opening /plugins, searching for superpowers, and selecting Install Plugin.
How do you use this skill?
Trigger it after a task, major feature, or before a merge, for example: “I finished the authentication feature; request a code review before merging.” It obtains BASE_SHA=$(git rev-parse HEAD~1) or origin/main and HEAD_SHA=$(git rev-parse HEAD), then dispatches a reviewer with the code-reviewer.md template. After feedback arrives, fix Critical and Important issues before continuing.