Skip to main content
skill CX Codex

review · hashgraph-online — Claude Code skill: code review and installation

This skill reviews PRs and diffs with multiple agents. Its default mode uses 5 agents; --deep runs the full review pipeline.

MIT ★ 1,596 updated 2026-10-29

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add hashgraph-online/awesome-codex-plugins --skill review -a claude-code
Open on GitHub

What review does

The skill chooses a diff source from a PR or MR link, a branch comparison, or local changes. It stops when the current directory is not a Git repository, and it has nothing to review when the diff is empty.

The default run uses 5 agents. Add --deep to run the full pipeline, including a quality check and senior review; --with-codex adds cross-model coverage. Use --plan <path> to provide a plan whose constraints apply to the review. The --run-checks flag lets a branch review run project tests to investigate a finding.

Install it in Claude Code with npx skills add hashgraph-online/awesome-codex-plugins --skill review -a claude-code. A Git repository is required; outside one, the review stops.

What it helps with

  • review changes in a PR or MR
  • compare a working branch with its base
  • inspect local uncommitted changes
  • run project tests to check a finding

Example prompts for the agent

  • Review the changes in my current branch against main.
  • Run a deep review of this PR and include Codex.
  • Review the diff using docs/review-plan.md and run tests to check findings.

How to install review

1Skills CLI (Vercel)

npx skills add hashgraph-online/awesome-codex-plugins --skill review -a claude-code

2Manually: put the files in place

~/.claude/skills/review/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/review/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about review

How do I install review in Claude Code?

Run npx skills add hashgraph-online/awesome-codex-plugins --skill review -a claude-code. The skill file is placed at ~/.claude/skills/review/SKILL.md.

What does the review skill do?

It gathers a diff from a PR or MR, branch comparison, or local changes, then sends it to multiple review agents. The default mode uses 5 agents.

What changes when I use deep mode?

The --deep flag runs the full agent pipeline, with a quality check and senior review. Add --with-codex for review coverage from another model.

Source text

SKILL.md · MIT
---
name: review
description: Run a multi-agent code review. Default fast mode (5 agents); pass --deep for full pipeline (all agents + quality check + senior review). Pass --with-codex for cross-model coverage.
argument-hint: "[PR/MR URL | --base <branch>] [--deep] [--plan <path>] [--run-checks] [--output <path>] [--set-output <path>] [--terminal] [--comment-pr] [--with-codex]"
when-to-use: "user wants a multi-agent code review of a PR or diff -- '/review', '/quiver:review', 'review my changes', 'review this PR', 'code review', 'audit the diff' (not: 'senior review')"
---

# Gather Context

```
!`git rev-parse --is-inside-work-tree 2>/dev/null || echo "NO_GIT"`
```

```
!`git branch --show-current 2>/dev/null || echo "NO_GIT"`
```

```
!`git branch --sort=-committerdate 2>/dev/null || echo "NO_GIT"`
```

---

# Instructions

You are a review orchestrator. Your job is to determine the correct diff source, announce the review mode, dispatch multiple review agents in parallel, then synthesize their findings into a single unified report.

## Step 0 -- Git Availability

If any gather-context block above returned `NO_GIT`, this directory is not a git repository.
Print: `> No git repository detected. /quiver:review requires a git repo.`
**Stop here.**

## Step 0.5 -- Detect Review Depth

Parse `$ARGUMENTS` for the `--deep`, `--plan`, and `--run-checks` flags:

1. If `$ARGUMENTS` contains `--deep`, set `review_mode = deep`. Strip `--deep` from `$ARGUMENTS` before passing to subsequent steps.
2. Otherwise, set `review_mode = fast`.
3. If `$ARGUMENTS` contains `--plan <path>`, set `constraints_plan_path` to the path token that follows the flag, and strip both `--plan` and that path from `$ARGUMENTS` before passing to subsequent steps. Otherwise leave `constraints_plan_path` unset.
4. If `$ARGUMENTS` contains `--run-checks`, set `run_checks` and strip the flag from `$ARGUMENTS` before passing to subsequent steps. Otherwise leave `run_checks` unset.

