review-adjudication

Discriminately adjudicate PR review comments before implementation. Treat each comment as a claim to test, build the strongest no-change countercase, recover PR rationale with explicit `$seq` when needed, and decide what to act on, rebut, defer, or investigate. Trigger for `$review-adjudication`, review the review, adjudicate PR comments, are these comments relevant, which comments matter, or should we act on these comments. Not for implementing fixes, writing rebuttals only, or final merge closure.

46 stars

Best use case

review-adjudication is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Discriminately adjudicate PR review comments before implementation. Treat each comment as a claim to test, build the strongest no-change countercase, recover PR rationale with explicit `$seq` when needed, and decide what to act on, rebut, defer, or investigate. Trigger for `$review-adjudication`, review the review, adjudicate PR comments, are these comments relevant, which comments matter, or should we act on these comments. Not for implementing fixes, writing rebuttals only, or final merge closure.

Teams using review-adjudication should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/review-adjudication/SKILL.md --create-dirs "https://raw.githubusercontent.com/tkersey/dotfiles/main/codex/skills/review-adjudication/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/review-adjudication/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How review-adjudication Compares

Feature / Agentreview-adjudicationStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Discriminately adjudicate PR review comments before implementation. Treat each comment as a claim to test, build the strongest no-change countercase, recover PR rationale with explicit `$seq` when needed, and decide what to act on, rebut, defer, or investigate. Trigger for `$review-adjudication`, review the review, adjudicate PR comments, are these comments relevant, which comments matter, or should we act on these comments. Not for implementing fixes, writing rebuttals only, or final merge closure.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

Related Guides

SKILL.md Source

# Review Adjudication

## Intent
Decide which PR review comments should change code, which should be rebutted, which are stale or out of scope, and which should be reframed as a governing invariant instead of handled as isolated local fixes.

This skill is **discriminative**, not deferential. A reviewer comment is an input claim, not an obligation.

## Output modes
- **Standard**: full adjudication contract.
- **Fast**: only decision buckets, invariant-level handoff, skew audit, and bottom line.

## Doctrine
Operate in **DISCRIMINATIVE**, **REBUTTAL-FIRST**, **INVARIANT-SEEKING**, **ANTI-RUBBER-STAMP**, and **EVIDENCE-WEIGHTED** mode.

- **DISCRIMINATIVE**: separate true concerns from irrelevant, stale, unsupported, preference-only, or misframed comments.
- **REBUTTAL-FIRST**: for each comment, construct the strongest no-change countercase before deciding to act.
- **INVARIANT-SEEKING**: look for the governing invariant behind repeated local comments; avoid fixing the same invariant piecemeal.
- **ANTI-RUBBER-STAMP**: do not let plausibility, politeness, reviewer authority, or ease of implementation become acceptance evidence.
- **EVIDENCE-WEIGHTED**: rank current artifacts above memories, memories above intuition, and direct proof above consensus.

## Contract
- Review comments are claims to test, not truths to obey.
- `act` is a conclusion, not the default.
- Current artifact state outranks reviewer intuition.
- Prefer current-session artifacts over memories. Use memories as secondary rationale support and provenance, not as the sole basis for acting.
- Distinguish the validity of the concern from the validity of the proposed fix.
- Separate relevance from actionability.
- Preserve raw comment identity; do not let summaries replace comment IDs, reviewers, excerpts, or locations.
- Tail-weight outputs for CLI use.
- Do not implement fixes here.

## Dependency
This skill expects `$seq` to be installed when PR rationale recovery is needed.
If `$seq` is unavailable, proceed only from current artifacts and mark PR rationale fields as `unknown` instead of inventing intent.

## Specialist mode
For large or disputed comment sets, optionally use these read-only specialists before final adjudication:
- `evidence_mapper`
- `soundness_auditor`
- `hazard_hunter`

Use them only to sharpen grounding, soundness, or hazard questions. They do not replace the adjudication judgment.

## `$seq` rationale recovery
Use `$seq` when the PR why is missing, disputed, stale, or likely to change adjudication.
Preferred ladder:
1. `plan-search`
2. `artifact-search`
3. `find-session` + `session-prompts`
4. `memory-map`
5. `memory-provenance`
6. `memory-history`

## Evidence ranking
1. Current diff, code, tests, CI, and local artifact state
2. Current-session artifact evidence
3. Prior-session artifact evidence
4. Memory-derived evidence
5. Reviewer intuition without artifact support

## PR Why Ledger
Summarize recovered rationale in compact fields:
- intended_change
- explicit_constraints
- non_goals
- governing_invariants
- evidence_source
- rationale_freshness
- staleness_source
- confidence

## Comment identity
Preserve raw review-comment identity. For every comment, carry:
- `comment_id`
- `reviewer`
- `short_excerpt`
- `file_or_thread`
- `disposition`
- `evidence_basis`
- `reply_stance`
- `handoff_action`

