Menu
Triage and resolve review comments on a GitHub PR. Reads all comments, assesses each one, and presents a resolution table. The user can then approve, modify, or reject resolutions, and the agent applies the chosen changes.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
| name | reconcile-review |
| description | Triage and resolve review comments on a GitHub PR. Reads all comments, assesses each one, and presents a resolution table. The user can then approve, modify, or reject resolutions, and the agent applies the chosen changes. |
After one or more agents (or humans) have reviewed a PR, this skill triages all the review comments and suggests resolutions. It works in two phases:
gh CLI must be installed and authenticated (gh auth status).A GitHub PR number (e.g. 42) or URL (e.g. https://github.com/owner/repo/pull/42).
# PR metadata
gh pr view <number> --json title,body,baseRefName,headRefName,author,state
# All review comments (inline + replies)
gh api "repos/$(gh repo view --json nameWithOwner -q .nameWithOwner)/pulls/<number>/comments" --paginate
# General PR comments
gh pr view <number> --comments --json comments
# The diff (for context when assessing each comment)
gh pr diff <number>
gh pr checkout <number>
This is needed so you can read the full files (not just the diff) when assessing comments and making changes later. All changes will be committed directly to this branch — this is iterative feedback on the PR, not a separate review branch.
Group comments by thread (top-level review comment + its replies). For each thread:
Output a markdown table in the terminal. Each row represents one comment thread:
| # | File | Line | Author | Concern | Severity | Suggested Resolution |
|---|------|------|--------|---------|----------|---------------------|
| 1 | src/foo.ts | 42 | AGENT claude | Null check missing | 🔴 bug | Accept: add guard clause |
| 2 | src/bar.ts | 15 | AGENT gpt-5 | Use const instead of let | 🟢 style | Accept: change to const |
| 3 | src/baz.ts | 8 | human-reviewer | Extract this to a helper | 🟡 design | Alternative: extract but keep in same file |
| 4 | src/qux.ts | 100 | AGENT claude | Add error handling | 🔴 bug | Accept: wrap in try/catch |
Severity legend:
After the table, print a summary:
For threads where agents disagree, highlight them and explain both sides:
### Disagreements needing human judgment
**Thread #5 — src/foo.ts:42**
- **AGENT claude:** Extract this logic to a separate function.
- **AGENT gpt-5 (reply):** Disagree — the logic is only 3 lines and extracting it adds indirection.
- **Suggested resolution:** ⚪ subjective — your call. If this logic is reused elsewhere, extract it.
After presenting the table, ask the user how to proceed. They can say:
For each accepted resolution, edit the file(s) to implement the fix. Follow the repo's conventions (code style, commit message format, etc.).
After making changes, reply to each resolved thread explaining what was done:
gh api "repos/$(gh repo view --json nameWithOwner -q .nameWithOwner)/pulls/<number>/comments" \
-f body="Resolved in [commit hash]: <brief description of the change>." \
-f in_reply_to="<comment-database-id>"
GitHub does not expose a REST API to resolve comment threads. The "resolve conversation" button in the UI calls a GraphQL mutation. To resolve threads programmatically, you need the thread's GraphQL node ID.
Step 1: Find the thread node ID for each comment
First, get the review thread ID from a comment's node_id using a GraphQL query:
# For a single comment, look up its pull request review thread
gh api graphql -f query='
query($commentId: ID!) {
node(id: $commentId) {
... on PullRequestReviewComment {
pullRequestReview {
comments(first: 50) {
nodes {
id
body
}
}
}
}
}
}
' -f commentId="<comment-node-id>"
Alternatively, list all review threads on the PR directly:
gh api graphql -f query='
query($owner: String!, $repo: String!, $pr: Int!) {
repository(owner: $owner, name: $repo) {
pullRequest(number: $pr) {
reviewThreads(first: 100) {
nodes {
id
isResolved
comments(first: 10) {
nodes {
body
author { login }
}
}
}
}
}
}
}
' -f owner="<owner>" -f repo="<repo>" -f pr=<number>
Match threads to your comment table by comparing the comment body text.
Step 2: Resolve each thread
gh api graphql -f query='
mutation($threadId: ID!) {
resolveReviewThread(input: {threadId: $threadId}) {
thread { isResolved }
}
}
' -f threadId="<thread-node-id>"
Simpler alternative: if you push a commit that modifies the exact line a comment is anchored to, GitHub auto-resolves that thread. This is often easier than the GraphQL approach — just make sure your code changes touch the commented lines.
After all changes are made, commit with a descriptive message referencing the PR:
git add -A
git commit -m "Address review feedback for PR #<number>
- Fix null check in src/foo.ts (thread #1)
- Change let to const in src/bar.ts (thread #2)
- ..."
git push
Report what was done: