The landscape of software development is undergoing a profound transformation, driven by the burgeoning capabilities of artificial intelligence. As AI models increasingly take on the foundational tasks of writing code, a critical question emerges: how can we effectively leverage AI to scrutinize the very codebases it helps create? The emerging consensus points toward a strategic upstream shift of human oversight, prompting a vital re-evaluation of where human developers should focus their efforts in this new paradigm. This paradigm shift is not merely theoretical; it addresses a tangible pain point in many development teams where mandatory peer reviews risk becoming a perfunctory exercise, a mere rubber stamp on a process designed for quality assurance.
A common scenario illustrates this challenge: a pull request languishes in a peer review channel for days. When a developer finally allocates time, they may possess limited context regarding the original engineer’s intentions or the intricate details of the implementation. The review then devolves into a perfunctory glance, often culminating in a hasty decision to merge, a gamble rather than a thorough validation. This inefficiency is not an isolated incident but a recurring theme in the industry, often rationalized by an ingrained optimism that the perceived benefits of standardization and order outweigh the evident drawbacks.
Avital Tamir, a software engineer at groundcover, a cloud-native observability platform company, has been a vocal proponent of reimagining this established code review process. He is not advocating for a descent into unbridled "cowboy-coding" but rather a pragmatic adaptation of established practices to contemporary technological realities. "There’s a lot of discourse about AI slop like hallucinations, misunderstood context, and confident wrongness, and those are real concerns," Tamir explained to The New Stack. "But we must also realize that it’s time to clean up ‘human slop,’ i.e., a class of error that humans make far more often than AI does. For these types of mistakes, an AI reviewer is much more reliable than a tired human."
The Perils of "Human Slop" in Code Reviews
The "human slop" Tamir describes resonates with many developers. It often begins after a feature is completed and a pull request is submitted. The request then enters a period of inactivity, sometimes referred to as "marinating." Developers may ping colleagues on communication platforms like Slack, but responses can be delayed. After a significant waiting period, often two days or more, a reviewer might finally engage, only to offer comments on trivial matters such as variable naming conventions or to ask questions already explicitly answered within the code itself.
The developer, faced with the prospect of a prolonged debate over minor issues, often opts to implement the suggested changes, even if they are inconsequential to the core functionality. This is frequently faster than arguing. Following these adjustments, a reviewer might finally grant an "LGTM" (Looks Good To Me), a process that can significantly decelerate the release cycle.
Tamir questions the efficacy of this protracted process. "What did that accomplish?" he posed. "A feature that could have shipped Tuesday ships Friday. Your competitor ships on Tuesday, finds the real bug on Wednesday, and fixes it on Thursday. Meanwhile, you’ve spent two days in review limbo, optimizing for plausible deniability instead of iteration speed." He emphasizes the need to critically examine what these lengthy review cycles are actually catching.
"The bugs that really hurt, like race conditions, data edge cases, or failure modes under load, are rarely spotted by someone reading code in isolation without full system context," Tamir elaborated. "The feedback that does come through tends to be stylistic such as: ‘use early returns,’ ‘extract a function,’ and so on—things that good static analysis should have caught automatically." When this time-consuming, often superficial review process is multiplied across dozens of engineers, numerous pull reviews per week, and multi-reviewer policies, the cumulative cost becomes substantial. This translates directly into lost opportunities for shipping features and reduced learning cycles for development teams.
The Rise of AI-Assisted and Rigorous Self-Review
The current technological landscape offers a compelling alternative: the integration of AI tools that can automate many of the tasks traditionally performed during human code reviews. Platforms like CodeRabbit enable teams to codify their stylistic conventions and best practices into automated rules, ensuring consistent application across all pull requests. Similarly, Claude Code Review, a multi-agent tool developed by Anthropic, is designed to detect software bugs before human reviewers even examine the code. Other notable AI-powered solutions include Qodo, which offers agentic software code development and review functionalities, and Greptile, a service specializing in AI code review.
With these advanced tools readily available, Tamir poses a pertinent question: "If AI is writing and reviewing the code, and a human with full context of the requirements has already verified the behavior, what gap does the asynchronous human approver fill when we should be championing rigorous self-review?"
This pivot towards self-review, augmented by AI, places accountability more directly with the software engineer who possesses the deepest understanding of the code and its context. Tamir outlines a typical AI-augmented self-review workflow:
- Initial Development and Unit Testing: The engineer writes the code and ensures it passes comprehensive unit tests.
- AI-Powered Static Analysis and Linting: Automated tools scan the code for style violations, potential bugs, and adherence to established coding standards.
- AI Code Review: An AI tool analyzes the code for logic errors, security vulnerabilities, performance issues, and potential edge cases. This goes beyond simple style checks, offering insights into deeper code quality aspects.
- Developer Self-Review: The engineer meticulously reviews their own code, informed by the AI’s findings and their complete understanding of the requirements.
- Integration with CI/CD Pipeline: The code is automatically built and deployed to staging environments, where further automated tests (integration, end-to-end) are executed.
- Optional Human Review for Critical Changes: For high-impact or complex changes, a human review might still be conducted, but it is now a more targeted and informed process, focusing on architectural decisions or complex business logic rather than stylistic minutiae.
"That process is more rigorous than waiting 48 hours for an LGTM," Tamir asserted. "Plus, it puts accountability exactly with the person who understands the problem. The uncomfortable truth is that much code review is just theater. It creates the appearance of rigor without reliably delivering it."
A Question of Trust and Team Structure
The increasing sophistication of AI in code generation and review necessitates a fundamental re-examination of software engineering team structures and management philosophies. At its core, this shift hinges on trust. Tamir suggests that if leadership lacks confidence in software engineers to conduct responsible self-reviews, "that’s a hiring problem, not a process problem."
He further posits that trust within high-performing teams is cultivated through tangible outcomes: consistently shipping functional features, taking ownership of failures and rectifying them swiftly, proactively disseminating knowledge, and actively involving colleagues in decision-making processes. These behaviors build a robust track record of competence and reliability, a track record that a passive peer review approval queue cannot replicate.
Teams considering adopting these AI-augmented self-review methodologies might find it prudent to begin with lower-risk internal software tools, greenfield services, or non-customer-facing systems. By carefully measuring key metrics such as deployment frequency, rollback rates, and bug detection rates, teams can assess the efficacy of the new approach. In parallel, synchronous human collaboration can be reserved for high-stakes decisions, ensuring that human expertise is applied where it is most critical. This strategic integration can transform team collaboration from a bureaucratic hurdle into a genuinely impactful element of the development lifecycle, moving beyond a simple "LGTM" to a more meaningful "Looks Really Good To Me." The ongoing evolution of AI in software development promises not only greater efficiency but also a more engaged and accountable engineering workforce.
