home / skills / everyinc / compound-engineering-plugin / resolve-pr-parallel

resolve-pr-parallel skill

safe

/plugins/compound-engineering/skills/resolve-pr-parallel

This skill resolves all PR comments in parallel by spawning dedicated agents for each thread, accelerating review feedback resolution.

npx playbooks add skill everyinc/compound-engineering-plugin --skill resolve-pr-parallel

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

Files (3)

SKILL.md

2.4 KB

---
name: resolve_pr_parallel
description: Resolve all PR comments using parallel processing. Use when addressing PR review feedback, resolving review threads, or batch-fixing PR comments.
argument-hint: "[optional: PR number or current PR]"
disable-model-invocation: true
allowed-tools: Bash(gh *), Bash(git *), Read
---

# Resolve PR Comments in Parallel

Resolve all unresolved PR review comments by spawning parallel agents for each thread.

## Context Detection

Claude Code automatically detects git context:
- Current branch and associated PR
- All PR comments and review threads
- Works with any PR by specifying the number

## Workflow

### 1. Analyze

Fetch unresolved review threads using the GraphQL script:

```bash
bash ${CLAUDE_PLUGIN_ROOT}/skills/resolve-pr-parallel/scripts/get-pr-comments PR_NUMBER
```

This returns only **unresolved, non-outdated** threads with file paths, line numbers, and comment bodies.

If the script fails, fall back to:
```bash
gh pr view PR_NUMBER --json reviews,comments
gh api repos/{owner}/{repo}/pulls/PR_NUMBER/comments
```

### 2. Plan

Create a TodoWrite list of all unresolved items grouped by type:
- Code changes requested
- Questions to answer
- Style/convention fixes
- Test additions needed

### 3. Implement (PARALLEL)

Spawn a `pr-comment-resolver` agent for each unresolved item in parallel.

If there are 3 comments, spawn 3 agents:

1. Task pr-comment-resolver(comment1)
2. Task pr-comment-resolver(comment2)
3. Task pr-comment-resolver(comment3)

Always run all in parallel subagents/Tasks for each Todo item.

### 4. Commit & Resolve

- Commit changes with a clear message referencing the PR feedback
- Resolve each thread programmatically:

```bash
bash ${CLAUDE_PLUGIN_ROOT}/skills/resolve-pr-parallel/scripts/resolve-pr-thread THREAD_ID
```

- Push to remote

### 5. Verify

Re-fetch comments to confirm all threads are resolved:

```bash
bash ${CLAUDE_PLUGIN_ROOT}/skills/resolve-pr-parallel/scripts/get-pr-comments PR_NUMBER
```

Should return an empty array `[]`. If threads remain, repeat from step 1.

## Scripts

- [scripts/get-pr-comments](scripts/get-pr-comments) - GraphQL query for unresolved review threads
- [scripts/resolve-pr-thread](scripts/resolve-pr-thread) - GraphQL mutation to resolve a thread by ID

## Success Criteria

- All unresolved review threads addressed
- Changes committed and pushed
- Threads resolved via GraphQL (marked as resolved on GitHub)
- Empty result from get-pr-comments on verify

Overview

This skill automates resolving all unresolved pull request review comments by spawning parallel agents for each thread. It detects the PR context, batches unresolved review threads, runs per-thread resolvers in parallel, commits fixes, and programmatically marks threads resolved. The goal is fast, repeatable handling of review feedback with verification after completion.

How this skill works

The skill fetches unresolved, non-outdated review threads for a given PR using a GraphQL query or GitHub CLI fallback. It groups items into a Todo list by type, then spawns a pr-comment-resolver agent for each thread and runs them in parallel. After applying fixes, it commits and pushes changes and calls a GraphQL mutation to mark each thread resolved, then re-fetches threads to verify completion.

When to use it

You need to address many PR review comments quickly across multiple files.
A PR has several independent review threads that can be fixed concurrently.
You want reproducible, programmatic resolution of review feedback.
Batch-fixing stylistic or test-related comments across a codebase.
Verifying that all review threads are resolved after changes.

Best practices

Run the get-pr-comments script first to list unresolved, non-outdated threads.
Group threads by type (code change, question, style, tests) to assign appropriate resolver logic.
Keep resolver tasks independent to avoid conflicts during parallel commits.
Use clear commit messages referencing the PR and specific review feedback.
Re-run verification and repeat if any thread remains unresolved.

Example use cases

A large PR with dozens of small style and test-change comments that can be fixed in parallel.
Multiple reviewers left independent suggestions across files; run per-thread agents to implement each suggestion concurrently.
Automated bulk resolution for CI-identified test updates requested during review.
Scripted run as part of a maintenance workflow to clear long-standing unresolved threads.

FAQ

What happens if the get-pr-comments script fails?

The skill falls back to GitHub CLI queries (gh pr view and gh api) to retrieve review comments and threads.

How are threads marked resolved?

After changes are committed and pushed, the resolve-pr-thread script runs a GraphQL mutation to mark each thread resolved, then verification confirms an empty result list.