Requesting code review

Hands finished work to a fresh reviewer subagent through a template: the commit range, the plan or requirements, findings by severity and a verdict on merging. Use when a task or feature is done and a merge to main is next.

Code reviewPack: Superpowers95 linesrequesting-code-review
Author
Source
obra/superpowers/skills/requesting-code-review @ 22f0b46
License
MIT · Copyright (c) 2025 Jesse Vincent

About this skill

What it does

The skill makes the agent hand finished work to a separate reviewer subagent instead of reviewing its own diff. The agent fills a prompt template with the commit range (base and head SHA), a short description of what was built and the plan or requirements, and dispatches a general-purpose subagent. The reviewer never sees the session history, so it judges the code, not the reasoning behind it. Critical findings are fixed at once, Important ones before moving on, Minor ones noted for later; a wrong finding gets pushback with technical reasons.

The template ships as code-reviewer.md. It has the reviewer check plan alignment, code quality, architecture, tests and production readiness; treat what a reasonable user would expect as a requirement even where the spec is silent; list every behavior it set aside as out of scope; and stay read-only on the checkout. It ends with a verdict: ready to merge — yes, no or with fixes.

When to use it, and when not

The skill makes review mandatory after each task in subagent-driven development, after a major feature and before a merge to main, and suggests it when the agent is stuck, before a refactor and after a tricky bug fix.

It needs subagent support and committed work: the template reviews a SHA range, not uncommitted changes. It also forbids skipping review because a change looks simple, so it is a poor default if small fixes should go through unreviewed.

How to run it

The install command below puts the whole folder in place: SKILL.md, code-reviewer.md and the licence. The agent picks the skill up by its description when it finishes a task or a feature; to call it yourself:

  • Claude Code: /requesting-code-review, or ask for the skill by name.
  • Codex: $requesting-code-review.
  • Cursor: type / in the Agent chat and pick requesting-code-review.

Example: /requesting-code-review The rate limiter is committed. Review everything since origin/main against the requirements in issue 42.

The same template runs the final whole-branch review in executing-plans and subagent-driven-development, so install it alongside them; receiving-code-review covers the other side of the review.

How it differs from similar skills

PR review from our catalog makes the current agent the reviewer and reports only bugs it can back with a failure scenario. Requesting code review covers the author's side: preparing the context, handing it to a fresh subagent and acting on the verdict. Self-review before PR is the author checking its own diff, which this skill avoids on purpose: an inline review burns the coordinating agent's context. Doubt-driven development also hands work to a fresh-context subagent, but for each non-trivial decision while the work is still in progress, with a prompt to find what is wrong. Code review against standards and spec runs two fresh subagents in parallel, one for the repo's written standards and one for the spec, and keeps their reports apart. The template gives security one line; for code that handles input, auth or payments, add Security review.

Install

Run one command — it saves SKILL.md and the files it uses into your agent's skills folder. Claude Code and Codex pick up a new skill without a restart; if it does not show up, restart the agent.

Claude Code — macOS, Linux
curl -fsSL --create-dirs -o ~/.claude/skills/requesting-code-review/SKILL.md https://anymodel.org/en/skills/superpowers/requesting-code-review/SKILL.md -o ~/.claude/skills/requesting-code-review/LICENSE https://anymodel.org/en/skills/superpowers/requesting-code-review/LICENSE -o ~/.claude/skills/requesting-code-review/code-reviewer.md https://anymodel.org/en/skills/superpowers/requesting-code-review/code-reviewer.md
Codex, Cursor — macOS, Linux
curl -fsSL --create-dirs -o ~/.agents/skills/requesting-code-review/SKILL.md https://anymodel.org/en/skills/superpowers/requesting-code-review/SKILL.md -o ~/.agents/skills/requesting-code-review/LICENSE https://anymodel.org/en/skills/superpowers/requesting-code-review/LICENSE -o ~/.agents/skills/requesting-code-review/code-reviewer.md https://anymodel.org/en/skills/superpowers/requesting-code-review/code-reviewer.md
Claude Code — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE','code-reviewer.md') { $p = Join-Path "$HOME\.claude\skills\requesting-code-review" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/superpowers/requesting-code-review/$f" -UseBasicParsing -OutFile $p }
Codex, Cursor — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE','code-reviewer.md') { $p = Join-Path "$HOME\.agents\skills\requesting-code-review" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/superpowers/requesting-code-review/$f" -UseBasicParsing -OutFile $p }