`--deep` affects Steps 2 (agent dispatch), 3 (synthesis), 3.5, 3.75, and 3.9 only. `--plan` affects Step 1.8 only -- it names the plan whose Global Constraints bind this review, and never changes which diff is reviewed. `--run-checks` affects Step 3.3 only -- it lets a branch review run the project's tests to check a finding. All other steps (diff source detection, manifest building, LSP detection, report saving, PR posting) are identical in both modes. Fast mode includes Step 3.3: every finding is checked against the code in both modes.

Announce the mode:
- Fast: `Running review (5 core agents)...`
- Deep: `Running deep review (full agent pipeline)...`

## Step 1 -- Determine Review Mode

Silently evaluate the conditions below in order. Use the **first** mode that matches.

### Mode 1 -- PR/MR Link Provided

If `$ARGUMENTS` contains a pull request or merge request URL from any Git platform (GitHub, GitLab, Bitbucket, Azure DevOps, etc.):

1. Detect the platform from the URL pattern. For GitHub, pass the full URL directly to `gh pr diff`. For GitLab, extract the merge request number and validate it is numeric.
   - **GitHub:** `github.com/{owner}/{repo}/pull/{number}` -- use `gh pr diff <full-URL>`
   - **GitLab:** `gitlab.com/{group}/{project}/-/merge_requests/{number}` -- extract `{number}` (must be numeric) and use `glab mr diff {number}`
   - **Bitbucket:** `bitbucket.org/{workspace}/{repo}/pull-requests/{number}` -- Bitbucket CLI lacks a direct diff command. Fall back to Mode 2 (branch diff).
   - **Other platforms:** Fall back to Mode 2 with a note:
     > Platform not recognized for direct diff fetching. Falling back to branch diff.
2. Before running a platform CLI command (`gh`, `glab`), check if the CLI is available. If not, fall back to Mode 2 with a note:
   > `{cli}` CLI not found. Falling back to branch diff.
3. Announce: `Reviewing PR/MR from provided link...`
4. If fetching fails (permissions, invalid URL), print a warning:
   > Could not fetch diff from the provided link. Falling back to branch diff.
   Then continue to Mode 2.
5. If fetching succeeds, pass the diff to the agent in Step 2.

### Mode 2 -- Branch Diff

If no PR link was provided (or Mode 1 fell back), and **any** of the following are true: (a) `$ARGUMENTS` contains `--base <branch>`, or (b) the current branch is **not** `main` or `master`:

1. **Determine the base branch** using one of these methods (in order):
   - **`--base` flag:** If `$ARGUMENTS` contains `--base <branch>`, use that branch directly. Skip the prompt.
   - **Interactive selection:** Otherwise, use `AskUserQuestion` to ask the user which base branch to compare against. Use the gathered branch list output to build action buttons for candidate branches. Include an **"Other (I'll type it)"** button as the last option. Phrasing:
     > You're on `{current_branch}`. Which branch should I compare against for the review?
   - If the user picks "Other (I'll type it)", ask them to type the branch name.
1b. **Validate the base branch:** Run `git rev-parse --verify {base_branch}` to confirm the ref exists.
    If it fails: > Branch `{base_branch}` not found. Please check the name and try again.
    **Stop here.**
2. Announce: `Reviewing branch {current_branch} against {base_branch}...`
3. Get the diff:
   ```
   git diff {base_branch}...HEAD
   ```
4. If the diff is empty, announce:
   > Branch diff against `{base_branch}` is empty. Checking for local uncommitted changes...
   Then continue to Mode 3.
5. Otherwise, pass the diff to the agent in Step 2.

### Mode 3 -- Uncommitted/Staged Changes

If the current branch is `main`/`master`, or the branch diff was empty:

1. Check for unstaged changes:
   ```
   git diff
   ```
2. If empty, check for staged changes:
   ```
   git diff --cached
   ```
3. If both are empty:
   > No changes to review. Commit some changes or switch to a feature branch and try again.
   **Stop here.**
4. Announce: `Reviewing local uncommitted changes...`
5. Pass the diff to the agent in Step 2.

### Re-review detection (all modes)

After obtaining the diff, check if a previous review report exists for this branch:

