Github Review Iteration

Name: Github Review Iteration
Author: prisma

prisma/prisma-next

2 installs
418 repo stars
Updated August 3, 2026
prisma/prisma-next

github-review-iteration skill documents Orchestrates a GitHub PR review loop by delegating triage and implementation to dedicated sub-agents, then repeating until actionable review items are cleared.

About

github-review-iteration skill documents Orchestrates a GitHub PR review loop by delegating triage and implementation to dedicated sub-agents, then repeating until actionable review items are cleared. Use when the user says “address PR review”, “triage review comments”, or “iterate until review is clean”.. name: github-review-iteration description: Orchestrates a GitHub PR review loop by delegating triage and implementation to dedicated sub-agents, then repeating until actionable review items are cleared. Use when the user says “address PR review”, “triage review comments”, or “iterate until review is clean”.

Orchestrates a GitHub PR review loop by delegating triage and implementation to dedicated sub-agents, then repeating unt
Platform-specific setup patterns for github-review-iteration.
Evidence-backed steps from upstream SKILL.md.
When-to-use criteria for github-review-iteration versus alternatives.

Github Review Iteration by the numbers

2 all-time installs (skills.sh)
Ranked #1,839 of 2,715 Automation & Workflows skills by installs in the Skillselion catalog
Data as of Aug 4, 2026 (Skillselion catalog sync)

At a glance

github-review-iteration capabilities & compatibility

Capabilities: github review iteration quick start · github review iteration when to use guidance · github review iteration integration patterns

From the docs

What github-review-iteration says it does

argument-hint: "[triage|implement|iterate] [pr-url] [output-dir]"

SKILL.md

disable-model-invocation: true

SKILL.md

