Why I Still Manually Review Every Pull Request (Even My Own)
AI-assisted everything is the current discourse. I still read every diff, line by line, before it merges — including the code I wrote myself. Here's why that habit hasn't gone away, and what it's caught.
The current discourse says AI handles most of the coding grind now — generate it, run the tests, ship it. I use AI tools constantly, for real work, and I'm not making a case against them. But I still read every pull request line by line before it merges, including the ones I wrote myself, and I don't think that habit is going away anytime soon. Here's why.
The Tests Passing Isn't the Same as the Code Being Right
Automated checks — tests, linters, type checkers — catch a specific, narrow category of problem: does the code do what the tests say it should do, and is it syntactically and stylistically consistent. What they don't catch: does the code do the right thing, in a way that fits how the rest of the system actually works, without a subtle assumption that's wrong in a case the tests didn't think to cover.
A pull request that passes every automated check can still be wrong in a way that only becomes visible when a human reads it and asks "wait, why is this touching that table" or "this assumes the input is always sorted — is that actually guaranteed anywhere?" Those aren't questions a test suite asks. They're questions a person asks by reading the actual change and thinking about what it means.
What Manual Review Has Actually Caught
Scope creep that automated checks have no opinion on. A change that does what it says but also quietly does three other things nobody asked for, buried in the same diff. Tests pass because the extra changes happen to work. Nobody flags it because nothing's technically broken. Reading the whole diff is the only way to catch "this PR is bigger than its description," and that mismatch is worth catching before it merges, not after.
Assumptions that are locally correct and globally wrong. Code that works fine for the specific case being tested but breaks an invariant somewhere else in the system — a function that assumes it's always called after another function runs, when that ordering isn't actually guaranteed everywhere. This is the exact category of bug that's hardest for any automated tool to catch, because it requires holding the whole system in your head, not just the change in isolation.
My own blind spots, on my own code. This is the part that surprises people most: I review my own pull requests the same way, as a genuinely separate step from writing the code, sometimes literally the next day. Code you just wrote is the code you're least able to see clearly, because you're still holding the intent in your head instead of reading what's actually on the screen. A day of distance, or even just switching from "writing" mode to "reading" mode deliberately, catches things that reviewing your own code in the same sitting you wrote it never does.
Where AI Tools Actually Fit In
I'm not reviewing manually because I distrust AI-generated code specifically more than human-written code — I review everything the same way, regardless of how it was written. AI tools are genuinely useful for generating a first draft, exploring an approach, or catching the boring stuff (formatting, obvious typos, missing null checks). What they're not a substitute for is the step where a person reads the actual change and asks whether it's the right change, not just a working one.
The honest version of this: AI tools have changed what I spend review time on. I spend less time catching typos and formatting issues (the tools catch those before I ever see the diff) and more time on the actual judgment questions — does this fit the system, does this do the right thing, is this the right scope. The review habit didn't go away. What I'm using it for shifted.
The Actual Takeaway
Automated checks answer "does this work." Manual review answers "is this right." Those are different questions, and no amount of AI-assisted tooling has actually collapsed them into one yet. Until it does, reading the diff — including your own — stays on the list.