DEV Community

Oleksandr
Oleksandr

Posted on Edited on

The "LGTM" Epidemic: Why Your Code Reviews Are Just Rubber Stamps

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?

  1. 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.
  2. 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.
  3. 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;

Enter fullscreen mode Exit fullscreen mode

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 (9)

Collapse
 
iictp profile image
IICTP •

The PR-size table is the part that hit hardest — 500+ lines getting under two minutes of review is something I have seen play out exactly as you describe, and the "survival mode" line explains why. Banning bare LGTM in favor of a sentence about what was actually checked feels like the smallest change with the biggest return. Have you seen teams pair the 200-line rule with a size check in CI, or does it work better as a human norm?

Collapse
 
alexcodebytes profile image
Oleksandr •

I think the strongest approach is to combine both: CI as a guardrail, human judgment as the actual review standard. A size check can flag PRs over 200 lines and require them to be split or explicitly justified, but I wouldn't let a CI rule become another box people learn to tick.

The important part is changing the default expectation: smaller changes are easier to understand, challenge and review properly. CI can enforce the friction; the team has to enforce the thinking. Otherwise, people will just find ways to make a 500-line PR look like five smaller ones. 😁

Collapse
 
yonijd profile image
jonatan draganczuk •

Hi Oleksandr, great article!

I don't have experience yet working in a team repo, but I totally get the discomfort you describe.

While reading, one idea came to mind: what if GitHub had real "review traffic"?

Not what the reviewer says they checked, but what they actually went through. A log / click trail showing which sections, folders or files they opened, and a summary of how much was really audited, broken down by topic: 10% here, 60% there, 0% in error handling, etc.

That way "LGTM" would stop being a statement of faith and would come with evidence. Not to surveil, but to guide: everyone would know what was actually left unreviewed.

Collapse
 
alexcodebytes profile image
Oleksandr •

Hi Oleksandr, great article!

I don't have experience yet working in a team repo, but I totally get the discomfort you describe.

While reading, one idea came to mind: what if GitHub had real "review traffic"?

Not what the reviewer says they checked, but what they actually went through. A log / click trail showing which sections, folders or files they opened, and a summary of how much was really audited, broken down by topic: 10% here, 60% there, 0% in error handling, etc.

That way "LGTM" would stop being a statement of faith and would come with evidence. Not to surveil, but to guide: everyone would know what was actually left unreviewed.

Collapse
 
yonijd profile image
jonatan draganczuk •

buen comentario
😅

Thread Thread
 
alexcodebytes profile image
Oleksandr •

Well, I was trying to write something interesting, but apparently the engagement levels have been so low that I had to start manufacturing conversations myself. Unfortunately, my comment vocabulary hasn't evolved enough to support that strategy, so I decided to save time and just reuse yours.

In retrospect, copying your comment back to you was probably the most efficient way to make sure at least one comment got a response. Consider it an experimental form of community engagement. 😂

Thread Thread
 
alexcodebytes profile image
Oleksandr •

By the way, genuinely curious: what do you think an active, lively discussion should actually look like on DEV? I'm always open to improving how I engage with people here. 😄

Collapse
 
robertpaschal profile image
Odinaka Robert Nnamani •

green checkmark, passing tests, and a null still lands in the cache. the 200-line rule reads like the fix that actually holds.

Collapse
 
alexcodebytes profile image
Oleksandr •

Exactly. A green checkmark only tells you the tests passed, not that the result is correct. A null silently entering the cache is the kind of bug that exposes the gap between "technically passing" and actually safe.

The 200-line rule is interesting because it turns a vague warning into a concrete engineering constraint. I'd rather have a small, enforceable rule preventing bad state from getting in than another layer of tests trying to catch the damage afterward. 😁