1. Scan the report directory (`.claude/reports/` or saved preference path) for `review-*.md` files.
2. **Filter by branch.** For each report found, read its `## Review Context` section and check the `Branch` field. Only consider reports that match the current branch. Discard reports for other branches.
3. If one or more matching reports exist, read the most recent one and extract its findings and metadata.
4. **Calculate iteration number**: Read the previous report's `## Review Context` section. Extract the `Iteration` value and increment by 1. If the previous report has no `Iteration` field, this is iteration 2.
5. **Extract previous HEAD commit**: Read the `HEAD at review` field from the previous report's `## Review Context`. Use this SHA to compute the delta diff: `git diff {previous_head_sha}...HEAD`. If the field is missing, fall back to using the report's filename timestamp to estimate the commit range via `git log --after="{timestamp}" --format=%H`.
6. This is a **re-review**. Apply these constraints:
   - **Scope lock**: Only flag findings that are (a) NEW issues introduced by commits made AFTER the previous review's timestamp, or (b) regressions where a previously-addressed finding has reappeared.
   - **No scope expansion**: Do NOT flag pre-existing patterns, stylistic preferences, or aspirational improvements that were not in the original review. The original review had the chance to flag these -- if it didn't, they are accepted.
   - **Idempotency check**: If the diff between the previous review and now contains NO functional code changes (only whitespace, comments, or formatting), the verdict MUST be "Approve" with zero findings.
   - When populating the report template's `## Review Context` section, set `Iteration` to {N}, `Previous report` to the path of the matched report, `Scope` to "Delta-only (changes since previous review)", and add a `Delta` line with `{commit_count} commits, {files_changed} files`.
7. Pass the re-review context and scope constraints to all agents in Step 2.

---

## Step 1.5 -- Build Diff Manifest

After obtaining the diff, analyze the list of changed files and classify each one. Build a text manifest using the taxonomy below:

| Type | Matched by | Security relevance |
|------|-----------|-------------------|
| `PROMPT` | `commands/*.md`, `agents/**/*.md`, `skills/**/*.md` with YAML frontmatter | Low -- instructions to LLM |
| `SCRIPT` | `*.sh` (anywhere, not just hooks/), `Makefile`, `Dockerfile`, `*.py`/`*.rb` (executable), CI workflow files (`.github/workflows/*.yml`, `.gitlab-ci.yml`) | High |
| `CONFIG-APP` | App configuration: auth, database, CI/CD environment, secrets files (`*.json`, `*.yaml`, `*.toml` containing app settings, credentials, or infrastructure) | High |
| `CONFIG-MANIFEST` | Package/plugin registries: `plugin.json`, `package.json`, lockfiles, `tsconfig.json`, `*.toml` build configs, `.gitignore`, `.editorconfig`, `.dockerignore` -- structural metadata only | Low |
| `CODE` | Application source (JS, TS, Go, Dart, etc.) | High |
| `DOCS` | `*.md` outside command/agent/skill dirs, `README*`, `CHANGELOG*` | Low |

Format the manifest as a simple list:

```
Diff Manifest:
- skills/review/SKILL.md → PROMPT (low security relevance)
- hooks/scripts/pre-compact-handover.sh → SCRIPT (high security relevance)
- plugin.json → CONFIG-MANIFEST (low security relevance)
- .env.example → CONFIG-APP (high security relevance)
```

Include risk signals if present: new dependencies, auth changes, secrets handling, new endpoints.

---

## Step 1.75 -- Navigation Detection

Before dispatching agents, detect navigation capabilities once.

**CodeGraph:** Check if `.codegraph/` exists at project root. Set `codegraph_available` to `true` or `false`. No user prompt.

**LSP:** Run the LSP detection flow in `skills/code-navigation/SKILL.md` (cached preference, one probe, no prompt); it yields `lsp_available`.

Pass both `codegraph_available` and `lsp_available` to agents that search the broader codebase (waste-detector, architecture-strategist, stress-tester, and project-context-analyst) in Step 2.

---

## Step 1.8 -- Global Constraints Discovery

Find the plan whose Global Constraints bind this review and extract that block verbatim. This step is a read-only lookup. It never edits, extends, paraphrases, or renumbers the block, and it never writes a plan file -- `/plan` is the only skill that decides constraint content.

