Agent skill

Review Pending PR Reviews

by nrwl in nrwl/nx

Review, grill, edit, and post pending PR review drafts saved by /review-pr (or its batch/cron runners).

MITAuto-check passedDevelopment

Install Review Pending PR Reviews

skills CLI
$ npx skills add nrwl/nx --skill review-pending-pr-reviews -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install nrwl/nx review-pending-pr-reviews --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/nrwl/nx.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/review-pending-pr-reviews .claude/skills/review-pending-pr-reviews && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
review-pending-pr-reviews
GitHub stars
29k
Token cost
~3.9k tokens
SKILL.md length
1,806 words
Files
1
Skills in repo
21
Repo updated
First seen
Licence
MIT

At a glance

Review, grill, edit, and post pending PR review drafts saved by /review-pr (or its batch/cron runners).

  • Works in 6 steps: Find pending drafts → Check for drift before presenting → Grill the findings before offering to post → …
  • The user says post my pending reviews
  • SKILL.md covers Configuration, 1. Find pending drafts, 2. Check for drift before… and 3. Grill the findings before…, plus 5 more sections
  • Calls gh and git

What it does

Review Pending PR Reviews is an agent skill from nrwl/nx. Review, grill, edit, and post pending PR review drafts saved by /review-pr (or its batch/cron runners). Lists drafts that have not yet been posted, walks the maintainer through each finding, then posts, closes, or discards. Use when the user says "post my pending reviews", "what reviews are waiting", "go through the review outbox", or invokes /review-pending-pr-reviews.

Its SKILL.md is about 3.9k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Pull requests. The repository describes itself as: The Monorepo Platform that amplifies both developers and AI agents. Nx optimizes your builds, scales your CI, and fixes failed PRs automatically. Ship in half the time. The licence is MIT.

When your agent uses it

  • The user says post my pending reviews
  • What reviews are waiting
  • Go through the review outbox
  • Invokes /review-pending-pr-reviews

Example prompts

  • “post my pending reviews”
  • “what reviews are waiting”
  • “go through the review outbox”
  • “/review-pending-pr-reviews”

