/do-review

Code review on your recent changes using the comprehensive-review plugin. Step 3 in the Development Flow.

Usage

/do-review                    # Review all uncommitted changes
/do-review HEAD~3..HEAD       # Review specific commit range
/do-review --branch           # Review current branch vs main
/do-review --security         # Include security audit
/do-review --full             # Run all 3 review agents

What It Does

Checks for the plugin — requires comprehensive-review
Gathers changes — uncommitted, commit range, or branch diff
Loads coding standards — matches file extensions to installed skills
Spawns review agents — 2 by default, 3 with --security/--full
Shows findings — grouped by perspective with actionable suggestions
Offers to apply — incorporate feedback directly or pick specific items

Review Agents

Agent	Focus	When
`architect-review`	Architecture, design, SOLID, scalability	Always
`code-reviewer`	Code quality, maintainability, best practices	Always
`security-auditor`	OWASP, vulnerabilities, auth, input validation	`--security` or `--full`

Agents run in parallel — the review takes about as long as the slowest agent, not the sum.

Review Scopes

Invocation	What gets reviewed	When to use
`/do-review`	Staged + unstaged changes	Before committing
`/do-review HEAD~3..HEAD`	Specific commit range	Reviewing recent commits
`/do-review --branch`	Current branch vs main	Before creating a PR

Scope and agent flags combine freely: /do-review --branch --full

Example Session

You: /do-review

Claude: Reviewing uncommitted changes (4 files, ~120 lines)...

## Architecture Review (architect-review)

1. Dependency direction: utils/auth.py imports from handlers/
   — this inverts the dependency. Utils should not depend on handlers.

## Code Quality Review (code-reviewer)

1. process_items() has a nested loop that could be O(n*m).
   Consider using a dict for lookups.

2. Function getData doesn't follow snake_case convention
   per project standards.

Review complete. 2 agents, 3 findings total.

Incorporate feedback? [Yes / No / Pick specific items]

You: Yes

Claude: Applied all 3 suggestions.
        Run /do-review again to verify, or commit.

How It Fits the Workflow

1. SPECIFY (/design or CLAUDE.md)
         │
         ▼
2. IMPLEMENT (write code + tests)
         │
         ▼
3. REVIEW (/do-review)  ◄── you are here
         │
         ▼
   Back to 1. or /wrapup → /clear

/do-review fills the gap between implementing and committing. It automates what the Development Flow describes as Step 3.

What Gets Passed to Review Agents

The command automatically gathers:

The diff — what changed
Changed file list — agents read full files for context
Coding standards — from skills matching the file extensions
Project context — tech stack and current task from CLAUDE.md

You don’t need to provide any of this manually.

Large Changesets

For diffs over 20 files or 500+ lines, Claude will warn you:

Large changeset: 32 files, ~800 lines changed.
Review may be less thorough. Continue as-is, or narrow the scope?
[Continue] / [Specify files or range]

You can narrow with a commit range or review in smaller batches.

vs /design —review

	/do-review	/design —review
Reviews	Code changes (diffs)	Design Records
When	After implementing	During design
Focus	Architecture, code quality, security	Problem clarity, story quality, completeness
Agents	architect-review + code-reviewer (+ security-auditor)	architect-review only
Scope	Git changes	Record content

Prerequisites

Requires the comprehensive-review plugin. If not installed:

comprehensive-review plugin is not installed. This command requires it.

Install it: /claude-code-setup → External Plugins

Tips

Run after implementing but before committing — catches issues early
Use --branch before creating PRs for a comprehensive review
Add --full for security-sensitive changes (auth, API endpoints, data handling)
Coding standards are included automatically — no need to mention them
You choose what feedback to act on — nothing is applied without your say
Works well with /with-advisor: advisor during implementation, review after

/design —review - Design review (not code review)
comprehensive-review - The review plugin
Workflow - Where /do-review fits

/design /with-advisor