1. **Explicit plan only.** If Step 0.5 set `constraints_plan_path` from `--plan <path>`, use that file. Otherwise set the block to empty and go to rule 3, in branch, PR and uncommitted mode alike. Never pick a plan on your own: a plan file is not tied to a branch, so a plan chosen by date or name can belong to another open branch, and a wrong constraint removes real findings in the suppression direction. `/work` and `/ship` print the review command with `--plan` for this reason; a user who knows a plan applies passes `--plan <path>`.
2. **Extract the block.** Read the file and take the `## Global Constraints` section: every line after that heading up to the next `## ` heading, with leading and trailing blank lines trimmed. Step 3's report template prints `constraints_plan_path` in `## Review Context`.
3. **Degrade cleanly.** With no `--plan`, a path that does not exist or cannot be read, or a file with no `## Global Constraints` heading, set the block to empty and continue with no note, no warning, and no error. An empty block means Step 2 skips per-agent context item 10 entirely, the Step 3 `constraint-blocked` filter never fires, and the report's `Global Constraints` field reads `N/A`. This path must behave exactly as a review did before this step existed.

Do the read with the Read tool at this point in the run, not with a `!` block at the top of this file: it depends on the flag parsed in Step 0.5, and `!` blocks run before any step logic.

Say nothing about this step in the chat stream. The report's `Global Constraints` field and the `constraint-blocked` entries in `## Filtered Findings` are where the block becomes visible.

---

## Step 2 -- Parallel Agent Dispatch

### 2a -- Discover available agents

Discover agents using a two-tier registry:

**Tier 1 — Review agents (dynamic):** Scan `agents/review/*.md`. For each `.md` file, read its YAML frontmatter to extract `name` and `description`.

**Tier 2 — External specialists (explicit):** Also include these agents from outside the review directory:
- `agents/research/best-practices-researcher.md`
- `agents/research/project-context-analyst.md`

For Tier 2 agents, read the frontmatter the same way. If a Tier 2 file is missing or unreadable, skip it silently — do not fail the review.

**Agent type identifiers** use the format `quiver:{name}` where `{name}` is the frontmatter `name` field. The category subdirectory is organizational only -- it is NOT part of the identifier. Examples:
- `agents/review/waste-detector.md` → `quiver:waste-detector`
- `agents/research/best-practices-researcher.md` → `quiver:best-practices-researcher`

### 2b -- Conditional Dispatch

Apply dispatch rules based on the Diff Manifest from Step 1.5.

The canonical gate for every agent is the `## Dispatch Gates` table in `.claude/rules/review-agent-rules.md`. The per-agent rules restated below are a copy of it for the orchestrator's use, and `tests/skills/test-review-dispatch-contract.sh` is the binding that fails when the copies diverge. When a gate changes, change the table first.

### Review depth dispatch

**If `review_mode = fast`:** Dispatch only these 5 agents:
- **`waste-detector`**: Always dispatched (same as deep mode).
- **`security-audit`**: Only when diff contains `SCRIPT`, `CODE`, or `CONFIG-APP` files (same gate as deep mode). In fast mode, receives additional context: "FAST MODE CHECK: For state management and interactive flows, verify every user-initiated process has a guaranteed termination path (timeout, cancel handler, forced cleanup). Missing exit conditions on partial user actions create livelock -- flag as High."
- **`logic-reviewer`**: Only when diff contains `SCRIPT` or `CODE` files (same gate as deep mode).
- **`best-practices-researcher`**: Only when diff contains `SCRIPT` or `CODE` files (same gate as deep mode). Include changed file list with detected languages/frameworks in the prompt.
- **`project-context-analyst`**: Always dispatched (same as deep mode). No scope restriction in fast mode -- the agent uses its full methodology to search git history and codebase for constraints that affect the diff. Scoping this agent reduces its effectiveness because it misses constraint forms not explicitly listed in the prompt.

All other agents are skipped in fast mode. Do not print skip notes for agents excluded by mode -- only print skip notes for agents excluded by their file-type gate within the active set (e.g., if fast mode is active and the diff has no CODE files, print the security-audit skip note).

**`--with-codex` in fast mode:** `codex-code-reviewer` is a deep-mode-only agent. If `--with-codex` is passed with fast mode, print:
> `--with-codex` requires `--deep` mode. Run `/quiver:review --deep --with-codex` for Codex coverage.
Then continue the fast review without Codex.

**If `review_mode = deep`:** Use the existing dispatch rules below (unchanged).

### Deep mode dispatch rules

