On July 20, 2026, GitHub made Code Quality generally available. The feature automatically added Copilot as a reviewer on every pull request. Eighteen days later, on August 7, they reversed it.
"You told us that adding a reviewer should be your choice."
— GitHub Changelog, August 7, 2026
Developers rejected automated review. But the more structurally interesting feature — the one nobody objected to — stayed. The Copilot coding agent reviews its own pull requests before opening them. Self-review is mandatory. Not opt-in. The agent writes code, reviews its own code, and opens a PR only after approving its own work.
There is a formal proof for what happens next.
The Proof
Song et al.'s "Recursive Self-Training Collapse" (June 2026) contains Theorem 2.3, which proves that when a model evaluates its own outputs — the same architecture generating and judging — the evaluation degenerates to what they call a rubber-stamp regime. Acceptance rates rise. Correctness does not. The proof is mathematical, not empirical. It doesn't depend on the specific model or domain. It applies whenever the generator and evaluator share a distribution.
GitHub's Copilot coding agent is this theorem deployed as infrastructure. The same model that writes the code runs the review. GitHub says it "catches obvious logic errors and stylistic issues." The formal proof says the system will converge on accepting its own outputs regardless of quality, because the evaluator cannot distinguish its own errors from correct solutions — it made those errors for the same reasons it would miss them.
The humans rejected the automated gate. The self-reviewing loop — the one Theorem 2.3 proves degenerates — kept running.
The Other Path
If AI can't review its own code, humans have to. LinearB's 2026 benchmark report measured what happens when they try. The dataset: 8.1 million pull requests from 4,800 engineering teams.
Teams with high AI adoption merged 98% more PRs. Review time increased 91%. Organizational productivity improvement: roughly 10%. The bottleneck moved from writing code to validating it.
The refactoring number is the sharpest signal. Human PRs get refactored about 37% of the time — reviewers improve the code, reshape it, integrate it properly. AI PRs get refactored close to zero. The code either ships as the model wrote it or it's rejected outright. No middle ground. No human judgment applied to the work. The review step that exists to catch problems is either skipped (first draft goes in) or overwhelmed (4.6× wait time, growing queue).
A causal study of 806 repositories using Cursor (He et al., MSR 2026) measured the same dynamic longitudinally. Velocity gains appeared in the first month, then returned to baseline by month two. Quality degradation appeared and persisted. Code complexity increased 41%. Static analysis warnings increased 30%. Twenty-four percent of AI-introduced technical debt remained unresolved months later.
Velocity transient. Quality degradation permanent.
The Blind Instrument
Both paths fail. The AI self-review degenerates mathematically. The human review drowns in volume. The third failure is the one that closes the loop: the instruments that would detect these failures are themselves compromised.
Sonar's 2026 developer survey: 96% of developers don't fully trust AI-generated code. Only 48% always verify before committing. Sixty-one percent say AI produces code that "looks correct but is unreliable." The gap between distrust and action — knowing the code is suspect but shipping it anyway — is the human verification failure in its most honest form.
GitClear's longitudinal data shows the structural consequence. From 2021 to 2024, refactored code dropped from 25% to under 10% of all changes — a 60% decline. Code cloning rose from 8.3% to 12.3%. AI and developers overwhelmingly choose to add new code rather than improve existing code. The codebase grows. The quality maintenance that used to happen during review doesn't happen. Nobody notices because the metric everyone watches — velocity — is up.
And the researchers who might measure this can't run clean experiments. METR's study found 30-50% of participants refused to code without AI even when assigned to the control group. DX DevEx research reported that 50.5% of teams using AI coding tools don't sustain their initial productivity gains. But their baseline — what "normal" looks like without AI — no longer exists. The instrument is calibrated to the thing it's measuring.
The Product
This is the closed loop. The AI reviews itself and the formal proof says it rubber-stamps. The human reviews the AI and the data says they're drowning. The measurement instruments that would detect either failure are calibrated to a baseline that no longer exists.
On July 29, GitHub made Copilot code review's agent skills and MCP server integration generally available. The review pipeline is becoming more agentic — more automated layers, each one evaluating the layer before it, each one unverified by anything outside the system. The response to the verification failure is more verification of the same kind.
The formal proof exists. The data exists. The market shipped it anyway.