home / skills / bobmatnyc / claude-mpm-skills / requesting-code-review

requesting-code-review skill

safe

/universal/collaboration/requesting-code-review

This skill dispatches a code-reviewer subagent to catch issues early and ensure implementations align with plan before proceeding.

npx playbooks add skill bobmatnyc/claude-mpm-skills --skill requesting-code-review

Review the files below or copy the command above to add this skill to your agents.

Files (4)

SKILL.md

3.2 KB

---
name: Requesting Code Review
description: Dispatch code-reviewer subagent to review implementation against plan or requirements before proceeding
when_to_use: when completing tasks, implementing major features, or before merging, to verify work meets requirements
version: 1.2.0
progressive_disclosure:
  level: 1
  references:
    - path: references/code-reviewer-template.md
      title: Code Reviewer Template
      description: Complete subagent template with placeholders and review checklist
    - path: references/review-examples.md
      title: Review Examples & Workflows
      description: Good vs bad reviews, severity guidelines, complete workflow examples
---

# Requesting Code Review

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

**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

## Quick Start

**1. Get git SHAs:**
```bash
BASE_SHA=$(git rev-parse HEAD~1)  # or origin/main
HEAD_SHA=$(git rev-parse HEAD)
```

**2. Dispatch code-reviewer subagent:**

Use Task tool with code-reviewer type, fill template at [Code Reviewer Template](references/code-reviewer-template.md)

**Required placeholders:**
- `{WHAT_WAS_IMPLEMENTED}` - What you just built
- `{PLAN_OR_REQUIREMENTS}` - What it should do
- `{BASE_SHA}` - Starting commit
- `{HEAD_SHA}` - Ending commit
- `{DESCRIPTION}` - Brief summary

**3. Act on feedback:**

| Severity | Action |
|----------|--------|
| **Critical** | Fix immediately, don't proceed |
| **Important** | Fix before next major task |
| **Minor** | Note for later, can proceed |

See [severity guidelines](references/review-examples.md#severity-guidelines) for details.

## Integration with Workflows

**Subagent-Driven Development:**
- Review after EACH task
- Catch issues before they compound
- Fix before moving to next task

**Executing Plans:**
- Review after each batch (3 tasks)
- Get feedback, apply, continue

**Ad-Hoc Development:**
- Review before merge
- Review when stuck

## Pushing Back on Reviews

**If reviewer wrong:**
- Push back with technical reasoning
- Show code/tests that prove it works
- Reference plan requirements
- Request clarification

See [pushing back examples](references/review-examples.md#pushing-back-on-reviews)

## Common Mistakes

**Never:**
- Skip review because "it's simple"
- Ignore Critical issues
- Proceed with unfixed Important issues
- Argue without technical justification

**Always:**
- Provide full context in review request
- Fix Critical issues immediately
- Document disagreements with technical justification
- Re-review after fixing Critical issues

## Examples

**Need examples?** See [Review Examples & Workflows](references/review-examples.md) for:
- Complete review output examples
- Good vs bad review requests
- Review workflows for different scenarios
- How to act on different severity levels
- When and how to push back

**Need template?** See [Code Reviewer Template](references/code-reviewer-template.md) for the complete subagent dispatch template.

Overview

This skill dispatches a code-reviewer subagent to inspect recent changes and validate implementation against the plan or requirements before continuing development. It helps catch regressions, design drift, and requirement mismatches early so fixes are small and inexpensive. Use it as a routine gate after tasks, features, or before merging to main.

How this skill works

You provide the subagent with the base and head git SHAs, a brief description of what was implemented, and the plan or requirements it should satisfy. The code-reviewer compares changes between SHAs, evaluates them against the provided plan, and returns findings with severity labels (Critical, Important, Minor) and actionable recommendations. Triage the results: fix critical issues immediately, resolve important issues before the next major task, and track minor items.

When to use it

After completing each subagent-driven task
After finishing a major feature or batch of tasks
Before merging any change into main or a release branch
When you’re stuck or need a fresh perspective
Before a significant refactor to establish a baseline

Best practices

Always include BASE_SHA and HEAD_SHA and a concise {WHAT_WAS_IMPLEMENTED} context
Attach the {PLAN_OR_REQUIREMENTS} so the reviewer can verify intent vs implementation
Treat Critical findings as blockers and fix them before proceeding
Respond to reviewers with evidence if you disagree and request clarification rather than ignoring feedback
Run review after fixes to verify issues are resolved

Example use cases

Automated review after a CI job comparing HEAD to origin/main to catch regressions before merge
Review after a multi-task batch to ensure the combined changes meet the planned feature spec
Request review when a junior developer finishes a task to provide mentoring and catch hidden issues
Run review prior to a large refactor to ensure the pre-refactor baseline is acceptable
Use review when fixing a complex bug to validate the fix and look for related regressions

FAQ

What minimum info does the reviewer need?

Provide BASE_SHA, HEAD_SHA, a short {WHAT_WAS_IMPLEMENTED}, and the {PLAN_OR_REQUIREMENTS}. A one-line {DESCRIPTION} helps focus the review.

How should I act on different severities?

Treat Critical issues as immediate blockers. Fix Important issues before the next major task. Log Minor issues for later unless they accumulate into larger risk.