- **`waste-detector`**: Always dispatched. Evaluates every changed file for unnecessary additions, redundancy with existing codebase, dead paths, and over-engineering.
- **`project-context-analyst`**: Always dispatched. Searches git history, project memory, and docs for institutional knowledge relevant to the changed files. Provides context that informs other agents' findings.
- **`security-audit`**: Only dispatched when the diff contains at least one `SCRIPT`, `CODE`, or `CONFIG-APP` file. Skip when all files are `PROMPT`, `DOCS`, or `CONFIG-MANIFEST`:
  > Skipping security-audit: no application code, scripts, or security-relevant configuration changed.
- **`best-practices-researcher`**: Only dispatched when the diff contains at least one `SCRIPT` or `CODE` file. Configuration files (both `CONFIG-APP` and `CONFIG-MANIFEST`) do not trigger this agent since they lack framework/library code to research. If dispatched, its prompt must include the list of changed files with their detected languages/frameworks so it can target its context7 lookups. Skip with a note otherwise:
  > Skipping best-practices-researcher: no application code or scripts changed.
- **`architecture-strategist`**: Only dispatched when the diff contains at least one `SCRIPT`, `CODE`, or `CONFIG-APP` file. If dispatched, its prompt must include the project's root file listing (`ls` of the project root) so it can map conventions in Phase 1. Skip when all files are `PROMPT`, `DOCS`, or `CONFIG-MANIFEST`:
  > Skipping architecture-strategist: no application code, scripts, or structural configuration changed.
- **`developer-experience-auditor`**: Only dispatched when the diff contains at least one `SCRIPT` or `CODE` file. Evaluates discoverability, error message quality, debugging experience, and automation-readiness. Skip when no code/scripts changed:
  > Skipping developer-experience-auditor: no application code or scripts changed.
- **`logic-reviewer`**: Only dispatched when the diff contains at least one `SCRIPT` or `CODE` file. Traces each changed function's inputs through branches to verify logical correctness. Skip when all files are `PROMPT`, `DOCS`, or `CONFIG-MANIFEST`:
  > Skipping logic-reviewer: no application code or scripts changed.
- **`test-reviewer`**: Only dispatched when the diff contains at least one `SCRIPT` or `CODE` file. Evaluates test assertion strength, regression detection power, and risk-based coverage gaps. Skip when all files are `PROMPT`, `DOCS`, or `CONFIG-MANIFEST`:
  > Skipping test-reviewer: no application code or scripts changed.
- **`stress-tester`**: Only dispatched when the diff contains at least one `SCRIPT` or `CODE` file. Constructs failure scenarios via assumption stress, composition fracture, and cascade chains. Receives depth calibration context: diff manifest file types + detected risk signals. Skip when all files are `PROMPT`, `DOCS`, or `CONFIG-MANIFEST`:
  > Skipping stress-tester: no application code or scripts changed.
- **`codex-code-reviewer`**: Only dispatched when ALL three conditions are met: (1) `$ARGUMENTS` contains `--with-codex`, (2) the `codex` CLI is detected on PATH, and (3) the diff is 2000 lines or fewer. This agent is a transport adapter that delegates the review to OpenAI Codex via the `codex` CLI; the actual reviewing is performed by Codex, not Claude. The Codex agent runs in parallel with all qualifying Claude review agents, providing cross-model "third eye" coverage. The CLI presence check is a Bash tool call the orchestrator performs at dispatch time (`command -v codex >/dev/null 2>&1 && echo PRESENT || echo MISSING`); do not place this check inside a `!` block in this command file (R3 forbids logic-bearing pipes in shell blocks). The diff line count is already available from the diff captured in Step 1 (`wc -l` on the diff output). Skip with notes otherwise:
  > Skipping codex-code-reviewer: --with-codex flag not provided.
  > Skipping codex-code-reviewer: codex CLI not found on PATH. Install with `npm install -g @openai/codex` (>= 0.123.0) or run `/codex:setup` from the openai/codex-plugin-cc plugin.
  > Skipping codex-code-reviewer: diff exceeds 2000 lines ({actual_count} lines). Codex review is skipped for large diffs to avoid excessive token consumption and timeouts.
