review-code

Reviews non-trivial pull requests to find correctness bugs missed by prior review rounds.

Updated May 19, 2026
One-click install
npx skills add https://github.com/kmosher/claude-plugins --skill review-code-kmosher
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: review-code
Source: https://github.com/kmosher/claude-plugins/tree/main/plugins/kmosher-review/skills/review-code
Command: npx skills add https://github.com/kmosher/claude-plugins --skill review-code-kmosher

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Standard code reviews often miss real bugs because reviewers grep instead of reading implementations, trust test names instead of assertions, and re-raise already-settled concerns. This Skill forces a structured adversarial review that surfaces logic errors, ignored errors, schema mismatches, and tests that pass with a buggy implementation. ## Core Features & Use Cases - Nine adversarial techniques: required upstream reading, CLAUDE.md compliance audit, adjacent comment checks, per-call traces, adversarial test critique, failure-mode enumeration, concrete walkthroughs, negative-space audit, and reference resolution. - Anti-pattern checklist: catches ignored errors, mutation of caller state, concurrency hazards, and tests that mock the failure mode they test, with a Go-specific guidance file loaded only for Go diffs. - Structured output: findings returned as JSONL with severity (P0–P3), category, file:line references, and honest confidence calibration. - Use Case: A PR with ten prior review rounds is about to merge. Run this Skill to trace every function call against its actual implementation, catching a predicate bug where an ignored error from a runtime resolver misclassifies fields. ## Quick Start Ask the AI to run an adversarial correctness review of the current branch or a specific PR before merging.

Frequently Asked Questions about review-code

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I find bugs that previous code reviews missed?▼

Run an adversarial review that forces nine explicit techniques: required upstream reading, per-call traces, adversarial test critique, failure-mode enumeration, concrete walkthroughs, and reference resolution. Each technique requires written reasoning, not just a claim it was done.

What is adversarial code review for pull requests?▼

Adversarial code review assumes prior reviewers missed something and systematically hunts for it. It reads function bodies instead of trusting names, asks whether each test would catch a deliberately buggy implementation, and enumerates failure modes the change does not cover.

When should I use this instead of a normal code review?▼

Use it for final review before merging non-trivial PRs, especially ones with several prior review rounds or lifecycle and schema changes. Skip it for trivial refactors, renames, or first-pass reviews of fresh PRs.

Does this review skill support languages other than Go?▼

Yes. The core checklist and nine techniques are language-agnostic. A separate Go guidance file with Go-specific anti-patterns like type assertions and defer-in-loop loads only when the diff touches Go files.

How are review findings reported and prioritized?▼

Findings are returned as JSONL with severity from P0 (data loss or panic) to P3 (test quality), a category such as correctness or concurrency, a file:line reference, and a confidence level of low, medium, or high based on how thoroughly the failure path was traced.