Requirements

  • Pre-approved tools (allowed-tools): Bash(gh pr review *), Bash(gh pr view *), Bash(gh pr comment *), Bash(gh pr close *), Bash(ls ~/.nx-pr-reviews*), Bash(ls $TRIAGE_DIR*), Bash(git -C ~/.nx-pr-reviews *), Bash(git -C $TRIAGE_DIR *), Bash(open *), Bash(cat > /tmp/gh-pr-review*), Bash(cat > /tmp/gh-pr-close*), Read, Edit(~/.nx-pr-reviews/*), Write(~/.nx-pr-reviews/*), Write(/tmp/gh-pr-review*), Write(/tmp/gh-pr-close*), Grep, Glob, Skill

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Find pending drafts
  2. Check for drift before presenting
  3. Grill the findings before offering to post
  4. Present for review
  5. Actions
  6. Summary

What it can do on your machine

Read from SKILL.md and the folder at commit 200edc8. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Bash(gh pr review *)
    • Bash(gh pr view *)
    • Bash(gh pr comment *)
    • Bash(gh pr close *)
    • Bash(ls ~/.nx-pr-reviews*)
    • Bash(ls $TRIAGE_DIR*)
    • Bash(git -C ~/.nx-pr-reviews *)
    • Bash(git -C $TRIAGE_DIR *)
    • Bash(open *)
    • Bash(cat > /tmp/gh-pr-review*)

    …and 9 more on the same allowed-tools line.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • gh
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use gh and git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Review Pending PR Reviews loads about 3.9k tokens when it runs. Until then it costs about 100 tokens; SKILL.md has 1,806 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~100
When it runs · the whole SKILL.md, loaded when a task matches
~3.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from nrwl/nx at commit 200edc8, republished under its MIT licence (© nrwl). 1,806 words, ~3,916 tokens.

Download SKILL.mdSave it as .claude/skills/review-pending-pr-reviews/SKILL.md (or your agent's skills folder).
name
review-pending-pr-reviews
description
Review, grill, edit, and post pending PR review drafts saved by /review-pr (or its batch/cron runners). Lists drafts that have not yet been posted, walks the maintainer through each finding, then posts, closes, or discards. Use when the user says "post my pending reviews", "what reviews are waiting", "go through the review outbox", or invokes /review-pending-pr-reviews.
allowed-tools
Bash(gh pr review *), Bash(gh pr view *), Bash(gh pr comment *), Bash(gh pr close *), Bash(ls ~/.nx-pr-reviews*), Bash(ls $TRIAGE_DIR*), Bash(git -C ~/.nx-pr-reviews *), Bash(git -C $TRIAGE_DIR *), Bash(open *), Bash(cat > /tmp/gh-pr-review*), Bash(cat > /tmp/gh-pr-close*), Read, Edit(~/.nx-pr-reviews/*), Write(~/.nx-pr-reviews/*), Write(/tmp/gh-pr-review*), Write(/tmp/gh-pr-close*), Grep, Glob, Skill

Review Pending PR Reviews

The outbox for /review-pr. Nothing reaches GitHub until the maintainer approves it here.

This skill is where a human is guaranteed to be present. /review-pr runs headless most of the time — review-prs drives it across tmux panes, and a cron runs it overnight — so its own Step 8.5 grill is skipped on the majority of reviews. This skill is therefore the real evaluation gate: it grills the findings first (Step 3) and only then offers to post.

Configuration

  • TRIAGE_DIR — where drafts live. Default: ~/.nx-pr-reviews, matching /review-pr's own default. Override with the same value if the maintainer has repointed it.

Do not read ~/.claude/triage/prs/. That is the store of the retired review-pr-deep pipeline. Its drafts predate the current review criteria (pre-PIPELINE_VERSION tiers), so posting one would publish findings the current calibrations would have dropped. If the maintainer wants those, they must be re-reviewed by /review-pr, not posted from the old store.

Each draft has YAML frontmatter (pr, verdict, head_sha, pipeline_version, posted_at, ...) and a ## Review draft section holding the body that will be posted.

A draft is pending iff posted_at: is empty. Once posted or discarded, posted_at is set and the file is kept as the historical record — it feeds /review-pr's re-review dedup, so never delete one.

1. Find pending drafts

bash
ls $TRIAGE_DIR

Read each file's frontmatter; pending iff posted_at: is empty. Sort oldest-first by last_reviewed_at so the longest-waiting review goes first.

For each, display: PR number and title, verdict, attempt, last_reviewed_at, URL, and the first 3 lines of ## Review draft.

2. Check for drift before presenting

bash
gh pr view PR_NUMBER --repo nrwl/nx --json headRefOid,state,isDraft -q '{head: .headRefOid, state: .state, isDraft: .isDraft}'

IMPORTANT: every Bash command must be a single, standalone command. Do not chain with &&, ||, or ;, and do not append redirects or backgrounding — these break permission matching. Use separate Bash calls.

Flag before the action prompt:

  • Stale — current head differs from frontmatter head_sha. Recommend skip and re-running /review-pr PR_NUMBER.
  • Closed/merged — state != OPEN. Recommend discard.
  • Draft PR — isDraft == true. The maintainer may not want to post yet.
  • Old pipeline — pipeline_version is missing or below the current constant for the draft's writer. The reviewer key names that writer: absent means Claude's /review-pr, whose constant is 9; codex means the Codex review-pr skill, which keeps its own. The draft was produced by weaker criteria. Recommend skip + re-review rather than posting.

3. Grill the findings before offering to post

Do this before showing the action prompt, and only for drafts that survived Step 2. Skip it entirely when the draft's frontmatter shows a ## Grill section already — /review-pr Step 8.5 grilled it interactively and re-grilling wastes the maintainer's time. Say so and go to Step 4.

Brief the maintainer before the first question — it is not optional, and it matters more here than in /review-pr. That skill's grill follows a review the maintainer just watched run; this one opens on a draft a cron produced days ago, about a PR they have likely never opened. Asking "does this hold?" cold makes the question unanswerable, and silence is defined below as stop — so a cold grill yields no evaluation at all, on the very drafts this skill calls the real gate.

text
PR #<N>: <title> — <author>, <age>, reviewed <date> at <head_sha>
<one or two sentences: what the PR actually changes, in plain terms>

Draft verdict: <verdict> — <what drives it>

Critical (<n>) — these gate the verdict
  1. <file:line> — <the claim in one clause>

Important (<n>)
  2. <file:line> — <the claim in one clause>

Pre-existing (<n>), Suggestions (<n>) — not grilled, listed so you know they exist

One line per finding. The detail arrives with the question that needs it, and every question restates its own finding inline — the claim, its NET-NEW line, its TRIGGER line, and one sentence on what specifically is uncertain about it. Never refer to a finding by number alone, and never make the maintainer open the draft to answer.

Invoke /grill-me, scoped to findings rather than to a plan. It works in rounds over a frontier — round 1 is every Critical finding, round 2 is Important plus whatever round 1 unblocked, round 3 is the consequences. Skip Suggestions; they never move the verdict.

For each finding, state your recommendation up front, then ask the three questions the tiers turn on:

  1. Does it hold? Is the defect real as described, not merely plausible?
  2. Is it this PR's? Does the NET-NEW line's base evidence support it, or is it pre-existing / widens?
  3. Is the tier right? Critical = something the PR produces is wrong now. Important = wrong later, or left unguarded.

Skip any question the draft already answers. The goal is resolving genuine uncertainty, not making the maintainer re-read their own review.

Never answer your own questions. If a question goes unanswered, stop and leave the draft exactly as it is. A grill that supplies the maintainer's answers launders agent output into apparent human review — which is precisely what this skill exists to prevent.

The sandbox is long gone by now. Unlike /review-pr Step 8.5, this skill cannot re-read --ref base to settle a factual dispute — the checkout was destroyed when that review finished. If a round turns on a fact rather than a judgment, say so and recommend skip + a fresh /review-pr run rather than guessing. Do not drop a finding on an unverified hunch.

Apply each round's answers before asking the next — drop, re-tier, or keep — then recompute the verdict with /review-pr Step 7's rule: only Critical blocks, at any quantity. Dropping the last Critical moves a PR from needs-changes to lgtm.

When the frontier is empty, brief again — the same inventory the grill opened with, re-rendered against the post-grill draft, showing what moved rather than only where it landed:

text
Grill complete — PR #<N>

Verdict: <before> → <after>          (or "unchanged: <verdict>")

Dropped (<n>)
  <file:line> — <claim, one clause> — <the maintainer's reason, in their words>
Re-tiered (<n>)
  <file:line> — <claim, one clause> — critical→important: <reason>
Kept (<n>)
  <file:line> — <claim, one clause>

The maintainer answered one round at a time, against one finding at a time; nobody holds the cumulative effect of six answers in their head. Ask whether it matches what they decided, and fix it here if not — this is the last point before Step 4 offers to post it to a public PR.

This is a confirmation, not another round. Do not reopen a settled finding or raise a concern the grill did not. If the maintainer's reply opens something genuinely new, grill it as a new round.

Record every drop and re-tier under ## Grill in the draft file, one line each:

markdown
## Grill

- <file:line> — <finding, one clause> — DROPPED: <maintainer's reason, in their words>
- <file:line> — <finding, one clause> — RETIERED critical→important: <reason>

That section is the tuning data for /review-pr's criteria. A reason that recurs across PRs is a missing calibration — add it to that skill's "Nx-specific calibration" list instead of re-litigating it every review.

4. Present for review

Open the PR alongside the draft:

bash
gh pr view PR_NUMBER --repo nrwl/nx --web
## Pending PR Review: #PR_NUMBER — TITLE
**Verdict:** needs-changes          ← post-grill verdict; note it if the grill changed it
**Attempt:** 1
**HEAD:** 438fa5a1 (stored) — 438fa5a1 (current)  ← or ⚠ DRIFT if different
**State:** OPEN (draft)
**Reviewed:** 2026-04-24

### Summary
<First Summary paragraph from the Review draft — 2-5 lines.>

### Counts
Critical: N · Important: N · Suggestions: N        (after the grill)
Dropped in grill: N

---
<first ~15 lines of the Review draft>
... (full body is in $TRIAGE_DIR/PR_NUMBER.md)
---

Actions: [post] [edit] [skip] [discard] [open-file]

If verdict: superseded — posting a review on a dead PR is noise. The draft already names the superseding PR in its ### Close-without-merge check section.

Actions: [close-with-pointer] [edit] [skip] [discard] [open-file]

If verdict: unnecessary — the PR shouldn't merge but there's no specific replacement to point at (no real bug / abandoned / duplicate of rejected work).

Actions: [close-with-reason] [edit] [skip] [discard] [open-file]

Wait for the maintainer to choose an action for each draft.

Show full SKILL.md (748 more words)Show less

5. Actions

  • post — Post to GitHub. Extract ONLY the ## Review draft body (from the first ### under it through the last line before ## Prior reviews); never the frontmatter, ## Grill, or trailing sections.

    Verdict → gh pr review flag:

    • lgtm / approve → --approve
    • needs-changes → --request-changes
    • blocked / comment / anything else → --comment
    • superseded / unnecessary do NOT use post — see the close flows below.

    Always use --body-file to avoid shell quoting issues:

    bash
    cat > /tmp/gh-pr-review-PR_NUMBER.md << 'REVIEW_EOF'
    REVIEW_BODY
    REVIEW_EOF
    bash
    gh pr review PR_NUMBER --repo nrwl/nx --request-changes --body-file /tmp/gh-pr-review-PR_NUMBER.md

    Then update frontmatter with Edit: posted_at: <ISO-8601 local timestamp>, posted_url: <URL>. Append to ## Posted: - attempt N posted YYYY-MM-DD as <verdict> → <posted_url>. Commit (see below). Never delete the file.

  • close-with-pointer (only for superseded) — Close with a short comment pointing at the superseding work. Do NOT post a review.

    1. Extract the superseding PR number(s) from ### Close-without-merge check. Prompt if unclear.
    2. Draft a short comment, let the maintainer edit before posting:
      Thanks for the PR! This has been superseded by #<SUPERSEDING_PR>, which <one-line reason>. Closing this one — appreciate the work.
    3. gh pr comment with --body-file.
    4. gh pr close <NUMBER> --repo nrwl/nx.
    5. Frontmatter: posted_at: <timestamp> (closed as superseded), posted_url: <comment URL>.
    6. ## Posted: - attempt N closed-as-superseded YYYY-MM-DD → <comment_url>. Commit.
  • close-with-reason (only for unnecessary) — Close with a short comment explaining why, with no specific replacement. Do NOT post a review.

    1. Extract the reason and evidence from ### Close-without-merge check (which signals fired, linked issue with no thumbs-up, last activity date, prior closed PR number).

    2. Draft a short, kind comment tailored to the reason. Always show it for edit before posting — these need a human touch. Templates by primary reason:

      • Bug not reproduced:
        Thanks for the PR! Before reviewing in depth, we tried to reproduce the issue from #<ISSUE> on master and weren't able to — the behavior described doesn't appear to be a bug we can confirm. Could you share a minimal repro repo so we can verify there's something to fix here? In the meantime I'm closing this; happy to reopen once we can confirm the underlying issue. Appreciate the contribution.
      • Abandoned (stale + conflicted + unanswered):
        Thanks for the PR! This branch has been inactive for <N> months and now has merge conflicts plus open reviewer questions. Closing for now to keep the queue tidy — please feel free to reopen with a rebase and answers to the prior review when you're able. Appreciate the work.
      • Duplicate of recently-closed PR:
        Thanks for the PR! This looks similar in scope to #<PRIOR_CLOSED_PR>, which we closed previously — the same concerns likely apply here. Closing to avoid re-litigating; if you think the situation has changed, the best next step is a comment on #<PRIOR_CLOSED_PR> or a fresh issue laying out the new context. Appreciate the contribution.
      • Other / mixed: one paragraph pulling the strongest signal(s). Always thank the contributor.
    3. Stage via --body-file:

      bash
      cat > /tmp/gh-pr-close-PR_NUMBER.md << 'CLOSE_EOF'
      <comment body>
      CLOSE_EOF
    4. gh pr comment <NUMBER> --repo nrwl/nx --body-file /tmp/gh-pr-close-PR_NUMBER.md

    5. gh pr close <NUMBER> --repo nrwl/nx

    6. Frontmatter: posted_at: <timestamp> (closed as unnecessary), posted_url: <comment URL>.

    7. ## Posted: - attempt N closed-as-unnecessary YYYY-MM-DD → <comment_url>. Commit.

    Be cautious. Closing without a pointer feels worse to a contributor than "superseded by". If the maintainer is unsure, prefer skip, or fall back to post with --comment so the contributor can respond before the PR is closed.

  • edit — Modify the ## Review draft body in place via Edit, then show it again for approval.

  • skip — Leave it pending. Move on. Right answer for stale drafts and old pipeline_version.

  • discard — Set posted_at: <timestamp> (discarded). Append to ## Posted: - attempt N discarded YYYY-MM-DD (<reason>). Never delete the file. Commit.

  • open-file — open $TRIAGE_DIR/PR_NUMBER.md, then re-prompt for an action.

  • post all — Post every remaining pending draft, mapping each verdict to its flag. Grill each one first (Step 3) unless it already carries a ## Grill section — post all is a shortcut past the action prompt, not past the evaluation. Update each file, commit once, show a summary. Skip superseded and unnecessary drafts (they need per-PR comments) and list them at the end.

Commit after changes

Only when TRIAGE_DIR is actually a git repo and the file is not ignored — same guard as /review-pr Step 10. The default ~/.nx-pr-reviews is typically not a repo, in which case the file on disk is the record and this step is a silent no-op:

bash
git -C $TRIAGE_DIR rev-parse --is-inside-work-tree
bash
git -C $TRIAGE_DIR add PR_NUMBER.md
bash
git -C $TRIAGE_DIR commit -m "triage: posted review for PR #PR_NUMBER"

Use discarded for discards; triage: update pending PR reviews (posted/discarded) for post all.

6. Summary

## PR Review Queue Complete
- Posted: X reviews
- Skipped: X drafts (still pending)
- Discarded: X drafts
- Findings dropped in grill: X across Y drafts
- Remaining: X drafts in $TRIAGE_DIR

Empty queue

If every file has a non-empty posted_at: "No pending PR reviews to post. The outbox is empty."

© nrwl, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/review-pending-pr-reviews of nrwl/nx.

Open the folder on GitHubat commit 200edc8

Compare with similar skills

Review Pending PR Reviews next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Review Pending PR Reviews compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Review Pending PR Reviews this skillnrwl/nx29k—~3.9kAutomated safety check: PassMIT
Finishing a Development Branchobra/superpowers297k5 repos~1.9kAutomated safety check: PassMIT
PR Babysitteropeninterpreter/openinterpreter69k3 repos~4.2kAutomated safety check: PassApache-2.0
Check PRonyx-dot-app/onyx32k2 repos~2.3kAutomated safety check: PassMIT
PR Design DocOpenHands/OpenHands91k—~2.4kAutomated safety check: PassMIT
WooCommerce Code Reviewwoocommerce/woocommerce11k3 repos~1.1kAutomated safety check: PassCustom licence

Similar skills

  • Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.

    297k GitHub starsUsed in 5 repos~1.9k tokens
    DevelopmentAuto-check passed
  • PR Babysitter

    openinterpreter/openinterpreter

    Watches an open GitHub pull request until it merges, handling review comments, diagnosing CI failures and retrying flaky checks along the way.

    69k GitHub starsUsed in 3 repos~4.2k tokens
    DevelopmentAuto-check passed
  • Check PR

    onyx-dot-app/onyx

    Checks a GitHub, GitLab, or Perforce (p4) pull request (or merge request, or shelved changelist) for unresolved review comments, failing status checks, and incomplete PR descriptions.

    32k GitHub starsUsed in 2 repos~2.3k tokens
    DevelopmentAuto-check passed
  • PR Design Doc

    OpenHands/OpenHands

    For a non-trivial pull request, write a self-contained HTML design doc under the temporary .pr/ directory and link a visibility-appropriate preview in the PR description, so maintainers grasp the…

    91k GitHub stars~2.4k tokensUpdated today
    DevelopmentAuto-check passed
  • WooCommerce Code Review

    woocommerce/woocommerce

    Reviews WooCommerce code changes against the project's standards, flagging backend PHP architecture, naming, documentation, data integrity and testing violations.

    11k GitHub starsUsed in 3 repos~1.1k tokens
    DevelopmentAuto-check passed
  • Record PR Demo

    payloadcms/payload

    A skill your agent uses when a Payload pull request needs a concise visual walkthrough for reviewers.

    45k GitHub stars~1k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Monitor CI

    nrwl/nx

    Monitor Nx Cloud CI pipeline and handle self-healing fixes. An agent skill from nrwl/nx.

    29k GitHub starsUsed in 6 repos~4.7k tokens
    Auto-check passed
  • Nx Import

    nrwl/nx

    Import, merge, or combine repositories into an Nx workspace using nx import.

    29k GitHub starsUsed in 6 repos~3.5k tokens
    Auto-check passed
  • Run Nx generators with prioritization for workspace-plugin generators.

    29k GitHub starsUsed in 2 repos~592 tokens
    Auto-check: notes
  • Author or scope a first-party Nx migration. An agent skill from nrwl/nx.

    29k GitHub stars~12k tokensUpdated yesterday
    Auto-check: notes
  • Generate code using nx generators. An agent skill from nrwl/nx.

    29k GitHub starsUsed in 1 repo~2.2k tokens
    Auto-check passed
  • Check modified Nx documentation pages against the astro-docs style guide.

    29k GitHub stars~1.3k tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Review Pending PR Reviews

What does Review Pending PR Reviews do?

Review, grill, edit, and post pending PR review drafts saved by /review-pr (or its batch/cron runners). Review Pending PR Reviews is an agent skill from nrwl/nx. Review, grill, edit, and post pending PR review drafts saved by /review-pr (or its batch/cron runners).

When should I use Review Pending PR Reviews?

Review Pending PR Reviews fits situations like: the user says post my pending reviews; what reviews are waiting; go through the review outbox; invokes /review-pending-pr-reviews.

How do I install Review Pending PR Reviews in Claude Code?

Run `npx skills add nrwl/nx --skill review-pending-pr-reviews -a claude-code`. Or copy the skill folder (.claude/skills/review-pending-pr-reviews in nrwl/nx) into .claude/skills/review-pending-pr-reviews in your project. Claude Code loads it when a task matches its description.

How do I install Review Pending PR Reviews in Codex?

Run `npx skills add nrwl/nx --skill review-pending-pr-reviews -a codex`. Or copy the skill folder (.claude/skills/review-pending-pr-reviews in nrwl/nx) into .agents/skills/review-pending-pr-reviews in your project. Codex loads it when a task matches its description.

Can I use Review Pending PR Reviews in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add nrwl/nx --skill review-pending-pr-reviews -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/review-pending-pr-reviews, .gemini/skills/review-pending-pr-reviews, .github/skills/review-pending-pr-reviews and .opencode/skills/review-pending-pr-reviews in your project.

What does Review Pending PR Reviews need to run?

Going by SKILL.md and its folder, Review Pending PR Reviews needs the command-line tools its instructions call (gh and git). Its frontmatter pre-approves these tools: Bash(gh pr review *), Bash(gh pr view *), Bash(gh pr comment *), Bash(gh pr close *), Bash(ls ~/.nx-pr-reviews*), Bash(ls $TRIAGE_DIR*), Bash(git -C ~/.nx-pr-reviews *), Bash(git -C $TRIAGE_DIR *), Bash(open *), Bash(cat > /tmp/gh-pr-review*), Bash(cat > /tmp/gh-pr-close*), Read, Edit(~/.nx-pr-reviews/*), Write(~/.nx-pr-reviews/*), Write(/tmp/gh-pr-review*), Write(/tmp/gh-pr-close*), Grep, Glob, Skill.

Does Review Pending PR Reviews access the network?

SKILL.md contains no URLs. Its commands use gh and git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Review Pending PR Reviews safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Review Pending PR Reviews use?

Review Pending PR Reviews is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Review Pending PR Reviews use?

About 3.9k tokens (SKILL.md is roughly 16k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Review Pending PR Reviews?

Skills that share tags, products or a category with Review Pending PR Reviews: Finishing a Development Branch (obra/superpowers, 297k stars), PR Babysitter (openinterpreter/openinterpreter, 69k stars), Check PR (onyx-dot-app/onyx, 32k stars) and PR Design Doc (OpenHands/OpenHands, 91k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Review Pending PR Reviews?

nrwl (a GitHub organization) maintains it in nrwl/nx, which has 29,401 GitHub stars. The repository holds 21 skills in this directory. The repository was last updated on October 10, 2026.

Source: nrwl/nx on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.