- **`report-checker`**: Never dispatched in Step 2. This agent is a post-synthesis quality gate, dispatched only in Step 3.5 after the report is assembled. Skip silently during agent discovery.
- **`senior-reviewer`**: Never dispatched in Step 2. This agent is a post-quality-check senior review, dispatched only in Step 3.75 after report-checker completes. Skip silently during agent discovery.
- **`fix-reviewer`**: Never dispatched in Step 2. This agent is a post-senior-review fix-proposal check, dispatched only in Step 3.9 after senior-reviewer completes. It lives under `agents/debug/`, so Step 2a's discovery never sees it. Skip silently during agent discovery.
- **`finding-verifier`**: Never dispatched in Step 2 -- it runs at Step 3.3, once per synthesized finding. Skip silently during agent discovery.
- **Future agents**: Add a row to the `## Dispatch Gates` table in `.claude/rules/review-agent-rules.md` before the agent's first review run, then restate that row here. The table row is the gate. Until a row exists, the agent is dispatched on every diff regardless of what changed, and `tests/skills/test-review-dispatch-contract.sh` fails until one is added -- dispatching too much is recoverable, silently reviewing nothing is not.

Spawn qualifying agents simultaneously using multiple Agent tool calls in a single response. Use the `quiver:{name}` identifier format described above as the `subagent_type`.

Each agent receives (in this order):
1. The **Diff Manifest** from Step 1.5.
2. A **scope reminder**: "Your findings MUST be scoped to code CHANGED in this diff. Respect file classifications in the Diff Manifest."
3. **Review context**: mode used, branches, PR URL (if applicable).
4. **Re-review context** (if applicable): "This is re-review iteration {N}. ONLY flag issues that are NEW in the delta since the previous review or regressions of previously-fixed findings. Do NOT flag pre-existing patterns, stylistic preferences, or aspirational improvements. If the delta contains no functional changes, return zero findings."
5. The **full diff** from Step 1. For re-reviews, also include the delta diff (`git diff {previous_head_sha}...HEAD`).
6. **File scope reminder**: "Review ALL file types in the diff regardless of language or type -- shell scripts, config files, CI configs, and build scripts deserve the same scrutiny as application source code."
7. **Citation accuracy**: "Every file:line reference in your findings must be verified by reading the file. Do not cite line numbers from memory or inference -- use the Read tool to confirm the content at the cited line before including it in a finding."
8. **Navigation availability** (for waste-detector, architecture-strategist, stress-tester, and project-context-analyst): `codegraph_available: {true|false}` and `lsp_available: {true|false}` from Step 1.75. These agents search the broader codebase and benefit from CodeGraph/LSP-first navigation. Other agents are diff-scoped and do not need these flags.
9. **Scope discipline**: Aspirational improvements, stylistic preferences, "could be better" suggestions, and theoretical hardening are out of scope. Flag only concrete demonstrable problems with code that is wrong, unsafe, or broken as written. If the code works correctly as written and you would not fix it yourself, do not flag it. Zero findings is a correct and expected result on clean code. (This clause applies on every review. Re-review mode adds additional delta-specific scope on top of this general lock.)
10. **Global Constraints** (only when Step 1.8 produced a non-empty block). Skip this item entirely when the block is empty -- do not emit the heading, an empty list, or a "no constraints" line. When the block is non-empty, append it exactly as written below, substituting the discovered plan path and the block text with no edits of your own:

    ```
    ## Global Constraints (from {plan path})

    These bind the change under review. They cut both ways:
    - A change in the diff that violates one of these is a finding, at whatever
      severity the violation earns.
    - A finding whose recommendation would require violating one of these is not a
      finding. Discard it and emit a one-line SUPPRESSED entry naming the constraint
      that ruled it out.

    {verbatim block}
    ```

    Pass the block through unchanged. Do not renumber it, summarize it, split it per agent, or add constraints of your own -- every agent receives the same text, and Step 3 relies on the agents' `SUPPRESSED` entries naming constraints the block actually contains.

### Adding future agents

- **Review-scoped agents:** Create under `agents/review/` and register in `plugin.json`'s `agents` array. The orchestrator discovers them automatically via Tier 1.
- **Cross-category agents:** Create under `agents/<category>/`, register in `plugin.json`, and add the path to the Tier 2 list in Step 2a. Add a dispatch rule in Step 2b.