npx skills add https://github.com/prisma/prisma-next --skill github-review-iteration

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/prisma/prisma-next/github-review-iteration.svg)](https://skillselion.com/skills/prisma/prisma-next/github-review-iteration)

Installs	2
repo stars	★ 418
Last updated	August 3, 2026
Repository	prisma/prisma-next ↗

How do I use github-review-iteration correctly?

Orchestrates a GitHub PR review loop by delegating triage and implementation to dedicated sub-agents, then repeating until actionable review items are cleared. Use when the user says “address PR revie

Who is it for?

Teams implementing github-review-iteration workflows from the catalog.

Skip if: Skip when requirements clearly match a different specialized stack.

When should I use this skill?

User asks about github-review-iteration, orchestrates a github pr review loop by delegating triage and implementation to dedicated .

What you get

Working github-review-iteration setup with validated configuration and next steps.

Files

SKILL.mdMarkdownGitHub ↗

GitHub Review Iteration

Run an iterative PR review loop: fetch state → render/summarize → triage actions → implement (code + Done + resolve) → re-fetch until the PR has no remaining actionable items.

This skill is an orchestrator. It delegates:

triage to ../review-triage-phase/agents/review-triager.md
implementation to ../review-implement-phase/agents/review-implementer.md

The orchestrator owns sequencing, handoff, and loop control. It does not perform triage or implementation directly when delegation is available.

Locating sibling skills and scripts

This skill depends on three sibling skills that live in the same parent directory:

../review-fetch-phase/ — fetches and renders PR review state
../review-triage-phase/ — triages review threads into an action plan
../review-implement-phase/ — implements triaged actions and resolves threads

All script paths in this document are relative to this skill's directory. Use ../ to reach sibling skills. Do not search the workspace/repo for these files — they are part of the skills installation, not the project being reviewed.

Usage

This skill supports subcommands:

triage: fetch + triage into structured actions
implement: execute the triaged actions and update status
iterate: loop triage → implement until clear (default)

/github-review-iteration iterate <PR_URL> [output-dir]

When output-dir is omitted, use the standard layout: wip/reviews/<owner>_<repo>_pr-<number>/ (derived from PR URL).

Example:

/github-review-iteration iterate https://github.com/OWNER/REPO/pull/123

Files written (deterministic layout)

Store artifacts under:

wip/reviews/<owner>_<repo>_pr-<number>/

Canonical artifacts:

review-state.json (canonical v2)
review-actions.json (canonical v2)

Derived artifacts:

review-state.md
summary.txt (or JSON summary)
review-actions.md
apply-log.json (optional)

When you need a thin wrapper for path setup + standard script calls, run:

node ./scripts/review-iterate.mjs --pr <PR_URL>

For phase-specific execution without full orchestration, use:

/review-fetch-phase <PR_URL> [output-dir]
/review-triage-phase <PR_URL> [output-dir]
/review-implement-phase <PR_URL> [output-dir]

Behavioral rules

WILL ADDRESS items:
reply + 👍
leave unresolved until fixed
Not addressed in this PR items:
reply with rationale + 👎
resolve the thread
Implementation:
granular, intent-driven commits
explicit staging only (never git add -A / git add .)
reply “Done” and resolve when complete

Operational reliability notes (Cursor)

`gh api` TLS / cert failures in sandboxed shells

If GitHub administration fails with an error like:

x509: OSStatus -26276 (or similar TLS/certificate verification failures)

Treat it as an environment/sandbox cert-store mismatch, not a script bug.

Recovery:

Re-run the affected gh calls outside the sandbox (use a shell mode that uses the system cert store).
Do not disable TLS verification (no GH_NO_VERIFY_SSL, no custom curl flags).
After re-running, continue the loop normally (fetch → triage → implement → resolve → repeat).

JSON-first deterministic commands

All script paths below are relative to this skill's directory.

1. Fetch canonical JSON:

node ../review-fetch-phase/scripts/fetch-review-state.mjs --pr <PR_URL> --out-json <review-dir>/review-state.json

2. Render and summarize from JSON (pure scripts):

node ../review-fetch-phase/scripts/render-review-state.mjs --in <review-dir>/review-state.json --out <review-dir>/review-state.md
node ../review-fetch-phase/scripts/summarize-review-state.mjs --in <review-dir>/review-state.json --format text --out <review-dir>/summary.txt

3. Render triage plan from canonical actions JSON:

node ../review-triage-phase/scripts/render-review-actions.mjs --in <review-dir>/review-actions.json --out <review-dir>/review-actions.md

Data exchange format (triager → implementer)

review-actions.json is the contract between the triager and implementer.

Minimum v2 shape:

{
  "version": 2,
  "pr": { "url": "https://github.com/OWNER/REPO/pull/123", "nodeId": "PR_kw..." },
  "reviewState": { "path": "review-state.json", "fetchedAt": "...", "version": 2 },
  "actions": [
    {
      "actionId": "A-001",
      "target": { "kind": "review_thread", "nodeId": "PRRT_xxx", "url": "..." },
      "decision": "will_address",
      "summary": "One-line description of what will be done",
      "rationale": null,
      "targetFiles": ["path/to/file.ts"],
      "acceptance": "How to tell it's done",
      "status": "pending",
      "done": null
    }
  ]
}

Rules:

Use node ids only for targets (target.nodeId).
Preserve actions[] order intentionally (do not reorder).
Implementer updates status (pending|in_progress|done) and done records in place.
Compound targets: A single pull_request_review body may contain multiple findings (especially from automated reviewers like CodeRabbit which bundle "outside diff range" comments into the review body). The triager must decompose these into sub-actions (e.g., A02a, A02b). Never blanket-dismiss review bodies without reading their content.

Procedure

`triage`

1. Delegate to triage sub-agent

Invoke the review triager agent at ../review-triage-phase/agents/review-triager.md and pass:

PR URL
output paths:
<output-dir>/review-state.md
<output-dir>/review-state.json
<output-dir>/review-actions.md
<output-dir>/review-actions.json
optional scope constraints

2. Require triage outputs

The triager must:

fetch review state (via ../review-fetch-phase/scripts/fetch-review-state.mjs)
triage review threads into review-actions.json decisions/status
write/update review-actions.md and review-actions.json

3. Validate handoff contract

Before returning from triage, verify that <output-dir>/review-actions.json exists and is valid for implementer consumption (version, PR metadata, and actions[] with target.kind + target.nodeId).

`implement`

1. Delegate to implementation sub-agent

Invoke the review implementer agent at ../review-implement-phase/agents/review-implementer.md and pass:

PR URL
<output-dir>/review-actions.md
<output-dir>/review-actions.json
optional scope constraints

2. Require implementation outputs

The implementer must:

work through pending will_address actions
make focused, explicit-staging commits
run smallest relevant checks per action
reply "On it" when starting, then "Done" and resolve the thread when complete
update review-actions.json in-place (status, done)
re-fetch review state at the end to verify remaining actionable items

Responsibility note:

Posting "Done" and resolving completed threads belongs to the implementer phase and is part of marking actions done.

`iterate`

Repeat delegated triage → delegated implement until there are no remaining actionable review items.

Loop contract:

1. Run triage delegation and read resulting review-actions.json. 2. Inspect review-actions.json; if no will_address actions remain with pending or in_progress status, stop and report completion. 3. Run implement delegation. 4. Re-run triage delegation to refresh state and determine next iteration. 5. Continue until clear.

Optional shortcuts (repo-specific)

If this repo provides dedicated slash commands or subagents for triage/implementation, prefer them to reduce manual steps.

You are the review orchestrator. You coordinate the triager and implementer to drive a PR to merge.

Run commands from this skill's directory. All script paths below are relative to it. Sibling skills are located in the same parent directory (use ../ to reach them).

Primary loop (repeat until clear)

1. Fetch review state (JSON-first)

node ../review-fetch-phase/scripts/fetch-review-state.mjs --pr <url> --out-json <output-dir>/review-state.json
node ../review-fetch-phase/scripts/render-review-state.mjs --in <output-dir>/review-state.json --out <output-dir>/review-state.md
node ../review-fetch-phase/scripts/summarize-review-state.mjs --in <output-dir>/review-state.json --format text --out <output-dir>/summary.txt
Treat review-state.json as canonical for triage.

2. Triage

Delegate to review-triager.
Output: review-actions.json (canonical) and review-actions.md (human summary).
Ensure GH thread administration is performed:
👍 + “will address” for items that will be implemented (leave unresolved)
👎 + explanation + resolve for items not addressed in this PR

3. Inspect action state

Read review-actions.json after triage.
If no will_address actions remain with pending or in_progress status, stop and report completion.
Only delegate implementation when at least one pending will_address action exists.

4. Implement

Delegate to review-implementer to execute review-actions.md.
Enforce granular commits and explicit staging.
Ensure the implementer updates review-actions.json statuses and done completion records.
Ensure each action maps to a GH thread:
“On it” + 👍 when starting
“Done” + resolve when finished

5. Re-fetch and verify

Re-run fetch-review-state.
If unresolved actionable threads remain, loop.
If none remain, stop and report completion.

Guardrails

Keep review artifacts and scripts out of unrelated PR branches.
Never stage/commit broad untracked directories as a side effect of review automation.
Prefer resolving threads only when the PR either (a) implemented the fix, or (b) explicitly won’t address in this PR with explanation.
Use deterministic storage layout: wip/reviews/<owner>_<repo>_pr-<number>/.
Use node-id-only action targets (target.nodeId), never numeric database ids.

{
  "name": "@prisma-next/skill-github-review-iteration",
  "private": true,
  "type": "module",
  "version": "0.0.0",
  "description": "Iterative review orchestration package for github-review-iteration skill",
  "scripts": {
    "iterate": "node scripts/review-iterate.mjs"
  }
}

#!/usr/bin/env node

import { spawnSync } from 'node:child_process';
import { access, mkdir } from 'node:fs/promises';
import { dirname, resolve } from 'node:path';
import { fileURLToPath, pathToFileURL } from 'node:url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const SKILL_DIR = resolve(__dirname, '..');
const SKILLS_ROOT = resolve(SKILL_DIR, '..');

const EXIT_SUCCESS = 0;
const EXIT_OPERATIONAL = 1;
const EXIT_CLI = 2;
const DEFAULT_REVIEWS_ROOT = 'wip/reviews';

function parseCliArgs(argv) {
  const args = argv.slice(2);
  const result = { prUrl: null, reviewsRoot: DEFAULT_REVIEWS_ROOT, help: false };
  if (args.includes('--help')) return { ...result, help: true };
  for (let i = 0; i < args.length; i += 2) {
    const flag = args[i];
    const value = args[i + 1];
    if ((flag !== '--pr' && flag !== '--reviews-root') || !value) {
      throw { code: EXIT_CLI, message: `error: invalid args near "${flag ?? ''}"` };
    }
    if (flag === '--pr') result.prUrl = value;
    if (flag === '--reviews-root') result.reviewsRoot = value;
  }
  if (!result.prUrl) throw { code: EXIT_CLI, message: 'error: --pr is required' };
  return result;
}

function parsePrUrl(url) {
  const match = url
    .trim()
    .match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)(?:\/)?(?:#.*)?$/i);
  if (!match) return null;
  return {
    owner: match[1],
    repo: match[2].replace(/\.git$/i, ''),
    number: Number.parseInt(match[3], 10),
  };
}

function deriveReviewDirectoryName(prUrl) {
  const parsed = parsePrUrl(prUrl);
  if (!parsed) throw new TypeError('error: invalid --pr value');
  return `${parsed.owner.toLowerCase()}_${parsed.repo.toLowerCase()}_pr-${parsed.number}`;
}

function runNodeScript(scriptPath, args) {
  const result = spawnSync(process.execPath, [scriptPath, ...args], { stdio: 'inherit' });
  if (result.status !== 0) throw new Error(`error: failed running ${scriptPath}`);
}

async function fileExists(path) {
  try {
    await access(path);
    return true;
  } catch {
    return false;
  }
}

async function main() {
  const options = parseCliArgs(process.argv);
  if (options.help) {
    process.stdout.write('Usage: review-iterate.mjs --pr <url> [--reviews-root <dir>] [--help]\n');
    process.exit(EXIT_SUCCESS);
  }

  if (!parsePrUrl(options.prUrl)) {
    throw { code: EXIT_CLI, message: 'error: --pr must be a GitHub pull request URL' };
  }

  const directoryName = deriveReviewDirectoryName(options.prUrl);
  const reviewDir = resolve(options.reviewsRoot, directoryName);
  await mkdir(reviewDir, { recursive: true });

  const reviewStateJsonPath = resolve(reviewDir, 'review-state.json');
  const reviewStateMdPath = resolve(reviewDir, 'review-state.md');
  const reviewSummaryPath = resolve(reviewDir, 'summary.txt');
  const reviewActionsJsonPath = resolve(reviewDir, 'review-actions.json');
  const reviewActionsMdPath = resolve(reviewDir, 'review-actions.md');
  await mkdir(dirname(reviewStateJsonPath), { recursive: true });

  const fetchPhase = resolve(SKILLS_ROOT, 'review-fetch-phase/scripts');
  const triagePhase = resolve(SKILLS_ROOT, 'review-triage-phase/scripts');

  runNodeScript(resolve(fetchPhase, 'fetch-review-state.mjs'), [
    '--pr',
    options.prUrl,
    '--out-json',
    reviewStateJsonPath,
  ]);
  runNodeScript(resolve(fetchPhase, 'render-review-state.mjs'), [
    '--in',
    reviewStateJsonPath,
    '--out',
    reviewStateMdPath,
  ]);
  runNodeScript(resolve(fetchPhase, 'summarize-review-state.mjs'), [
    '--in',
    reviewStateJsonPath,
    '--format',
    'text',
    '--out',
    reviewSummaryPath,
  ]);

  if (await fileExists(reviewActionsJsonPath)) {
    runNodeScript(resolve(triagePhase, 'render-review-actions.mjs'), [
      '--in',
      reviewActionsJsonPath,
      '--out',
      reviewActionsMdPath,
    ]);
  }

  process.stdout.write(`${reviewDir}\n`);
}

const isMain =
  Boolean(process.argv[1]) && pathToFileURL(resolve(process.argv[1])).href === import.meta.url;
if (isMain) {
  main().catch((error) => {
    const code = typeof error?.code === 'number' ? error.code : EXIT_OPERATIONAL;
    process.stderr.write(`${error?.message ? String(error.message) : String(error)}\n`);
    process.exit(code);
  });
}

Related skills

Agent BrowserGive their coding agent reliable, high-fidelity control over any website or Electron desktop app.591k39.6k

Lark ApprovalLet their AI coding agent create, read, update, and approve items in Lark (Feishu) approval workflows without leaving the coding environment.494k

Lark EventHandle Feishu/Lark bot events, webhooks, and subscription callbacks in agent-driven backend code.493k

Lark Workflow Meeting SummaryAutomatically generate structured meeting summaries and action items from Lark/Feishu calls without manual note-taking.492k

Lark Workflow Standup ReportAutomatically generate and post daily standup reports in Lark/Feishu from their workflow and activity data.492k

Twitter AutomationAutomate X/Twitter posts, scheduling, and engagement via X API integration441k669

FAQ

What does github-review-iteration do?