Why PRs Still End at a Human Merge

GitHub's pull request, introduced in 2008, turned a plain-text diff into a social workflow. Comments, approvals, and—crucially—a merge button that stayed dark until another developer signed off. That gate made accountability structural: nothing ships without a human willing to own it. Seventeen years later, that principle still holds, even as the code being reviewed increasingly comes from an LLM.

Agentic coding tools now scaffold projects, open PRs, and even respond to their own review comments. That raises an obvious question: when part of the code originates with a model, who is accountable? The answer remains the same—the developer who hits merge. What has changed is everything leading up to that click.

What Developer Interviews Revealed About AI Review

GitHub Copilot's code review team recently interviewed developers about their review workflow. Three patterns emerged consistently.

  1. No special treatment: Reviewers scrutinized AI-generated diffs as strictly as any other submission.
  2. Self-reviews raised the floor: Developers who ran Copilot review before opening a PR eliminated an entire class of trivial nits—trimmed imports, missing tests—cutting review back-and-forth by roughly a third.
  3. Judgment stays human: Programming is about trade-offs. LLMs can outline options, but someone has to decide based on organizational goals and standards.

The takeaway is straightforward: AI augments developer judgment; it does not replace it. That principle shapes how Copilot's review features are built.

Where LLMs Excel—and Where They Fall Short

Current models handle the grunt work of review well:

  • Mechanical scanning: typos, unused arguments, missing edge cases.
  • Pattern matching: spotting likely SQL injection or an un-awaited promise.
  • Pedantic consistency: mixed naming conventions, formatting disparities.

They still struggle with the substantive parts:

  • Architecture: whether to split a service or cache locally.
  • Mentorship: explaining why a pattern matters and when to break it.
  • Values: whether a feature should exist at all.

Those gaps keep developers firmly in the loop.

A Practical Playbook for AI-Assisted Reviews

The most effective approach starts before you submit. Treat your reviewers the way you want them to treat you: don't send them noise.

Self-Review in the IDE First

Run Copilot code review before pushing. It combs the staged diff for docstring opportunities, null dereferences, and other obvious fixes. You address those before opening the PR so teammates see only the substantive issues that need human insight.

Own the Generated Code

Using AI doesn't transfer responsibility. Once code is committed, your name is on it. You need to understand what it does, verify it meets team standards, and ensure it integrates cleanly with the rest of the codebase.

If an AI agent writes code, it’s on me to clean it up before my name shows up in git blame.

Jon Wiggins, Machine Learning Engineer at Respondology

Keep the Pipeline as the First Gate

Unit tests, secret scanning, CodeQL, dependency checks, style linters—your existing CI should run all of them. Fail fast, fail loudly. AI review doesn't replace these checks; it complements them after they pass.

Deploying AI Where Judgment Matters Least

The value of AI in review isn't replacing reviewers; it's absorbing routine work. LLMs are particularly good at catching the kind of mistakes LLMs tend to make—increasingly relevant as more AI-generated code lands in codebases.

Define clear roles: use AI for detailed, repetitive scrutiny where human attention drifts; rely on developers for architecture, consistency with business goals, and organizational values. Set expectations about when AI feedback is authoritative and when human judgment takes precedence. Custom instructions in Copilot allow teams to codify those rules directly.

Building a Sustainable Review Process

  • Document guidelines: specify when AI reviews run, what feedback to trust, and how to escalate disagreements with an AI review.
  • Keep them current: codebases and AI capabilities evolve; what works today may not next quarter.
  • Discuss results openly: share both positive and negative AI review experiences to sharpen the team's approach.
  • Refine automation: use review feedback to find recurring issues that belong in automated tests rather than manual review.

The Irreducible Human Layer

Even as models improve, three review responsibilities stay stubbornly human: architectural trade-offs like splitting services or taking on tech debt, mentorship through code review threads, and ethical questions about whether a feature should ship at all. PRs remain the audit log and governance layer—the mechanism that ensures judgment is applied before shipping. The goal isn't to automate that judgment. It's to give developers time to use it well.