requesting-code-review

obra/superpowers

Dispatch a code reviewer subagent to catch issues before they cascade.

What is requesting-code-review?

Request focused code review from a subagent reviewer with precise context about your changes. Use after completing tasks, implementing major features, or before merging to verify work meets requirements. The reviewer receives only the work product and diff, not your session history, keeping them focused and preserving your context.

Dispatch a general-purpose subagent configured as a code reviewer
Pass precise context (description, requirements, git SHAs) to the reviewer
Receive structured feedback categorized by severity (Critical, Important, Minor)
Keep reviewer focused on work product, not session history
Preserve your own context for continued development

How to install requesting-code-review

npx skills add https://github.com/obra/superpowers --skill requesting-code-review

Prerequisites

Git repository with commit history
Ability to dispatch general-purpose subagents
Access to code-reviewer.md template

Claude Code

Cursor

Windsurf

Cline

How to use requesting-code-review

1.Get the base commit SHA (e.g., previous commit or origin/main)
2.Get the head commit SHA (current HEAD)
3.Dispatch a general-purpose subagent using the code-reviewer.md template
4.Fill in DESCRIPTION (what you built), PLAN_OR_REQUIREMENTS (what it should do), BASE_SHA, and HEAD_SHA
5.Review the subagent's feedback categorized by severity
6.Fix Critical issues immediately, Important issues before proceeding, and note Minor issues for later
7.Push back with technical reasoning if you disagree with feedback

Use cases

Good for

After completing each task in subagent-driven development workflows
Before merging code to main branch
After implementing a major feature to catch architectural issues
When stuck on a problem to get a fresh perspective
Before refactoring to establish a baseline of current behavior

Who it's for

Developers using subagent-driven development
Teams implementing multi-agent workflows
Engineers working on complex features or refactors
Anyone wanting structured code review before merge

requesting-code-review FAQ

When should I request code review?

Mandatory: after each task in subagent-driven development, after completing major features, and before merge to main. Optional but valuable: when stuck, before refactoring, or after fixing complex bugs.

Why does the reviewer get a separate context instead of my session history?

It keeps the reviewer focused on evaluating the work product itself, not your thought process. This also preserves your own context for continued development without bloating it.

What should I do if the reviewer is wrong?

Push back with technical reasoning. Show code or tests that prove it works, and request clarification. Never ignore Critical issues, but you can dispute feedback if you have valid justification.

Can I skip review for simple changes?

No. The skill emphasizes never skipping review because 'it's simple.' Review early and often to catch issues before they cascade.

What are the severity levels for feedback?

Critical (fix immediately), Important (fix before proceeding), and Minor (note for later). Always fix Critical and Important issues before moving forward.

Full instructions (SKILL.md)

Source of truth, from obra/superpowers.

name: requesting-code-review description: Use when completing tasks, implementing major features, or before merging to verify work meets requirements

Requesting Code Review

Dispatch a code reviewer subagent to catch issues before they cascade. The reviewer gets precisely crafted context for evaluation — never your session's history. This keeps the reviewer focused on the work product, not your thought process, and preserves your own context for continued work.

Core principle: Review early, review often.

When to Request Review

Mandatory:

After each task in subagent-driven development
After completing major feature
Before merge to main

Optional but valuable:

When stuck (fresh perspective)
Before refactoring (baseline check)
After fixing complex bug

How to Request

1. Get git SHAs:

BASE_SHA=$(git rev-parse HEAD~1)  # or origin/main
HEAD_SHA=$(git rev-parse HEAD)

2. Dispatch code reviewer subagent:

Dispatch a general-purpose subagent, filling the template at code-reviewer.md

Placeholders:

{DESCRIPTION} - Brief summary of what you built
{PLAN_OR_REQUIREMENTS} - What it should do
{BASE_SHA} - Starting commit
{HEAD_SHA} - Ending commit

3. Act on feedback:

Fix Critical issues immediately
Fix Important issues before proceeding
Note Minor issues for later
Push back if reviewer is wrong (with reasoning)

Example

[Just completed Task 2: Add verification function]

You: Let me request code review before proceeding.

BASE_SHA=$(git log --oneline | grep "Task 1" | head -1 | awk '{print $1}')
HEAD_SHA=$(git rev-parse HEAD)

[Dispatch code reviewer subagent]
  DESCRIPTION: Added verifyIndex() and repairIndex() with 4 issue types
  PLAN_OR_REQUIREMENTS: Task 2 from docs/superpowers/plans/deployment-plan.md
  BASE_SHA: a7981ec
  HEAD_SHA: 3df7661

[Subagent returns]:
  Strengths: Clean architecture, real tests
  Issues:
    Important: Missing progress indicators
    Minor: Magic number (100) for reporting interval
  Assessment: Ready to proceed

You: [Fix progress indicators]
[Continue to Task 3]