lockstep
4 min readNaman Jain

Code review checklist (with additions for AI-written code)

A practical code review checklist based on Google's engineering practices: design, functionality, tests, naming, comments, plus checks for AI-written code.

A pull request gets two approvals in eight minutes. A week later, someone finds it duplicated a helper that already existed, added a dependency for one function, and changed a public response shape customers rely on. Both reviewers looked. Neither had a list of what to look for.

This checklist follows Google's What to look for in a code review and its review standard, checked on 16 November 2026, with additions for code written by AI agents.

The standard

Google's guide makes one principle senior to the rest: approve a change once it definitely improves the overall code health of the system, even if it isn't perfect. There's no perfect code, only better code. Optional suggestions are fine; label them so they don't block.

The checklist

Copy into your PR template or review notes:

## Design
- [ ] The change fits the system's design and belongs in this codebase
- [ ] It isn't more complex than it needs to be
- [ ] It doesn't build for needs we don't have yet

## Functionality
- [ ] It does what the author intended, and that's good for users
- [ ] Edge cases and errors are handled
- [ ] UI changes look and behave sensibly
- [ ] Concurrency, if any, is safe

## Tests
- [ ] New logic has tests
- [ ] Tests would fail if the code broke
- [ ] Tests are readable and not overly coupled to implementation

## Readability
- [ ] Names are clear
- [ ] Comments explain why, not what
- [ ] Docs are updated where behavior changed
- [ ] Follows the style guide

## AI-written code
- [ ] No duplicated logic; existing helpers are reused
- [ ] No new dependencies without approval
- [ ] The author can explain every part of it
- [ ] Consistent with recorded team decisions

What each section is for

Design. The most important check, and the one automated tools miss. Does this belong here? Does it fit how the system works?

Complexity. Google's guide asks whether a reader can understand it quickly and whether the author built anything they might need in the future but don't need now. Speculative generality is a common source of debt.

Tests. Present, correct, and useful. Tests that can't fail aren't tests.

Naming and comments. Good names make most comments unnecessary. Comments should explain why something is done, since the code shows what.

Every line, in context. Google says to review every line you were asked to review, and to look at the whole file or system, not just the diff.

Compliment good work. Google's guide includes it, and it matters for a team that reviews each other every day.

Additions for AI-written code

When an agent wrote the change, add four checks:

  • Duplication. Agents often write a new helper instead of finding the existing one. Search for similar functions.
  • New dependencies. A package added for one function is debt. Ask whether the standard library or an existing dependency covers it.
  • Explainability. If the author can't explain a part, it isn't ready. Simon Willison's rule: don't commit code you couldn't explain to someone else.
  • Team decisions. The code may be clean and still contradict a decision made outside the repository, such as keeping an old API format or not using a library. Reviewers who weren't part of that decision won't catch it.

More in AI code review best practices and technical debt from AI coding.

Making the checklist stick

  • Put it in the PR template, so authors self-check before review.
  • Keep it short. A checklist nobody reads is decoration.
  • Automate what you can. Linting, formatting, and type checks shouldn't need a human.
  • Small PRs. The checklist works on 200 lines, not 2,000.

Where Lockstep fits

The last check, consistency with team decisions, is the hardest to do by hand. Lockstep captures decisions from PRDs, Slack, and pull requests, routes each to its owner for approval, and briefs Claude Code sessions on the ones that apply before code is written. Its checks are advisory: they flag likely conflicts for a reviewer to look at.

See how it works.

Sources checked 16 November 2026

For the done criteria behind a review, see definition of done vs acceptance criteria. For review in CI, see Claude Code GitHub Actions. For reviewing API changes, see API design best practices. For routing reviews to the right people, see CODEOWNERS file examples.

Frequently asked questions

What should a code review check?
Google's engineering practices list: the code is well-designed, the functionality is good for users, UI changes are sensible, concurrency is safe, it isn't more complex than needed, it doesn't build things not yet needed, it has well-designed tests, names are clear, comments explain why, documentation is updated, and it follows the style guide.
When should a reviewer approve a change?
Google's standard is to approve once a change definitely improves the overall code health of the system, even if it isn't perfect. Reviewers can leave optional suggestions, labeled as such, without blocking.
What extra checks does AI-written code need?
Look for duplicated logic the agent wrote instead of reusing existing code, new dependencies nobody approved, code the author can't explain, and changes that contradict decisions the team made outside the code.
Should code review be done line by line?
Google's guide says to review every line you've been asked to review, while also looking at the change in the context of the whole file and system.
How long should a code review take?
Small changes review faster and better. Keep pull requests small enough to read in one sitting; for large changes, ask the author to split them.

Keep reading