# How to Kill the Code Review — Ankit Jain, Aviator

## Executive summary

The traditional code review process is failing due to increasing code churn and reliance on AI agents, leading reviewers to only skim results. The speaker argues that code review must shift its focus from verifying line-by-line correctness (semantic accuracy) to preserving crucial non-technical aspects like knowledge sharing, mentorship, and architectural alignment. The proposed solution involves capturing the entire development session's decisions (the 'intent'), converting these into formal acceptance criteria, building an AI Slop Registry of recurring feedback, and generating a verifiable test plan that serves as the new review surface.

## Key takeaways

- The Code Review Crisis: Code churn is high (861%), leading to increased bottlenecks at the review stage. Currently, over 30% of changes merge without any review, and even when AI reviews are used, human involvement often reduces to skimming rather than deep reading.
- Review Must Preserve Alignment: Code review's most critical function is not just catching bugs (semantic accuracy), but facilitating knowledge sharing, mentorship, and architectural alignment. This 'alignment' aspect must survive the shift to automated development.
- The New Review Surface: Intent vs. Diff: Instead of reviewing code diffs, the review surface should become a verification of 'intent' and 'evidence.' This is achieved by capturing user decisions from development sessions, converting them into acceptance criteria, and generating a test plan that runs against a live preview.

## Technical details

- AI Code Verification & Trust Models: The speaker critiques his previous 'five-layer trust model,' arguing that it failed to account for the non-correctness aspects of review, such as knowledge sharing and mentorship. The goal is to build a system where trust is layered into the code before merging.
- Development Methodology Critique: The speaker warns that adopting 'spec driven development' without a feedback loop replicates the waterfall model. Real decisions are made and captured in the interactive prompts during coding sessions, not just in initial specifications.
- AI Slop Registry: This concept addresses semantic accuracy by codifying recurring review comments (e.g., best practices, common bug patterns). By building a registry from past feedback, the system learns over time, turning every recurring comment into a guardrail that doesn't need manual re-review.
- The Review Loop Mechanics: The proposed workflow is: Capture session decisions (Intent) $ ightarrow$ Generate Acceptance Criteria $ ightarrow$ Build Test Plan $ ightarrow$ Verification System runs a live preview against the plan. The reviewer then validates if the evidence meets the defined intent.

## Practical implications

- Mine your last 1,000 code review comments to build an 'AI Slop Registry' of repeatable best practices and guardrails.
- Shift the focus of team discussions from reviewing line-by-line diffs to discussing architecture and validating intent.
- Implement a system that captures development session prompts/decisions to generate formal acceptance criteria, thereby making review evidence-based rather than code-based.

## Topics

Code Review, AI Development, Build Engineering, CI/CD, Software Architecture, Knowledge Management, Aviator, Ankit Jain's LinkedIn/X Profile

Source: https://www.youtube.com/watch?v=YgEv7IQzGdM