I stopped rubber-stamping AI PRs — here's the 10-minute review bar I use

Coding agents are great at producing diffs. They're less great at knowing when a "quick fix" quietly became a 30-file refactor with a new dependency, a renamed helper, and a test suite that only fails if you delete the function entirely.

I kept merging PRs that looked fine: confident summary, CI green, "improved robustness" in the description. Then: drive-by renames, lockfile churn I didn't ask for, auth-adjacent code I never mentally authored. The failure mode wasn't "AI bad" — it was rubber-stamping when review bandwidth couldn't keep up.

So I stopped relying on vibes. I forced a thin, explicit bar I can finish in about ten minutes. Shareable below — steal it, argue with it, add to it.

What "AI-aware" review actually means

• Tests that prove nothing. Happy-path asserts that pass even if the bug returns.
• Unclear rollback. You didn't write the mental model, so at 2am you don't know what to revert.

AI-aware review is not "distrust everything." It's matching human intent to agent delivery before you read every line like it's 2014.

The 10-minute review bar

Do these in order. If something fails early, stop — don't sink twenty minutes into a PR that should be split.

1. Restate the human intent (60 seconds)

Ignore the agent summary first. Write one sentence of what you (or the ticket author) asked for.

"Add rate limiting to the public signup endpoint."

If you can't state that without reading the diff, the PR description is already broken. Fix that before diving in.

2. File-list sanity check (90 seconds)

Scan the changed files against

3. Hotspots first, not alphabetical (2 minutes)

Jump to risky surfaces before cosmetic churn:

• Auth, sessions, permissions
• Payments / money paths
• Filesystem, shell, eval, templated commands
• New outbound network calls
• Secrets, tokens, .env patterns, anything that looks like a prompt or credential leaked into code or comments

You're not doing a full security audit in ten minutes. You're checking whether the agent wandered into dangerous neighborhoods without being asked.

4. Scope creep pass (90 seconds)

Look specifically for:

• Mass formatting or import reshuffles
• New dependencies you wouldn't have chosen
• "No behavior change" claims while types or public APIs moved
• Extra abstractions the ticket never named

Agents love helpfulness. Helpfulness without a plan is how a one-line bugfix becomes a mini rewrite.

5. Rollback story (60 seconds)

6. Test quality, not coverage theater (2 minutes)

Read the tests as adversarial:

• Would they fail if the original bug came back?
• Or do they only fail if the function is deleted?
• Are edge cases / failure paths covered for the risky bits?

Green CI with weak tests is how rubber-stamping feels safe.

7. Ownership & STOP conditions (60 seconds)

Before approve:

• Who owns the follow-up if this misbehaves?
• Was there a written plan for a multi-file change?
• Does this cross your personal STOP line?

STOP and ask (or split) when:

1. The agent touched a large file set with no plan written down.
2. Lockfile + app logic + infra landed in one "quick fix."
3. The summary says "no behavior change" but types, routes, or public APIs moved.
4. You can't explain the rollback path in one sentence.
5. Security-sensitive files changed and you only skimmed them.

Those are merge-blockers for me, not style nits.

Free checklist (copy/paste)

Use this as a PR comment template or a personal pre-merge gate:

AI PR — 10-minute bar

[ ] Human intent in one sentence (not the agent summary)
[ ] File list matches intent — no drive-by files
[ ] Hotspots checked: auth / payments / fs / shell / network / secrets
[ ] No surprise deps, renames, or formatting-only churn mixed in

## Optional: ask the agent for a blast-radius summary

Before you deep-read, paste something like this into the same agent (or a fresh chat with the diff):

text
Summarize this PR for a human reviewer:
1) Intended change in one sentence
2) Files that seem unrelated to that intent
3) Security-sensitive touchpoints
4) New dependencies or infra changes
5) Suggested split if the blast radius is too wide
Be skeptical. Prefer "I might be wrong" over polish.

Treat the answer as a map, not truth. You're still the reviewer.

## Habits that compound

The checklist works better if a few team habits exist upstream:

- **Commit or stash before long agent runs.** Easy revert beats archaeology.
- **Plan before multi-file edits.** A five-bullet plan in the PR beats a post-hoc apology.
- **PR description must separate** what the human wanted vs what the agent added. That single split kills a lot of summary theater.
- **Prefer small agent loops.** One intent per PR — agents can chain; you don't have to merge the chain as one blob.

It's just an explicit bar so juniors and seniors share the same merge / fix / split language.

## What this is not

- Not a claim that AI review tools replace humans.
- Not enterprise GRC, compliance theater, or a vendor pitch dressed as process.
- Not fabricated "bugs down X%" metrics. I don't have those, and you shouldn't trust posts that invent them.

I'm not anti-agent. I'm anti-rubber-stamp. Agents ship faster than thoughtful review capacity on small teams; a thin bar is how I keep both speed and sleep.

---

I packaged the checklist, Cursor-oriented rules, and review prompts I actually use into a small **AI Agent Code Review Kit** ($29): [https://chopragunji.gumroad.com/l/nxoboi](https://chopragunji.gumroad.com/l/nxoboi)

If you've got a better checklist item — or a war story about an agent drive-by — drop it in the comments. I'll steal the good ones.
[ ] Rollback story is clear (single revert or documented plan)
[ ] Tests would fail if the bug returned
[ ] STOP conditions clear? (big unplanned blast radius, mixed concerns, "no behavior change" lies)

Decision: merge / request changes / split PR
Notes:

Ask out loud: if this breaks at 2am, can I revert cleanly?

• Single coherent change set → usually yes
• Mixed refactors + feature + lockfile → often no
• Data migration or irreversible side effects → pause and demand a plan

If you didn't mentally author the change, the rollback question matters more, not less. that one sentence. Ask:

• Is every file necessary for the intent?
• Any renames, docs, configs, or lockfiles that weren't requested?
• App logic + infra + dependency bump in one "quick fix"?

Unrelated files → park them, ask for a split, or open a follow-up. Do not negotiate with yourself ("it's probably fine").
Classic code review still matters: correctness, readability, design. Agent PRs add a few failure modes that show up more often:

• Scope creep. Unrelated files, formatting-only churn, "while I was there" refactors.
• Surprise surface area. New deps, new network calls, shell/filesystem touch points you didn't request.
• Summary theater. The agent writes a polished narrative that doesn't match the file list.