Skip to content
Skills Library
Programming · Review & audit

review-diff

/review-diff

Review a pull request, a patch or an agent's own work with findings ranked by risk instead of listed by line. Use when asked to review a diff, when a change touches data, auth, money, migrations or concurrency, when reviewing generated code that looks plausible, or when a review is turning into a style debate the linter should have settled.

Repository
HoNspot ↗
Licence
MIT
Last repository change
30.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 30.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Review a pull request, a patch or an agent's own work with findings ranked by risk instead of listed by line. Use when asked to review a diff, when a change touches data, auth, money, migrations or concurrency, when reviewing generated code that looks plausible, or when a review is turning into a style debate the linter should have settled.

Original author description

Review a pull request, a patch or an agent's own work with findings ranked by risk instead of listed by line. Use when asked to review a diff, when a change touches data, auth, money, migrations or concurrency, when reviewing generated code that looks plausible, or when a review is turning into a style debate the linter should have settled.

How it works

  1. When to use
  2. Ground rules
  3. Procedure
  4. Anti-patterns
  5. Definition of done
  6. Report format
Original SKILL.md headings · 101 lines, 850 words
SKILL.md preview
---
name: review-diff
description: Review a pull request, a patch or an agent's own work with findings ranked by risk instead of listed by line. Use when asked to review a diff, when a change touches data, auth, money, migrations or concurrency, when reviewing generated code that looks plausible, or when a review is turning into a style debate the linter should have settled.
license: MIT
---

# Review a diff

A review is a risk assessment, not a reading exercise. The question is never "is this code nice" but
"what can this change break, and would we find out before a user does".

## When to use

- Any pull request larger than a trivial rename.
- Changes touching data, authentication, payments, permissions, migrations, concurrency or public API.
- Reviewing code you (or an agent) generated — plausible code is exactly the code that slips through.
- A review with 40 comments about formatting and none about the transaction boundary.

## Ground rules

1. **Read the intent before the diff.** If the description does not state what changes and why, ask;
   a diff without intent cannot be judged, only re-litigated.
2. **Rank by consequence.** Blockers are things that break correctness, security, data or users. A
   naming preference is not in the top ten and often not in the review at all.
3. **Style is the linter's job.** If a machine can decide it, do not spend a human comment on it —
   configure the machine instead.
4. **Every finding needs a concrete failure scenario.** "This feels fragile" is not reviewable; "two
   concurrent requests both pass the check and both insert" is.
5. **Test the tests.** A new test that passes before the change proves nothing; say so.
6. **Approve honestly.** Approval means "I have seen what this can break". If you did not read part of
   it, say which part.

## Procedure

1. **Read the description, the linked issue, and the test changes first** — in that order. Then the
   source. Tests tell you the author's model of the change, which is where the misunderstanding shows.

2. **Identify the blast radius** and review in this order, which is roughly the order things hurt:

   | Area | Question |
   | --- | --- |
   | Data | Can this lose, corrupt or duplicate data? Is it reversible? |
   | Auth / permissions | Any path that skips a check? Any new trust in client input? |
   | Concurrency | Two of these at once — still correct? |
   | Error paths | What happens when the third-party call fails, times out or returns garbage? |
   | Migration / deploy | Can it ship while old code runs? Can it roll back? |
   | Public contract | Does this break a consumer who is not in this diff? |
   | Performance | New loop, query or payload on a hot path? |
   | Readability | Would the next person understand *why*, given a year? |

3. **Look for what is absent, not only what is present.** No error handling, no test for the new
   branch, no cleanup of the temporary file, no removal of the old path, no migration for the new
   column, no version bump.

4. **For generated code, run the plausibility checks**: does the imported symbol exist in the
   installed version; does the function signature match the call; does the test actually fail when the
   behaviour is removed; is the "happy path" the only path.

5. **Write findings with severity, evidence and a question** — `[blocker]`, `[major]`, `[minor]`,
   `[nit]`. Each with file:line, the scenario, and what you suggest. A question invites the answer
   that might prove you wrong, which is often the correct outcome.

6. **Summarise with a verdict**: approve, approve with follow-ups, or request changes, plus the one
   or two things that actually matter. Nobody reads 30 comments in order of appearance.

## Anti-patterns

| Tempting move | Why it is wrong |
| --- | --- |
| Commenting on 40 lines of formatting | Buries the one real finding; linters exist |
| "Can we make this more readable?" with no target | Unactionable; propose the shape you want |
| Approving because CI is green | CI checks what someone remembered to assert |
| Reviewing only the added lines | Deletions and unchanged callers are where breakage hides |
| Rewriting the PR in the comments | Review the change or propose your own, not both |
| Blocking on preference | Turns the review into a negotiation and teaches people to avoid review |

## Definition of done

- [ ] The blast-radius table was actually walked, in that order.
- [ ] Every finding has severity, location, failure scenario and a suggestion.
- [ ] New tests were checked for the "would it fail before the fix" property.
- [ ] The verdict is explicit, with the top one or two concerns named.
- [ ] Style findings were moved to a linter or dropped, not counted.
- [ ] Anything you did not review is named ("I did not evaluate the SQL plan").

## Report format

```
Verdict:  approve | approve with follow-ups | request changes

Blockers
  [file:line] <failure scenario in one sentence> → <suggestion>

Major
  ...

Minor / nits (optional, ignorable)
  ...

Tests:     <do they fail before the fix? what is not covered?>
Not reviewed: <parts you skipped, and why>
```

Severity definitions and the phrasing that keeps a review useful rather than adversarial are in
[references/severity.md](references/severity.md).
Files in this package (2)
  • SKILL.md 5 KB
  • references/severity.md 3 KB

Versions

RepositoryScoreLicence
This page · AmirAzy/HoNspot100MIT
se-uhd/ai-slop-skill100CC-BY-4.0
zanderadam/engy100MIT
jisuzzzz/haechi100MIT
RubenGlez/rubstack95MIT

Database snapshot: 13.11.2026 · package version 982316047b80 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100awesome-code-review
    Reviews a diff, patch or pull request for correctness, security and team standards, with severity-ranked findings. Use when asked to review a change or PR, or before merging.
  • 90code-review-and-quality
    Reviews a diff for correctness, risk, and missing evidence before merge. Use when preparing a change for commit, reviewing a pull request, reviewing AI-generated code, or deciding whether work is genuinely done.
  • 90review
    Review a pull request or diff for this repository against otari's project standards. Use when asked to review a PR, inspect a diff, or prepare review feedback.
  • 100code-review
    Reviews a change — a diff, a PR, a branch, or uncommitted work — for correctness, risk, and maintainability, and reports findings ranked by severity. Use this whenever the user asks you to review, check over, or give feedback on code they or someone else wrote, mentions a pull…
  • 90code-review
    Reviews a pull request against this repository's blocking criteria and reports only findings that name a failure mode. Use when reviewing a change, a pull request or a diff.
  • 90code-review
    Use when reviewing a bounded diff or pull request for actionable defects and regressions.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.