## Required checks per comment
For every comment, assess:
1. grounding
2. materiality
3. freshness
4. diagnosis
5. scope fit
6. proposed-fix validity
7. remediation posture
8. strongest no-change countercase
9. no-change countercase status
10. governing invariant, if any
11. minimum evidence to change mind

## Rebuttal-first pass
Before marking a comment `act`, write the strongest plausible no-change countercase.

A no-change countercase may be:
- the comment is unsupported by the current artifact state
- the comment is stale or superseded
- the comment is preference-only
- the comment is locally valid but out of scope for this PR
- the concern is valid but the proposed fix is wrong
- the requested local fix would hide the governing invariant
- the review asks for non-accretive broadening without proof
- the review assumes a contract this PR does not own
- the evidence is insufficient and the correct next step is validation only

Only mark `act` when artifact evidence defeats the no-change countercase.

If the countercase is not defeated, use `rebut`, `defer`, or `need-evidence`.

## Governing invariant pass
After individual adjudication, cluster comments that appear to point at the same underlying invariant, source-of-truth rule, ownership boundary, soundness obligation, or API contract.

When multiple comments share an invariant:
- do not treat them as unrelated local fixes
- name the governing invariant
- decide whether the correct handoff is an invariant-level change
- route to `$fixed-point-driver` when the comments are coupled or likely to reopen one another
- route to `$accretive-implementer` only when the invariant-level agenda is narrow and locally reviewable

## Relevance classes
Use exactly one per comment:
- material-relevant
- relevant-nonmaterial
- partially-relevant
- stale-or-superseded
- unsupported
- out-of-scope
- preference-only

## Disposition values
Use exactly one per comment:
- act
- rebut
- defer
- need-evidence

## No-change countercase status
Use exactly one per comment:
- defeated
- not-defeated
- unresolved

## Reply stance
For each comment, optionally record a `Reply Stance` to help later handoff to `$logophile`:
- acknowledge-and-fix
- acknowledge-and-bound
- rebut-with-evidence
- defer-with-scope
- ask-for-evidence

## Acceptance skew audit
Before finalizing, audit the distribution of dispositions.

If every substantive comment is marked `act`, treat that as a warning sign, not a victory. Add an **All-Action Justification** that explains why no comment was unsupported, stale, out of scope, preference-only, misdiagnosed, or better handled as validation-only.

If the review set has many locally valid comments, ask whether they share a governing invariant. Prefer one invariant-level handoff over many isolated local fixes when the same rule is recurring.

## Output contract

### Standard
- Review Basis
- PR Why Ledger
- Comment Ledger
- No-Change Countercases
- Governing Invariant Ledger
- Reply Stance Ledger
- Act On
- Rebut
- Defer / Out of Scope
- Need Evidence
- Invariant-Level Handoff
- Acceptance Skew Audit
- Handoff Agenda
- Adjudication Bottom Line

### Fast
- Act On
- Rebut
- Defer / Out of Scope
- Need Evidence
- Invariant-Level Handoff
- Acceptance Skew Audit
- Handoff Agenda
- Adjudication Bottom Line

## Handoff rules
- Route to `$accretive-implementer` when the accepted agenda is narrow, accretive, and locally reviewable.
- Route to `$fixed-point-driver` when accepted comments are coupled, contentious, invariant-level, or likely to reopen one another.
- Route to `$logophile` only for drafting replies, naming, or wording.
- If the correct response is no code change, do not create an implementation handoff.

## Hard rules
- Do not turn adjudication into implementation.
- Do not treat memory artifacts as infallible.
- Do not force action on preference-only, stale, unsupported, or out-of-scope comments.
- Do not mark a comment `act` merely because it is easy to fix.
- Do not mark a comment `act` merely because the reviewer is probably right.
- Do not accept a local fix when the real issue is a governing invariant.
- Do not hide uncertainty; say exactly what evidence is missing.

## Resources
- [seq-rationale-ladder.md](references/seq-rationale-ladder.md)
- [adjudication-ledger.md](references/adjudication-ledger.md)
- [criticality-rubric.md](references/criticality-rubric.md)
- [example-invocations.md](references/example-invocations.md)
- [common-routing-vocabulary.md](references/common-routing-vocabulary.md)

Related Skills

adversarial-reviewer

46
from tkersey/dotfiles

Use this skill for non-trivial code review where the job is to challenge the current artifact set, surface material defects, and produce an explicit change agenda. Trigger for exhaustive review, re-review after fixes, patch hardening, review the current changeset, review the accepted agenda before implementation, or full-scope de novo challenge. Use full-scope review rather than diff-only review when exhaustive confidence matters. Do not trigger for trivial wording feedback or final readiness decisions without a review question.

