The Death of Pull Requests: AI Coding's Impact on Code Collaboration

For anyone who learned to code in the last 15 years, it's hard to imagine a life without Git, GitHub, and Pull Requests. But there was a time before them — and it may well come to pass that there is life after. On April 16, 2026, GitHub made history by allowing repository owners to disable pull requests entirely, a feature previously restricted to issues only. This isn't a minor UI tweak. It's a signal that the fundamental mechanics of code collaboration are being rewritten by the rise of AI coding agents.

The 21-Year Arc of Pull Requests

Pull requests were arguably invented in 2005, successfully popularized by GitHub in 2008, and have dominated open source collaboration ever since. For two decades, the PR has been the atomic unit of code review, the checkpoint where human judgment meets proposed changes. But the model was built for human collaborators — humans who write code in bursts, review in batches, and merge when satisfied.

AI agents don't work this way. They generate code continuously, iterate in loops, and produce changes at a scale that makes traditional PR review impractical. When an agent can produce 50 meaningful commits in an hour, the human bottleneck becomes the problem, not the solution.

The Rise of "Prompt Requests"

Pete Steinberger and Theo have been vocal advocates for what they call "Prompt Requests" — a fundamental shift from reviewing code to refining prompts. The logic is compelling:

• No merge conflicts: Agents work from specifications, not branches
• Easier iteration: Tweaking a prompt is faster than reviewing hundreds of lines
• Security: Less risk of malicious code slipping through innocent-looking PRs

The maintainer's role shifts from code reviewer to specification curator. Instead of reading diffs, you refine the prompt that generates the code. Instead of catching bugs in review, you catch ambiguity in requirements.

Reputation-Based Systems

Mitchell Hashimoto and Amp Code have pioneered alternative approaches: reputation-based systems for handling untrusted code contributions. Rather than reviewing every line, you review the agent that produced it. High-reputation agents get commit access. Low-reputation agents submit to automated evaluation harnesses.

This mirrors how we already handle dependencies. You don't review every line of React or TensorFlow — you trust the source. As AI agents become more deterministic and observable, the same trust model applies to generated code.

GitHub's Strategic Shift

GitHub's decision to allow disabling PRs isn't happening in a vacuum. It follows closely on the heels of their broader "Death of Code Review" initiatives, including AI-powered auto-review and agent-driven code suggestions. The platform is positioning itself for a world where:

• Most code is written by agents, not humans
• Review happens via evaluation harnesses, not human eyes
• Collaboration moves from "propose and review" to "specify and verify"

What This Means for Builders

The shift isn't immediate or universal. Human review still matters for architecture, security-critical code, and novel algorithms. But the default is changing. If you're building agent systems today, you should be designing for a world without PRs:

• Invest in specification quality — prompts are the new pull requests
• Build evaluation harnesses that can verify agent outputs
• Design for continuous integration, not batch review
• Track agent reputation and capability metrics

The Broader Implication

As Aaron Levie noted in "Building for Trillions of Agents": "the path forward is to make software that agents want." Humans invented git for human collaboration reasons. Agents need different primitives. The PR was a human checkpoint. The future belongs to verification harnesses, specification contracts, and reputation systems.

GitHub's move is an acknowledgment that the infrastructure of software development must evolve. The 21-year reign of the pull request is ending not with a bang, but with a settings toggle. What's emerging is a new collaboration model built for the agent era — one where the bottleneck isn't human attention, but specification clarity and verification rigor.

Quick Facts

Metric	Value
PR Invention	2005 (kernel dev)
GitHub Launch	2008
Disable PR Feature	April 16, 2026
Key Advocates	Pete Steinberger, Theo
Alt Approaches	Mitchell Hashimoto, Amp Code
New Primitive	Prompt Requests

Why PRs Are Dying

Factor	Impact
Agent velocity	50 commits/hour vs human pace
Review bottleneck	Human attention becomes limiting factor
Merge conflicts	Agents work from spec, not branches
Security model	Reputation > line-by-line review

Prompt Request Advantages

• No merge conflicts — spec-driven generation
• Faster iteration — tweak prompt vs review code
• Reduced attack surface — spec is smaller than diff
• Scalable verification — harnesses vs human review

Reputation System Model

Agent Tier	Access Level	Verification
High reputation	Direct commit	Spot checks
Medium reputation	Branch push	Harness evaluation
Low reputation	Spec submission	Full review

Builder Action Items

• Invest in specification quality
• Build evaluation harnesses
• Design for continuous integration
• Track agent reputation metrics
• Prepare for verification-first workflows

Implementation Guide

Transitioning from PR-based to prompt-based workflows.

Specification-First Pattern

// Old: PR with description
const pr = {
  title: "Add user auth",
  description: "Implements JWT...",
  diff: generateDiff()
};

// New: Prompt with spec
const promptRequest = {
  spec: `
    Add user authentication:
    - JWT tokens with 24h expiry
    - Refresh token rotation
    - Rate limit: 5 attempts/minute
  `,
  constraints: {
    securityLevel: "high",
    testCoverage: 0.9,
    maxComplexity: 10
  },
  verification: authTestHarness
};

Reputation Tracker

class AgentReputation {
  constructor() {
    this.metrics = {
      successRate: 0,      // % of tasks completed
      bugRate: 0,          // bugs per 1000 LOC
      revertRate: 0,     // % of commits reverted
      reviewTime: 0,       // avg time to acceptance
      harnessScore: 0      // automated eval score
    };
  }
  
  getTier() {
    const score = this.calculateScore();
    if (score > 0.9) return "trusted";
    if (score > 0.7) return "verified";
    if (score > 0.5) return "reviewed";
    return "sandbox";
  }
  
  getAccessRights(tier) {
    return {
      trusted: { directCommit: true, autoMerge: true },
      verified: { directCommit: true, autoMerge: false },
      reviewed: { branchPush: true, requireHarness: true },
      sandbox: { specSubmit: true, noPush: true }
    }[tier];
  }
}

Verification Harness

async function verifyAgentOutput(spec, implementation) {
  const checks = {
    // Static analysis
    lint: runLinter(implementation),
    complexity: checkComplexity(implementation),
    coverage: runTests(implementation),
    
    // Semantic verification
    specMatch: checkSpecCompliance(spec, implementation),
    security: runSecurityScan(implementation),
    
    // Integration
    build: runBuild(implementation),
    integration: runIntegrationTests(implementation)
  };
  
  const results = await Promise.all(Object.values(checks));
  
  return {
    pass: results.every(r => r.pass),
    score: average(results.map(r => r.score)),
    feedback: generateFeedback(results)
  };
}

Migration Strategy

Phase	Action	Timeline
1	Add harness evaluation to PR pipeline	Now
2	Track agent reputation metrics	2 weeks
3	Enable auto-merge for high-reputation agents	1 month
4	Transition to prompt-first workflow	3 months
5	Disable PRs for agent-only repos	6 months