Skip to main content
command CX Codex

parallel-review — Claude Code command: parallel code review

parallel-review runs code review across multiple directories or files simultaneously, one subagent per target.

MIT ★ 1,424 updated 2026-10-06

Install into Claude Code · Manually: put the files in place All methods and platforms ↓
.claude/commands/parallel-review.md
Open on GitHub

What parallel-review does

The command splits a list of targets (directories, files) into independent tasks and spawns a subagent for each with run_in_background: true. All calls must go out in a single message for true parallelism. Each subagent looks for bugs, vulnerabilities, performance issues, and test coverage gaps, then returns its result automatically. The command collects reports, sorts findings by severity, and outputs a prioritized summary with recommended actions.

You need .claude/commands/parallel-review.md in the project root for the command to work. Three parallel reviews take roughly a third of the time sequential ones would — noticeable for large PRs or pre-merge module checks.

What it helps with

  • run reviews of several modules simultaneously instead of sequentially
  • check code in different directories in parallel before merging
  • collect findings from independent parts of a project in one report

Example prompts for the agent

  • review src/auth, src/api, and src/db in parallel
  • run /project-starter:parallel-review src/auth src/api src/db
  • do a review of all modules in src/modules at once

How to install parallel-review

Manually: put the files in place

.claude/commands/parallel-review.md

Call it with /parallel-review. For all projects use ~/.claude/commands/

Questions about parallel-review

How do I install parallel-review in Claude Code?

Place the command file at .claude/commands/parallel-review.md in the project root.

What does parallel-review do?

It runs code review across multiple directories or files simultaneously via subagents — each target is checked in parallel, results are collected into a prioritized summary.

How does the command run reviews in parallel?

It creates a subagent per target with run_in_background: true and sends all calls in one message — Claude Code then launches them simultaneously rather than sequentially.

Source text

parallel-review.md · MIT
---
description: Run parallel code review across multiple directories or files. Uses N subagents simultaneously for faster analysis.
argument-hint: <directories or files to review in parallel, e.g., "src/auth src/api src/db">
---

# Parallel Code Review

Review `$ARGUMENTS` using parallel subagents for maximum speed.

## Process

1. **Parse Targets**: Split arguments into independent review targets
2. **Spawn Parallel Reviewers**: Launch one subagent per target
3. **Collect Results**: Each subagent returns its review automatically on completion
4. **Synthesize**: Merge findings into prioritized report

## Execution Pattern

**CRITICAL**: Launch ALL Task calls in a SINGLE message for true parallelism.

For each independent target, spawn a subagent with `run_in_background: true`:

```
I'm launching N parallel code reviewers:

[Task 1]
description: "Review [target 1]"
prompt: "You are a code reviewer. Analyze [target 1] for:
- Code quality and best practices
- Potential bugs and edge cases
- Security vulnerabilities
- Performance issues
- Test coverage gaps

Provide findings with file:line references and severity levels."
run_in_background: true

[Task 2]
description: "Review [target 2]"
prompt: "You are a code reviewer. Analyze [target 2] for..."
run_in_background: true

[Task 3]
description: "Review [target 3]"
prompt: "You are a code reviewer. Analyze [target 3] for..."
run_in_background: true
```

Each subagent returns its result automatically when it completes — there is no
separate retrieval step. Read each review as it returns.

## Output Format

```markdown
## Parallel Review Results

### Summary

- **Targets reviewed**: N
- **Total findings**: X
- **Critical issues**: Y
- **Execution time**: ~Zs (parallel)

### [Target 1] Findings

#### Critical

- [Issue] at file:line - [Description]

#### Warnings

- [Issue] at file:line - [Description]

#### Suggestions

- [Improvement] at file:line - [Description]

### [Target 2] Findings

...

### Combined Priority List

1. **Critical** - [Target X] - [Issue description]
2. **Critical** - [Target Y] - [Issue description]
3. **High** - [Target Z] - [Issue description]
   ...

### Recommended Actions

1. Fix critical issues in [Target X] first
2. Address security concerns in [Target Y]
3. Consider performance optimizations in [Target Z]
```

## Example Usage

```
/project-starter:parallel-review src/auth src/api src/db
```

This spawns 3 parallel reviewers (one per directory), completing in ~1/3 the time of sequential review.

## When to Use

- Reviewing multiple independent modules
- Pre-merge comprehensive codebase review
- Analyzing different areas of a large PR
- Comparing implementation patterns across directories

© CloudAI-X · MIT · CloudAI-X/claude-workflow-v2

Similar slash commands

All slash commands for Code review and refactoring →

From the same set46

The whole set →
mentor mentor puts the assistant into teaching mode: it explains the reasoning behind code, walks through how it works and suggests what to try next. CX Codex +1 ★ 1,424repo stars review Sets Claude Code to run strict engineering reviews, triaging issues from critical security flaws to minor stylistic fixes. CX Codex +1 ★ 1,424repo stars lint-check lint-check runs the linters your project already configures, sorts findings by severity and can auto-fix style. Useful right before a commit instead of waiting for CI. CX Codex +1 ★ 1,424repo stars run-tests run-tests runs the project's tests in tiers: the ones your changes touch first, then the whole unit suite, then integration. CX Codex +1 ★ 1,424repo stars code-simplifier The code-simplifier command reviews recent changes and proposes cleaner code without changing behavior. Use it after implementing a feature or refactoring. CX Codex +1 ★ 1,424repo stars security-scan security-scan is a command for Claude Code that checks a repository for hardcoded secrets, vulnerable dependencies, injection, XSS and weak config before a commit or PR. CX Codex +1 ★ 1,424repo stars verify-changes verify-changes executes adversarial multi-subagent verification across recent code diffs to weed out bugs and false alarms. CX Codex +1 ★ 1,424repo stars save-session-learnings The save-session-learnings command for Claude Code saves useful findings from a coding session to CLAUDE.md and AGENTS.md after debugging or a substantial task. CX Codex +1 ★ 1,424repo stars

Project sponsors

Companies that keep this analytics open