zig

46
from tkersey/dotfiles

Use when implementing, reviewing, migrating, linting, testing, fuzzing, profiling, optimizing, or hardening Zig 0.16.0 code: .zig files, build.zig/build.zig.zon, std.Io/process.Init migration, C interop, expert comptime/metaprogramming/reflection/codegen, allocator ownership, FFI boundaries, concurrency, dependencies, and measured performance work.

verification-closure

46
from tkersey/dotfiles

Use this skill to decide whether the current artifact set is actually ready by consuming a canonical Closure Handoff Packet, running the narrowest decisive checks, and assigning a grounded readiness state. Trigger for requests like verify this patch is ready, run closure gates, decide if the branch reached a material fixed point, or close the loop on the current artifact state. Do not trigger for broad redesign or de novo code review without a closure question.

ux-audit

46
from tkersey/dotfiles

Systematic UX evaluation using Nielsen heuristics and accessibility checks. Use when reviewing UI, "is this usable", improving user experience, or pre-launch.

universalist

46
from tkersey/dotfiles

Use when code smells point to a structural refactor that should ship: flag or state matrices, repeated boundary validation, shared-key agreement checks, branchy policy logic, or syntax mixed with execution. Default to one seam, one smallest honest construction, adapter-first staging, and one proof signal.

synesthesia

46
from tkersey/dotfiles

Cross-modal diagnostic and review workflow for software systems. Use this skill to understand, explain, compare, critique, debug, profile, review, or refactor code by mapping technical signals into sensory models, then translating those models back into precise engineering language. Best fits include architecture review, readability or maintainability assessment, strange or flaky behavior, performance bottlenecks, API or UX critique, onboarding explanations, and comparing implementations or designs by feel, friction, weight, rhythm, sharpness, smoothness, coupling, or complexity. Also use when prompts ask what a codebase, bug, logs, API, or system feels, sounds, or looks like, or ask to make it lighter, smoother, cleaner, tighter, quieter, or more coherent. Do not use for exact API syntax, compliance or legal interpretation, security sign-off, rote code edits, or terse factual tasks.

st

46
from tkersey/dotfiles

Manage persistent task plans in `.step/st-plan.jsonl`, with an explicit first-use choice between repo-committed storage and local-only ignore via `.git/info/exclude`, so state survives turns/sessions and can stay reviewable in git when desired. Use when users ask to "use $st", "resume the plan", "export/import plan state", "checkpoint milestones", "track dependencies/blocked work", "show ready next tasks", "keep shared TODO status on disk", "store backlog tasks on disk without loading them into `update_plan` yet", "select which durable tasks enter the mirrored plan", "map a `$select` plan into durable execution state", "prove `$st` works for implementation tracking", mirror the durable plan into Codex `update_plan` or OpenCode `TodoWrite`, or diagnose/repair `st-plan.jsonl` concerns (for example append-only vs mutable semantics, lock-file ignore policy, or seq/checkpoint integrity).

simplify-and-refactor-code-isomorphically

46
from tkersey/dotfiles

Shrink and unify code without changing behavior. Use when: simplify, refactor, reduce duplication, remove lines, extract helper, reuse component, DRY, collapse, better abstraction.

ship

46
from tkersey/dotfiles

Finalize work after validation: confirm a signal, capture proof in the PR description, and open a PR (no merge). Use when asked to run `$ship`, ship/finalize a branch, prepare or open a PR without merging, or publish validation proof before handoff.

seq

46
from tkersey/dotfiles

Mine Codex sessions JSONL (`~/.codex/sessions`) and file-based memories (`~/.codex/memories`) for explicit `$seq` and artifact-forensics questions, preferring `artifact-search`, then specialized follow-ups such as `skill-blocks`, `plan-search`, `session-prompts`, `session-tooling`, and `orchestration-concurrency`, then `query-diagnose`, and generic `query` only when needed. Opencode mining is explicit-only and requires a literal `opencode` cue in the request.

refine

46
from tkersey/dotfiles

Refine an existing Codex skill in place with minimal diffs, then validate with quick_validate. Trigger when asked to improve a skill's trigger description/frontmatter, workflow text, metadata, scripts/references/assets, or agents/openai.yaml; also for requests to iterate, refactor, rename, or fix a skill using usage/session-mining evidence (for example from $seq).

reduce

46
from tkersey/dotfiles

Deconstruct high-cost abstractions and recommend lower-level primitives that reduce tooling, indirection, and hidden steps. Use when requests ask for fewer layers (for example "too many layers", "remove this framework/plugin/DI", "ditch codegen/task runners", "replace with plain scripts/config/SQL"), or when prompts say "it feels over-engineered", "start simpler", or "reduce the size of the codebase" (analysis-only unless implementation is explicitly requested).