Code Review vs. Verification
Last updated: 2026-11-045 min read
Sources checked 2026-11-04no external figures
Code review is human judgment about quality – design, readability, fit. Verification compares task-relative evidence with written scope and acceptance criteria. Static analysis, tests, and validation add different observations. None guarantees correctness, security, or compliance, and none makes the business, legal, or release approval.
Contents
What review is for – and what it was never built to do
Code review earns its place three ways: it transfers knowledge, it catches design problems a compiler never will, and it keeps a second pair of eyes on everything that ships. All three assume something quietly: that reading capacity roughly matches writing speed. For a long time it did: a reviewer reconstructed the author’s intent from the diff, the commit message, and a shared context, and usually got it right.
That reconstruction step is the part that breaks with AI. The author of the change is a model whose “intent” lived in a prompt that is gone by review time. A May 2026 study of how humans actually review AI-generated pull requests on GitHub, built on the AIDev dataset and accepted to EASE 2026, found that most of them received no review at all, and that the reviewed ones were mostly reviewed by AI agents, with humans steering the agents rather than evaluating the code. It is one dataset and useful evidence rather than a universal law. Written intent can give reviewers a clearer reference point, but the study does not prove that review fails or that verification replaces it.
Evidence, not a universal throughput law
The 2026 Sonar vendor survey is about self-described review behavior and perceptions. It is dated and relevant, but it is not production telemetry and does not establish a causal throughput rule.
NIST’s February 2022 Secure Software Development Framework distinguishes code review, where a person looks at the code, from code analysis, where tools find the issues, inside one practice (PW.7), and treats testing executable code as a practice of its own (PW.8). That is the durable point: combine evidence sources according to risk and record their coverage and omissions. Missing or stale evidence can create verification debt.
Review and verification, side by side
| Dimension | Code review | Verification |
|---|---|---|
| Core question | Is this good code? Does it fit our system? | What do the selected checks show against stated criteria? |
| Reference point | Reviewer's experience and memory of the context. | Written intent: goal, boundaries, acceptance criteria. |
| Nature | Judgment, irreplaceably human. | Comparison, systematic where criteria and evidence permit. |
| Scales with AI volume? | Depends on change size, risk, tooling, and reviewer capacity. | Depends on criteria, check coverage, tooling, and evidence quality. |
| Output | Comments, review opinion, and possibly a designated approval. | Recorded verification evidence, including failures and omissions; not business or legal approval. |
| Failure mode when overloaded | Rubber-stamping: approval without scrutiny. | Spec theater: documents nobody compares against. |
Not a replacement: the working division of labor
Treating either practice as a universal replacement is the wrong abstraction. Removing humans from the loop discards the judgment layer that no check can provide, and it ignores what review does for the team’s shared understanding. The division that works in practice:
- Define intent and select checks. A spec-vs-implementation check against written intent, plus risk-appropriate static analysis, tests, and other evidence with recorded limits.
- Review with evidence in view. The reviewer receives the diff plus recorded findings and outcomes, challenges their coverage, and may request another iteration.
- Human gate last.A designated person accepts or rejects under the team’s decision rights. Review opinion and verification evidence inform that business or release decision; neither makes it automatically.
The reviewer’s job changes from “reconstruct what this was supposed to do” to “judge whether it is good”, which is the job review was always best at. This split is the heart of the broader verification loop.
As a concrete process with steps and roles, this division is described in the two-pass review workflow.
Limits and typical mistakes
- Dropping review entirely. Verification checks stated intent; it has no opinion on whether the intent was wise. That judgment is the reviewer’s.
- Treating AI review tools as verification. An AI reviewer without a written intent is another opinion, not a check. Useful for the mechanical backlog, not a reference point.
- Keeping review time constant and calling it progress. If AI PRs get the same minutes as human PRs despite subtler failure modes, the process is optimizing for throughput over certainty. Measure both.
Where Reality Graph fits
Reality Graph records one task-relative evidence layer: written task intent before the run, boundary and criteria checks after it, selected validation outcomes and omissions, and an evidence report the reviewer reads before judging. What those checks add up to, one value per run rather than a patchwork of per-tool statuses, follows the rules under how the outcome is computed. It does not prove correctness, security, or compliance and does not make business, legal, or release approval. Your review process and decision rights stay yours.
Verification can contribute
- Scope and boundary checks against written intent
- Criteria-by-criteria pass/fail with a recorded outcome
- Validation runs the generating model did not author
- Task-relative evidence a reviewer can challenge and use
Review keeps
- Architecture and trade-off judgment
- Readability, naming, and system fit
- Knowledge transfer across the team
- The final accept/reject decision, always human
If these boundaries fit how your team wants to ship:
FAQ
- What is the difference between code review and verification?
- Code review records a reviewer’s judgment about a change. Static analysis produces rule-based findings; tests produce observations for selected scenarios; task-relative verification compares available evidence with stated scope and acceptance criteria. Validation asks whether the result serves its intended use. These outputs are complementary and bounded by their coverage.
- Does verification replace code review?
- No. A verification result can give a reviewer recorded evidence about selected criteria, but it cannot supply architecture judgment, uncover every defect, or make a release, business, legal, security, or compliance approval. The useful sequence is context-dependent and often iterative.
- Does AI-generated code require one universal review workflow?
- No. Risk, change size, system criticality, team structure, and available checks determine the workflow. Sonar's 2026 vendor survey covers developer perceptions, not production telemetry; a May 2026 study of AI-generated pull requests on GitHub found that most received no review and that those reviewed were mostly reviewed by AI agents. Both motivate explicit evidence, not a universal sequencing rule.
- AI review tools already exist – doesn't that solve it?
- They can add findings, summaries, or suggestions. Those outputs remain tool observations whose value depends on context, rules, model behavior, and reviewer follow-up. They are not automatically verification evidence or approval, and they do not replace written intent, tests, static analysis, or human judgment.
- What does this mean for a small team?
- Start with written intent and risk-appropriate checks. Record static-analysis findings, test results, omitted checks, and the task-relative verification outcome next to the diff. A reviewer can use that evidence, challenge it, request more work, and make the team’s designated approval decision.
- How do we start without rebuilding our process?
- Pilot one change with explicit scope, acceptance criteria, selected checks, recorded omissions, and a named human decision right. Compare the evidence with the diff during review. Treat the result as an example to measure, not proof that the same workflow fits every repository.
Keep reading
Sources
- NIST SP 800-218, Secure Software Development Framework v1.1 (February 2022, final): code review and code analysis as two methods of practice PW.7, executable-code testing as practice PW.8; v1.2 has been an initial public draft since 17 December 2025; checked 4 November 2026
- Sonar – State of Code Developer Survey (press release, January 2026): developer perceptions of AI code and review, self-reported and not production telemetry; checked 4 November 2026
- Duma, Wróblewski, Bobińska, Winiarska, Przymus – These Aren't the Reviews You're Looking For: How Humans Review AI-Generated Pull Requests (arXiv 2605.02273, 4 May 2026, accepted to EASE 2026; AIDev dataset); checked 4 November 2026