Any other agent: save the file into its skills folder, or give it the link to the file: https://anymodel.org/en/skills/superpowers/requesting-code-review/SKILL.md

SKILL.md

Raw

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.

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: git merge-base origin/main HEAD
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 | cut -d' ' -f1)
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]

Common Rationalizations

Excuse Reality
"I'll just review the diff myself instead of dispatching a reviewer" You're the coordinator — reviewing the diff inline burns the context window you need to keep driving the work. Dispatch a reviewer subagent: the diff and the evaluation live in its context, and only the findings come back to you.
"The reviewer needs my whole session history to understand the change" Hand it precisely crafted context, never your session's history. That keeps the reviewer on the work product, not your thought process.

Red Flags

Never:

  • Skip review because "it's simple"
  • Ignore Critical issues
  • Proceed with unfixed Important issues
  • Argue with valid technical feedback

If reviewer wrong:

  • Push back with technical reasoning
  • Show code/tests that prove it works
  • Request clarification

See template at: code-reviewer.md

Connect through AnyModel API

This skill runs on whatever model your agent uses. Point Claude Code, Codex or Cursor at AnyModel to run it on Claude, GPT, Gemini and more with one key — pay per token, no subscription.

More from the pack Superpowers

Brainstorming before you build

Finds out what you want to build and why: one question at a time, its understanding played back part by part, two or three approaches to pick from and a design doc, with no code until you approve it. Use for a new feature or change when the request leaves the essentials open.

Dispatching parallel agents

Splits independent problems between parallel subagents, each with one domain and a self-contained brief with scope, constraints and the report expected back, then checks their edits for conflicts and runs the full suite. Use when several unrelated things fail at once.

Executing plans

Runs a plan from writing-plans in the current session with no subagent per task: tasks in order through TDD, a ledger of progress and rulings that survives context compaction, and one fresh review of the whole branch at the end. Use when per-task review is not needed or there are no subagents.

Finishing a development branch

Finishes a branch: runs the tests, offers to merge locally, open a pull request or keep it as is, reruns the tests after a merge and removes its own worktree, and discards work only after you type "discard". Use when the implementation is done.

Receiving code review

Checks each review comment against the code before changing anything, clears up every unclear item first, pushes back with technical reasons and never performs agreement. Use when working through review feedback without blind fixes.

Subagent-driven development

Executes a plan through subagents: a fresh implementer and reviewer for every task, checking spec compliance and code quality, up to five fix rounds and a final review of the whole branch. Use for a plan of independent tasks when each one needs a review.

Systematic debugging

Keeps the agent from guessing at fixes: reproduce the bug and find the root cause first, test one hypothesis at a time, fix with a failing test, and question the design after three failed fixes. Use for any bug, test failure or unexpected behavior.

Test-driven development, Superpowers style

Drives work test-first: a test seen failing, then the least code that passes and a run of the whole suite; code written before its test is deleted. Use for features and bug fixes when the agent tends to add tests after the code.

Using git worktrees

Moves feature work into an isolated git worktree: checks whether the agent is already isolated, prefers the harness's own worktree tool, keeps the folder git-ignored, installs dependencies and runs a baseline test. Use when the work must not land on the branch you have open.

Verification before completion

Stops the agent from saying "done" or "tests pass" until it has rerun the check and read the whole output. Use whenever the agent reports success, commits or opens a pull request.

Writing implementation plans

Turns a spec into a plan for an implementer new to the codebase: files, signatures, interfaces between tasks, tests with exact values and TDD steps with each command's expected output. Use for a multi-step task when the spec is ready and no code exists yet.

Writing skills

Writes and edits skills the TDD way: a subagent first does the task without the skill and its mistakes are written down, then the smallest text that answers them goes in and the loopholes get closed. Use for a skill that other agents will load.