Preface¶

Performing a Code Review before merging a PR is an almost unavoidable step in most development teams. When the changes are minor, manually scanning through the diff is manageable. But once it involves authentication logic, payment flows, or critical hot paths, reviewers often have to switch back and forth between security, performance, correctness, and readability — a single-threaded brain can barely focus on four dimensions at once, and missing one type of problem is not uncommon.

Since Agent 2.0, Cursor has supported launching parallel sub-Agents via the Task tool. In the community-maintained awesome-cursor-skills repository, there is a Skill specifically leveraging this capability: parallel-code-review. It assigns the same diff to four read-only sub-Agents, each reviewing from one of the four perspectives, then the main Agent deduplicates and merges the results to output a priority-sorted review report. This article introduces its positioning, installation method, and complete workflow after verifying against the official SKILL.md.

What it is¶

parallel-code-review is an Agent Skill following the universal SKILL.md format, from the GitHub repository spencerpauly/awesome-cursor-skills, categorized as “Cursor-Native” — meaning it relies on Cursor’s unique Task parallel sub-Agent capability, and the same workflow cannot be exactly replicated in other tools like Codex CLI or Claude Code.

One-sentence positioning: Launch four parallel read-only explore sub-Agents, each guarding one review dimension to examine the same set of changed files, then merge them into a deduplicated, graded Code Review report.

The Skill metadata marks user-invocable: true, which means you can call it directly by name in a conversation without waiting for the Agent to match and trigger it automatically.

Core Features and Highlights¶

Four-Dimensional Parallel Review¶

Unlike “one Agent scanning the diff from start to finish”, parallel-code-review splits the work into four dedicated perspectives:

Four sub-Agents start simultaneously, each reading code only without write permissions — this is the prerequisite for safe parallel review.

Structured Merged Output¶

After receiving the four reports, the main Agent follows an official three-step synthesis process:

1. Deduplication: When the same issue is flagged by multiple dimensions, only keep one entry, using the highest severity level.
2. Sorting: First by Critical / High / Medium / Low, then by repair cost.
3. Summarization: Output an executive summary of no more than 5 items, plus a list of actionable entries (including file:line numbers and repair suggestions).

Optional Post-Review Fixes¶

After the review is complete, the main Agent can fix issues on its own, or launch non-read-only follow-up Tasks for the items you approve. The review and modification phases are deliberately separated to avoid parallel read-write conflicts.

Installation and Activation¶

The Skill is distributed as a single SKILL.md file, and installation essentially means placing it in the skills directory that the Agent can automatically discover.

Using in Cursor¶

According to the awesome-cursor-skills README and Cursor Skills documentation, the Skill file should be placed in:
- Project-level: <project root>/.cursor/skills/parallel-code-review/SKILL.md
- Or personal-level: ~/.cursor/skills/parallel-code-review/SKILL.md

Manual installation (most straightforward):

mkdir -p .cursor/skills/parallel-code-review
curl -o .cursor/skills/parallel-code-review/SKILL.md \
  https://raw.githubusercontent.com/spencerpauly/awesome-cursor-skills/main/resources/parallel-code-review/SKILL.md

Restart or open a new Agent conversation after saving, and Cursor will automatically detect the Skill.

CLI installation (if you have configured the npx skills toolchain):

npx skills add spencerpauly/awesome-cursor-skills --skill parallel-code-review

The specific target directory depends on the current version of the CLI; in a Cursor environment, it will usually write to the project’s .cursor/skills/ directory.

Using in Claude Code¶

The third-party directory Claude Skills Hub provides the installation command for Claude Code:

npx skills add spencerpauly/awesome-cursor-skills --skill parallel-code-review --agent claude-code

The Skill content is identical, but parallel-code-review’s workflow explicitly depends on Cursor’s Task tool. After installing it in Claude Code, whether you can fully execute the four-way parallel review depends on whether the environment provides an equivalent parallel read-only sub-Agent mechanism. Cursor is the official designed target platform.

Typical Usage Examples¶

After enabling the Skill, follow these four steps before merging large or high-risk PRs.

1. Define the Scope of Changes¶

First provide the reviewer with a clear list of files. The official recommendation:

git diff --name-only origin/main...HEAD

You can also directly paste the PR link, allowing the main Agent to extract the changed files from the branch diff.

2. Launch Four Parallel Sub-Agents in One Message¶

Key rule: Send four Task calls in the same message, each with subagent_type: "explore" and readonly: true. The official prompt template is as follows (replace <list> with the actual file list):

Security Review Prompt:

Read-only review: SECURITY

Changed files:
<list>

Focus: injection (SQL, shell, XSS), authZ/authN gaps, secrets in code, unsafe deserialization, path traversal, SSRF, IDOR, dependency CVEs mentioned in diff.

Output:
- Critical / High / Medium / Low findings
- File:line and short fix recommendation
- "No issues" if nothing material

The prompts for the three dimensions of Performance, Correctness, and Readability have the same structure, only differing in the Focus field — see the full original text at official SKILL.md.

You can also trigger it with natural language, for example:

Please perform a four-dimensional parallel review of the diff of the current branch relative to origin/main according to the parallel-code-review Skill.

The Agent will automatically apply the above workflow after reading the Skill.

3. Wait for the Synthesized Report¶

Once all four sub-Agents return results, the main Agent will perform deduplication, grading, and summarization. The expected output includes:
- An executive summary of no more than 5 items
- An actionable list with severity level, location, and repair suggestions

4. (Optional) Fix Issues One by One¶

After confirming the items to fix, ask the main Agent to modify the code directly, or launch targeted non-read-only Tasks for individual issues. The official recommendation: Only enter the modification phase after your approval to avoid the Agent from over-actively refactoring on its own.

Applicable Scenarios and Notes¶

When to Use It¶

The official When to use lists three typical scenarios:
- Large diffs or refactoring: A single linear review is easy to miss one type of problem.
- Security-sensitive changes: Authentication, payment, parsing untrusted input, etc.
- Performance-sensitive paths: Hot loops, N+1 queries, packaging entry points, etc.

For small changes of a few dozen lines, direct manual review or single-Agent review is often more cost-effective. The value of parallel-code-review is most obvious when “the scope of changes is large and there are multiple risk dimensions”.

Usage Restrictions (Official Notes)¶

1. Maintain read-only mode: Be sure to set readonly: true during the parallel phase to prevent multiple sub-Agents from writing files simultaneously.
2. Split ultra-large diffs: If changes span multiple directories, split them by directory, run a four-dimensional review for each directory, and do not cram unrelated megadiffs into a single pass.
3. Do not replace manual and compliance processes: The Skill clearly states that it is a supplement to human reviewers, and cannot replace compliance or security approval in regulated environments.
4. Cursor-exclusive capability: Task parallel sub-Agents are a core feature of Cursor Agent 2.0; other AI programming tools may load the same SKILL.md, but may not have an equivalent parallel execution environment.

Summary¶

parallel-code-review puts Cursor’s parallel Agent capability into the high-frequency scenario of Code Review: four read-only sub-Agents each guard a professional perspective, and the main Agent is responsible for deduplication and merging — equivalent to pulling a “security engineer + performance engineer + logic reviewer + readability reviewer” into the PR discussion at the same time, while the wall-clock time is close to a single review.

If you often face large PRs or worry about “reviewers losing track of details” when working on sensitive modules, it is worth adding this Skill to your project’s .cursor/skills/ directory and running a four-dimensional parallel review before merging.

Official Skill address: github.com/spencerpauly/awesome-cursor-skills/tree/main/resources/parallel-code-review