Imagine this. It’s Tuesday morning. You’re sipping your coffee, feeling good. Then, the Slack notification hits: a P1 incident. Production is down.
You jump into the war room. Everyone is panicking. You dig through the logs, trace the stack trace, and finally find the culprit. It’s a stupidly simple bug. A missing null check. Or a wrong variable name.
Then comes the gut punch: you check the Git history. This code was merged two weeks ago. It had been approved by three senior engineers. The PR had a green checkmark. The tests passed.
How did this happen?
Because everyone just commented "LGTM" and moved on with their day.
We’ve all been there. I’ve been there. I’ve been the one who approved a 500-line PR in 45 seconds because I was rushing to my next meeting. But this "Looks Good To Me" culture is slowly rotting our codebases, and we need to talk about it.
The illusion of "Four Eyes"
The whole point of code review is to catch what the author missed. It’s supposed to be a safety net. But in reality, it often becomes a performative ritual.
Why do we do it?
- The Bottleneck Fear: Nobody wants to be the guy who blocks a release because of a minor naming convention. We feel pressured to approve quickly so the team can ship.
- Cognitive Overload: If you send me a PR with 40 changed files, my brain just shuts down. I can’t review that properly, so I just scan it and hit approve, hoping for the best.
- The "It Compiles" Mentality: If the CI/CD pipeline is green and the tests pass, we assume it works. We forget that tests only prove the code does what the author thought it should do — not what it actually needs to do.
The math of the "Rubber Stamp"
Let's look at the uncomfortable reality of how we actually review code versus how we think we do:
| PR Size (Lines of Code) | Average Review Time | Actual Review Quality |
|---|---|---|
| 1 - 50 lines | 15 - 30 mins | High. Real questions are asked. |
| 50 - 200 lines | 10 - 15 mins | Medium. Major logic is checked, edge cases ignored. |
| 200 - 500 lines | 5 - 8 mins | Low. Skimming for typos. |
| 500+ lines | < 2 mins | LGTM. (Please just let me close this tab). |
When a PR gets too big, the reviewer’s brain switches from "analytical" to "survival mode". We stop looking for logic errors and start looking for reasons to just approve it and move on.
A code review is not a proofreading session
Here is what a typical "LGTM" review looks like in the wild:
+ // Adding a new caching layer for user profiles
+ const user = await getUserFromCache(userId);
+ if (user) {
+ return user;
+ }
+ // Fallback to DB
+ const dbUser = await fetchFromDB(userId);
+ await setUserInCache(userId, dbUser);
+ return dbUser;
The Reviewer: "LGTM 👍" (Approved).
What the reviewer missed: dbUser could be null if the user doesn't exist, which means we are caching null and returning it, causing a silent failure on the frontend three calls later.
The author had all the context in their head, so it looked fine to them. The reviewer just glanced at the syntax, saw that it "makes sense", and approved it.
How do we fix the "LGTM" epidemic?
I don't think the answer is "just be more careful." That's like telling someone to "just be happier." We need structural changes.
1. Ban the LGTM comment.
Seriously. Make it a team rule. If you are approving a PR, you must leave a comment explaining what you checked. Even if it’s just: "Checked the DB calls and the error handling looks correct. Tested locally, works as expected." This forces the reviewer's brain to actually engage with the code, even for a few seconds.
2. Enforce the 200-line rule.
If a PR is over 200 lines of actual logic (excluding generated files, lockfiles, etc.), it gets rejected automatically. It must be split. Reviewing smaller chunks is the only way to maintain quality without burning out your seniors.
3. Ask a real question.
The best code reviews are the ones where the reviewer asks, "Why did you choose this approach instead of X?" or "What happens if this API call times out?" If you can't think of a single question to ask about a PR, it probably means you didn't read it carefully enough.
4. The "Rubber Duck" review.
Before you assign a reviewer, explain your own PR in the comments. Write a short paragraph: "Hey, this PR does X. The tricky part was Y, so I handled it by doing Z. Please pay special attention to the database transaction on line 45." This guides the reviewer exactly where to look and prevents them from getting lost.
It’s about culture, not tools
You can have the fanciest CI/CD pipeline, the most strict linters, and the best AI code review bots (yes, even Claude or Copilot). But if your human reviewers are just acting as a human LGTM button, your codebase is a ticking time bomb.
Code reviews are not a gate to pass; they are a conversation about the code. And a conversation requires more than just saying "Looks good."
Let's discuss
I'm curious how other teams handle this.
Do you have a team culture where it’s acceptable to block a PR for a whole day just to ask questions?
What is your "hard limit" for PR size before you hit that reject button?
Have you ever caught a catastrophic bug in a review that the CI completely missed? What was it?
I'd love to hear your war stories. Because at the end of the day, the best code review is the one that prevents you from getting that 3 AM PagerDuty alert.
Top comments (0)