**No fallback polling.** After dispatching agents, wait for the harness's completion notification before moving to Step 3 -- never call `ScheduleWakeup` as a hedge against a missed notification. The harness always notifies on completion; a fallback wakeup gains nothing and, if its delay exceeds the 5-minute prompt-cache TTL, forces a full-context reprocess of the growing conversation on every fire.

## Step 3 -- Synthesize Findings

After **all** agents return, merge their outputs into a single unified report.

### Synthesis mode

**If `review_mode = fast`:** Use the simplified synthesis rules below. **If `review_mode = deep`:** Use the full synthesis rules (items 0-9 with subsumption and proportional floor).

### Fast mode synthesis

With 5 agents, the finding volume is low enough to skip the heavy-duty noise reduction designed for 10+ agent output.

0. **Filter on substance, not citation form.** Same as deep mode item 0 -- correct citations rather than discard findings.
1. **Deduplicate.** If 2+ agents flag the same issue, keep the more detailed finding and note both agents. No consensus tracking (5 agents rarely produce 3+ consensus).
2. **Unified severity.** Same scale and definitions as deep mode (Critical/High/Medium/Low).
3. **Tag source.** Same format: `[ID] [SEVERITY] (agent-name) file:line -- title`.
4. **Filter false positives.** Apply 5 filters only:
   - Prompt-vs-code confusion (agent treats prompt text as executable code)
   - Out-of-scope findings (references code not changed in diff)
   - Phantom citations (graduated check with recovery -- same as deep mode item 4 sub-items a/b/c)
   - Severity inflation (hypothetical scenario -> downgrade to Low)
   - Constraint-blocked (finding carries a `SUPPRESSED` entry, or its recommendation cannot be acted on without violating a Global Constraint) -> DISCARD, recorded as filtered with classification `constraint-blocked` and the constraint named. Same rule as deep mode item 4, so both modes behave identically; never fires when Step 1.8 produced no block.
5. **Unified verdict.** Same rules as deep mode.
6. **Identify strengths.** Same rules as deep mode.
7. **Assign a disposition to every finding.** Same rules as deep mode item 7, including the rule that a finding whose own body argues against acting now cannot be **Before merge**.
8. **Compute fix order.** Same rules as deep mode item 8.
9. **Populate findings overview.** Same format as deep mode.

**Skipped in fast mode:**
- Subsumption (parent-child merging) -- finding volume too low to need it
- Proportional severity floor (Profile A/B/C) -- designed for 10-agent output volumes
- Consensus tracking with severity upgrade -- 5 agents rarely produce 3+ consensus given non-overlapping scopes
- Contradictions filter -- rare with 5 non-overlapping agents
- Aspirational refactoring filter -- agents' discipline rules already suppress this
- Subjective style filter -- same
- Misapplied doc lookups filter -- best-practices-researcher already handles this internally

### Deep mode synthesis

Follow these rules:

**0. Filter on substance, not citation form.** When a finding's underlying observation is verifiable in the codebase but its citation is malformed (wrong line number, off-by-N, points to a blank line or unrelated content), **correct the citation rather than discard the finding**. Use grep or file search to locate the described content; if found, update the `file:line` reference and keep the finding. Only discard as a phantom citation when the described content does not appear anywhere in the cited file (true fabrication). Do not use citation-format filters to drop findings whose underlying defects you have verified to exist. The phantom-citation filter (item 4 below) exists to suppress hallucinations, not to dismiss substantive observations on a technicality. This rule applies to every agent's output but is most relevant for external transport adapters like `codex-code-reviewer`, where line-number drift between diff hunk position and absolute file line is a common LLM error.

