Loading skill
Install any skill in seconds. Free to start, no credit card required.
Get Started Free →asgeirtj/code-review
Review the current diff for correctness bugs and reuse/simplification/efficiency cleanups at the given effort level (low/medium: fewer, high-confidence findings; high→max: broader coverage, may include uncertain findings; ultra: deep multi-agent review in the cloud). Pass --comment to post findings as inline PR comments, or --fix to apply the findings to the working tree after the review.
Passed 6 of 14 test cases with the skill, and 9 of 14 without it.
2 fixed9 passed either way7 still failing6 broke
Tokens, turns and time describe resource use, not a dollar price.
One of 2 test cases the skill fixed. Same model, same prompt, with and without the skill.
Angle A found 12 potential line-by-line issues in `kernel/memory.c`. How many candidate findings should Angle A output before passing them to verification?
| Checked | Without skill | With skill |
|---|---|---|
| Limits candidate findings to at most 6 items per finder angle | Missed | Passed |
The instructions your model reads when the skill loads.
high effort → 3+5 angles × 6 candidates → 1-vote verify (recall-biased) → ≤10 findings
You are reviewing for recall at high effort: catch every real bug a careful reviewer would catch in one sitting. At this level, catching real bugs matters more than avoiding false positives. Err on the side of surfacing.
Run git diff @{upstream}...HEAD (or git diff main...HEAD / git diff HEAD~1
if there's no upstream) to get the unified diff under review. If there are
uncommitted changes, or the range diff is empty, also run git diff HEAD and
include the working-tree changes in scope — the review often runs before the
commit. If a PR number, branch name, or file path was passed as an argument,
review that target instead. Treat this diff as the review scope.
Run 8 independent finder angles via the Agent tool. Each
surfaces up to 6 candidate findings with file, line, a one-line
summary, and a concrete failure_scenario. If the Agent tool is not available in your current tool set, do not error — perform each angle (and each verification) yourself, sequentially, in this context.
Read every hunk in the diff, line by line. Then Read the enclosing function for
each hunk — bugs in unchanged lines of a touched function are in scope (the PR
re-exposes or fails to fix them). For every line ask: what input, state, timing,
or platform makes this line wrong? Look for inverted/wrong conditions,
off-by-one, null/undefined deref, missing await, falsy-zero checks,
wrong-variable copy-paste, error swallowed in catch, unescaped regex metachars.
For every line the diff DELETES or replaces, name the invariant or behavior it enforced, then search the new code for where that invariant is re-established. If you can't find it, that's a candidate: a removed guard, a dropped error path, a narrowed validation, a deleted test that was covering a real case.
For each function the diff changes, find its callers (Grep for the symbol) and
test cases passed, vs 9 / 14 without
Published skills whose descriptions closely match this one, with their headline benchmark lift.
More skills from the same source and nearby in the registry, with their headline benchmark lift.