Skip to content
Code Review cover
Code QualityFree · MIT

Code Review

Two passes on a diff — correctness bugs first, real cleanups second, zero style nitpicks. Every blocker carries a concrete failure scenario.

v1.0.0 · ~590 tokens · ⬇ 0 · Updated July 6, 2026

What it does

Reviews the change (not the repo) in two passes: correctness (off-by-one, edge cases, error paths, contracts, regressions) then reuse/simplicity. Severity as BLOCKER/SHOULD/NIT, every finding anchored to file:line, every blocker with a concrete failure scenario. Skips formatting — the linter owns that.

Example uses

Review a risky pull request

A high-stakes diff touches billing logic and you want the bugs found before merge.

Review the diff on this branch against main — it changes how we calculate proration for subscription upgrades. Correctness pass first: edge cases around zero-day periods, timezone boundaries, and unpaid invoices. Give me BLOCKER/SHOULD/NIT with file:line anchors and a concrete failure scenario for every blocker.

Check changes before merging

You just finished a feature and want a correctness check on your working diff.

I just finished the retry logic in src/lib/queue.ts. Review my working diff for correctness: swallowed errors, missing awaits, and whether callers of processJob still get the return shape they expect. Skip style — the linter owns that.

Audit error paths in a PR

You're not sure the new error handling actually survives partial failures.

Review this PR that adds error handling to our S3 upload pipeline. Focus on the error paths: what happens on a partial failure halfway through a multi-file batch, whether anything is silently swallowed, and whether the cleanup actually runs. Anchor every finding to file:line.

Install

# 1. Create the skill folder in your Claude setup
mkdir -p ~/.claude/skills/code-reviewer

# 2. Download SKILL.md into it (or move the file you just downloaded)
#    → ~/.claude/skills/code-reviewer/SKILL.md

# 3. Claude Code auto-discovers it on next launch.

Inside the skill

SKILL.md
---
name: code-reviewer
description: Review a diff for correctness bugs and cleanup opportunities, with severity and file:line anchors. Use on a pull request, a working diff, or when asked to "review this code", "check my changes". Two passes — correctness first, then reuse/simplicity — never style nitpicks.
---

# Code Review

Review the CHANGE, not the whole repo. Find bugs that will actually bite, then genuine
cleanups. Anchor every finding to a location. Skip subjective style — the linter owns that.

## Pass 1 — Correctness (the one that matters)

For each changed hunk, ask:
- **Does it do what it claims?** Off-by-one, inverted condition, wrong operator, wrong variable.
- **Edge cases**: null/undefined/empty, zero, negative, very large, unicode, concurrent access.
- **Error paths**: what happens when the call fails? Swallowed error? Partial write? No rollback?
- **Contracts**: return shape matches callers; async actually awaited; resources closed.
- **Regressions**: does this break an existing caller or assumption? Check the call sites.
- **Security**: user input reaching a query/shell/HTML sink (hand off to the
  `security-review-code` skill if deep).

## Pass 2 — Reuse & simplicity (only real wins)

- Duplicate of an existing helper? Point to the helper.
- Dead code, unreachable branch, unused variable introduced by the change.
- Needless complexity: a loop that's a `map`, nesting that's an early return, a flag that's two functions.
Only raise these if they're clear improvements — don't invent work.

## Severity

- **BLOCKER**: will produce wrong results, data loss, crash, or a vuln. Must fix before merge.
- **SHOULD**: real bug in an edge case, or a meaningful cleanup. Fix or consciously accept.
- **NIT**: minor; optional. Keep these rare — a review that's 90% nits gets ignored.

## Output

```
REVIEW — <target> (<n> files)
BLOCKER / SHOULD / NIT
  [severity] <file:line> — <what's wrong> → <fix>
      Fails when: <concrete input/state → wrong outcome>   (for bugs)
Looks good: <what's solid — so the author knows it was actually read>
```

## Rules

- Every BLOCKER needs a concrete failure scenario. "This looks risky" is not a finding.
- Don't restate the diff. Don't ask for changes the diff already made. Don't nitpick formatting.
- Review the code that's there, not the code you'd have written. Different ≠ wrong.

Changelog

  • v1.0.02026-07-03Initial clean-room write.

Frequently asked questions

Is Code Review free?

Yes. Code Review is free to download and MIT-licensed.

Where do I install Code Review?

Place the SKILL.md file in ~/.claude/skills/code-reviewer/ and Claude Code auto-discovers it on next launch.

How many tokens does Code Review use?

About 590 tokens — it is designed to be token-lean.

Anthony M. — Founder & Lead Reviewer
Anthony M.Verified Builder

We're developers and SaaS builders who use these tools daily in production. Every review comes from hands-on experience building real products — DealPropFirm, ThePlanetIndicator, PropFirmsCodes, and many more. We don't just review tools — we build and ship with them every day.

Written and tested by developers who build with these tools daily.