@@ · review craft @@

Author self-review: the cheapest code review you’re not doing

Othman Shareef · June 28, 2026 · 6 min read

The highest-leverage code review on your team costs nothing, blocks nobody, and is skipped daily: the author reading their own pull request, in the diff view, before requesting eyes. In the recent Hacker News thread on performative review, the top-voted observation was blunt: the self-review saves the company the most money, because cost scales with the distance between making a bug and finding it.

Why the diff view and not your editor

You’ve been staring at this code for days in the editor, so you see what you meant. The diff view shows what you did, in the exact frame your reviewer will see: the stray console.log, the formatting blast radius, the file that shouldn’t be there, the seven-line function that reads fine in context and cryptic in isolation. The medium switch is the point: it breaks author blindness the same way reading your writing aloud does.

The five-minute pass

  1. Sweep for accidents: debug output, commented-out blocks, unrelated formatting, files that don’t belong, secrets and config meant for local only.
  2. Read as a stranger: for each hunk, would someone without your week of context understand why this line changed? If not, comment it, rename it, or annotate the PR at that line yourself.
  3. Check the seams: error paths, edge inputs, the one place you said “I’ll come back to this.” You remember where the bodies are; the reviewer has to dig.
  4. Write the map: what changed, why, where the risk is, what you’re unsure about. “Start with applyBatch, the rest is wiring” is the most valuable sentence in any large PR.
  5. Pre-empt the split question: if the self-review took ages or the map has two unrelated stories, split it now, before a reviewer asks.

Self-review changes the economics, not just the defect count

Every issue the author catches converts a public round-trip (comment → notification → context switch → push → re-request) into a private keystroke. Authors who self-review consistently get reviewed faster; reviewers learn whose PRs respect their time, and an analysis of a popular r/ExperiencedDevs question about slow reviews reached the same conclusion: authors control more of their wait time than they think. The polish is also contagious in the good direction: a clean, mapped PR makes a lazy LGTM feel out of place.

In the agent era, self-review is the accountability line

When an AI wrote the change, “the author read it first” stops being hygiene and becomes the whole ballgame: it’s the moment a human takes ownership. That’s why we built pre-PR review into Pyor (our tool, free for individuals): read your agent’s diff on your own branch, leave yourself notes, fix before anything becomes a pull request. Your reviewers receive code a human has vouched for, and our AI-code checklist gets shorter every time someone does it.

Frequently asked questions

Isn’t self-review redundant if a reviewer will look anyway?

No. It changes what the reviewer spends attention on. Defects found by the author cost a keystroke; the same defect found by a reviewer costs a comment, a context switch, a re-push, and a re-review round-trip. Self-review moves the cheap defects to the cheap finder, leaving reviewer attention for design and correctness.

How long should a self-review take?

For a normal-sized PR, five to fifteen minutes. If self-reviewing takes an hour, that is the PR telling you it’s too large: split it before requesting review.

Does self-review work for AI-generated changes?

It’s even more important there. When an agent wrote the code, the author’s self-review is the first time any human has read it. Sending it to a reviewer unread outsources your accountability, and reviewers can tell.

← All posts