Sachin Gupta reveals why AI coding agents trigger massive review debt

AI coding agents are accelerating the speed of software development. Pull requests (PRs) land in repositories faster than ever, yet engineering teams are hitting a hidden bottleneck. While code production volume climbs, human capacity to review, trust, and understand that code remains static. This gap creates what Sachin Gupta, a staff software engineer at eBay, calls ReviewDebt—the accumulating burden of unverified automated code.

According to industry benchmarks, the issue is compounding rapidly. Data from Faros AI shows that median PR review times have jumped significantly, while a growing percentage of pull requests are merged with no human review at all. Traditional engineering metrics like PR throughput or cycle time paint a rosy picture, but they act as vanity metrics. They measure the raw speed of production rather than the speed of trust.

Decoding the Five Deterministic Signals of Review Burden

To manage this growing technical liability, teams need a concrete, defensible way to measure the human effort required to review any given pull request. The ReviewDebt framework uses five deterministic signal families to calculate a score from 0 to 100 without relying on unpredictable language models as judges.

Net Lines and Cross-Module Coupling

Coding agents often apply fixes directly at the call site rather than routing changes to the root cause. This habit leads to sprawling changes across multiple files. The mental model required to review a sprawling pull request scales steeply, making even minor agent-assisted changes surprisingly exhausting to verify.

The Test Evidence Gap

Automated tools frequently generate code with low test-to-production line ratios. Even when agents write tests, they often perform "test theater"—asserting what the code currently does rather than what the business logic should do. This locks in buggy behavior instead of validating correctness.

Directory and Ownership Spread

When a PR touches files across multiple team boundaries, coordination overhead explodes. Human developers must secure approvals from various code owners who lack context. This multi-party review process quickly eats up the time saved by automated generation.

AI Authorship Indicators

Identifying agent-authored code helps teams flag PRs that need extra scrutiny. Common signals include co-authored commit footers, specific branch name prefixes (like cursor or copilot), and generated-by phrases in the PR body. This signal does not penalize AI usage but adjusts the review complexity score accordingly.

Evidence and Rationale Gaps

An automated PR often lacks context, offering short, unhelpful titles or single-word descriptions. A high-quality review requires a clear explanation of the "why" behind a change. When a PR lacks this documentation, its reviewability drops to zero.

Shifting from Intuition to Measurement

To adopt this framework, teams should score their last 200 merged pull requests to establish a baseline. By setting a clear threshold—such as flag and review any PR scoring above 50—organizations force authors to provide additional evidence before seeking senior engineer approval.

Rather than blocking development, publishing these scores directly as PR comments builds visibility. Engineering managers can track weekly averages per team to identify where review fatigue is building up before it triggers production incidents.

Establishing a Trust Boundary for AI Delivery

Measuring this burden changes the conversation between developers and management. Instead of debating subjective feelings about review speed, engineering leaders can point to hard metrics. Teams can directly quantify how much review debt they are accruing relative to their deployment velocity.

As organizations rely more heavily on autonomous agents, establishing an audit trail becomes non-negotiable. Tracking the burden ensures that teams maintain software quality, preserve architectural integrity, and keep human engineers firmly in the loop.