How to Review AI-Generated Code: Checklist
On this page
Learning Objective
Review agent-produced changes efficiently and rigorously: know the characteristic mistakes AI code makes, read diffs in an effective order, use the agent to help review itself without trusting it blindly, and keep changes small enough to review well.
Concept Explanation
When agents write more of the code, review becomes the main place where human judgment enters, and the bottleneck shifts from writing to reading. Two forces make this hard. AI-generated code looks clean and confident, which lowers reviewers' guard. And agents can produce large diffs quickly, which invites skimming. The 2025 Stack Overflow survey captured the result: the most common frustration developers reported with AI was solutions that are almost right, but not quite.
AI-generated code has characteristic failure modes worth checking every time. Hallucinated or outdated APIs: functions, options or packages that do not exist or no longer behave as assumed. Plausible but wrong logic: off-by-one errors, inverted conditions, time zone and currency mistakes, which tests may not cover. Weakened verification: modified or skipped tests, assertions loosened, or mocks so broad that the test proves nothing. Error handling that hides problems: catch-all blocks, swallowed exceptions, silent defaults. Scope creep: unrelated reformatting, renamed variables, opportunistic refactors that bloat the diff. Duplication: a new helper written next to an existing one that does the same thing. Security gaps: missing authorization checks, injection, secrets in logs, overly permissive configuration.
Read in an order that finds these quickly. Start with the summary and the diff statistics: does the size match the task, and are unexpected files touched? Read the tests next, because they tell you what the change claims to do; check that they would fail without the change and that none were weakened. Then read the core logic, then the edges: error handling, configuration, migrations, dependency changes. Run the code when behavior matters, rather than reasoning only from the diff.
Agents can help review, used carefully. Asking the same session to review its own work tends to confirm it. A fresh session, a different model, or a dedicated review subagent with instructions to look for specific failure modes finds more. Automated review tools catch some classes of bugs. None replaces a person who understands what the change is for; treat AI review as a first pass that reduces your load, not as approval.
The single most effective practice is keeping changes small. Reviewers find a much higher share of defects in small changes than in large ones, and an agent will happily produce a change too large to review. Split work into steps (Day 8), and send back diffs that mix unrelated changes.
| Failure mode | What to look for | Quick check |
|---|---|---|
| Hallucinated API | Calls to functions or options you do not recognize | Check the library docs or type definitions |
| Weakened tests | Changed assertions, skip markers, deleted tests | git diff on test files |
| Hidden errors | Broad catch blocks, silent defaults | Search the diff for catch and except |
| Scope creep | Reformatting, unrelated renames | Diff stat, files outside the task |
| Duplication | New helper similar to an existing one | Search for similar function names |
| Security gaps | Missing auth checks, injection, secrets in logs | Review every new endpoint and query |
Worked Example: A Pre-Review Script for Agent Diffs
This script runs before human review and flags the patterns most associated with AI-generated mistakes, so the reviewer starts with the riskiest parts.
#!/usr/bin/env bash
# review-flags.sh: highlight risky patterns in the current branch versus main.
set -uo pipefail
BASE="${1:-main}"
echo "== Size"; git diff --stat "$BASE"...HEAD | tail -1
echo "== Files touched"; git diff --name-only "$BASE"...HEAD
echo "== Test files changed (check none were weakened)"
git diff --name-only "$BASE"...HEAD | grep -E '(test|spec)\.' || echo " none"
echo "== Skips and focus markers added"
git diff "$BASE"...HEAD | grep -E '^\+.*(\.skip\(|@pytest\.mark\.skip|xit\(|\.only\()' || echo " none"
echo "== Broad exception handling added"
git diff "$BASE"...HEAD | grep -E '^\+.*(except Exception|except:|catch \(\w*\) \{\s*\}|catch \{)' || echo " none"
echo "== New dependencies"
git diff "$BASE"...HEAD -- package.json requirements*.txt pyproject.toml | grep -E '^\+\s*"?[a-z@]' || echo " none"
echo "== Possible secrets"
git diff "$BASE"...HEAD | grep -iE '^\+.*(api[_-]?key|secret|password|token)\s*[:=]' || echo " none"None of these flags proves a problem, and an empty report does not prove correctness. They direct attention: a reviewer who sees a modified test file and a new broad catch block knows where to look first.
Real-World Examples
- In the 2025 Stack Overflow Developer Survey, 66 percent of developers named "AI solutions that are almost right, but not quite" as their biggest frustration with AI tools, and 45 percent said debugging AI-generated code was more time-consuming.
- SmartBear's widely cited study of code review at Cisco found that reviewers' defect detection fell sharply when reviewing more than about 200 to 400 lines at a time, a finding that matters more when agents can generate large diffs in minutes.
Review Questions & Answers
The tests state what the change claims to do. Checking them first reveals whether the claim matches the task and whether any tests were weakened, skipped or deleted to make the change pass.
The session shares the reasoning and assumptions that produced the code, so it tends to confirm its own choices. A fresh session, another model or a dedicated reviewer with specific checks finds more problems.
Hallucinated or outdated APIs, plausible but wrong logic, weakened or skipped tests, swallowed errors, scope creep, duplicated helpers and missing security checks.
Reviewers detect a much smaller share of defects in large changes. Agents can produce large diffs quickly, so splitting work into small changes is essential to keep review effective.