1. **Deduplicate with consensus tracking.** If two or more agents flag the same issue (e.g., waste-detector's Redundancy Scan and architecture-strategist both flag unnecessary duplication, or security-audit and best-practices-researcher both flag an unsafe dependency pattern), keep the more detailed finding and discard the other. Prefer the specialist agent's version when depth is comparable. **Record which agents flagged it** -- when 2+ agents independently flag the same issue, add a `Flagged by:` annotation listing all agents. Multi-agent consensus increases confidence; when 3+ agents flag the same issue, consider upgrading its severity by one tier (e.g., Medium -> High) unless it is already Critical.

   **Subsumption rule.** After deduplication, check for parent-child relationships between remaining findings. If a narrow finding is a direct symptom, consequence, or subset of a broader finding, **absorb** the narrow finding into the broader one instead of listing it separately. **Parent selection:** Choose the finding that better explains the root cause or connects to project conventions/architecture as the parent -- not necessarily the one with higher severity. A LOW finding that explains "this breaks the pro...

© Yilmaz Yagiz Dokumaci · MIT · hashgraph-online/awesome-codex-plugins

Similar skills

All skills for Code review and refactoring →

review by other authors comes first.

review garrytan review is a Claude Code skill that checks local changes, a branch, or a PR before merge. It examines the diff and writes a review report. CX Codex +1 514installs review official anthropics review is a Claude Code skill that checks incoming agreements against a company playbook and routes them to the right review skills. It runs when a contract is submitted for review. CX Codex +1 778installs review JuliusBrussee Runs an adversarial senior review of the spec before any code is written. Builds a skeptic and tries to refute the plan instead of rubber-stamping it. CX Codex +1 811installs review parcadei review runs parallel specialized subagents to evaluate code quality, architecture, and impact, then synthesizes a final merge verdict. CX Codex +1 523installs review jsmastery-pro review audits completed features against your original plan, system architecture, and production readiness. Flags discrepancies in a structured report without making code edits. CX Codex +1 1,000installs code-review-gate kyy-logs The code-review-gate Claude Code skill reviews code changes before a commit or PR merge. It gathers the diff, checks test quality, and records issues. CX Codex +1 ★ 517repo stars independent-review Paweł Huryn The independent-review Claude Code skill runs an independent code review before a release and after fixes. The reviewer must start in a session that did not build the change. CX Codex +1 ★ 741repo stars ai-code-review-triage laulauraluo The ai-code-review-triage skill for Claude Code reviews pull requests and diffs produced by AI coding agents. It separates defect hunting from context checks and approval decisions. CX Codex +1 ★ 90repo stars production-readiness-review vaibhav-space production-readiness-review is a Claude Code prompt for auditing repository changes before a commit or deployment. It checks diffs, code, tests, and integration points. GP ChatGPT ★ 336repo stars code_review Ivanna Kaceviča The code_review rule for Claude Code sets a review process for changes before merging. It checks branches, files, code, tests, and the PR/MR description. CX Codex +1 ★ 674repo stars branch-review-before-pr ulpi-io branch-review-before-pr reviews a branch diff against the default base and reports merge-stopping defects before the PR exists. Edits nothing until you approve a fix. CX Codex +1 167installs

From the same set391

The whole set →
amazon-ads-marketing-cloud amazon-ads-marketing-cloud formulates AMC SQL queries, analyzes ad attribution pathways, and manages audience segments directly within conversational agent workflows. CX Codex +1 ★ 1,596repo stars ship ship breaks a project into phases and runs each from discovery through implementation, checks, and a report. Saved phase state lets you resume after a stop or /clear. CX Codex +1 ★ 1,596repo stars pr A rule file that hands your agent the bkt pr command reference: list, view, approve and merge pull requests on Bitbucket Data Center or Cloud. CX Codex +1 ★ 1,596repo stars maintaining-modding-environments maintaining-modding-environments handles ongoing maintenance for Bethesda modding setups: updates KB packs, cleans cache directories, and configures the xtl translation tool. CX Codex +1 ★ 1,596repo stars codiris-agentizer The codiris-agentizer skill crawls a company's site, works out what it sells, and builds a matching agentfront from a Next.js template. CX Codex +1 ★ 1,596repo stars zotero-research-tools The zotero-research-tools plugin connects an agent to a local Zotero library through Zotero MCP. Use it to find and read items, prepare citations, and inspect collections and tags. CX Codex ★ 1,596repo stars youtube-skills The youtube-skills plugin for Claude Code extracts YouTube transcripts with timestamps, searches videos and channels, and browses playlists via TranscriptAPI without yt-dlp or headless browsers. CX Codex ★ 1,596repo stars yandex-direct-for-all yandex-direct-for-all — a plugin bundle connecting Claude Code and Codex to Yandex Direct, Metrika, and Wordstat v2 via MCP servers. CX Codex ★ 1,596repo stars

Project sponsors

Companies that keep this analytics open