HN Debrief

Stop sending me huge PRs; a rant

  • AI
  • Programming
  • Developer Tools
  • Open Source
  • Infrastructure

The post is a blunt plea for smaller pull requests. It argues that AI agents can now generate thousands of lines of code in one shot, but that does not make those changes reviewable. The complaint is not just about line count. It is about authors treating review as a mandatory gate instead of a handoff to another human who needs a clear story, sane scope, and enough context to judge risk. People strongly agreed with that framing. The center of gravity was that AI has made code generation cheap, while understanding, sequencing, and verifying changes is still expensive and very human.

If your team is using AI to write code faster, you need explicit standards for PR size, sequencing, and review ownership now. Otherwise you are turning reviewer time, compliance gates, and system understanding into the real constraint on delivery.

Discussion mood

Frustrated and increasingly defensive. Most people agreed that giant AI-generated PRs are exhausting to review and often signal that the author is dumping comprehension work onto someone else. The friction is amplified by weak organizational incentives, compliance gates, deadline pressure, and tools that make code generation much faster than explanation or verification.

Key insights

  1. 01

    Commit splitting is now a second pass

    Breaking a large implementation into clean commits has become post-processing work, not something the model naturally does while coding. People with good results are getting them by first letting the feature exist, then using the model to rewrite history into conceptual commits that each build, while still manually steering around rebases, branch stacks, and the model's poor instincts about narrative order.

    Treat commit hygiene as a dedicated stage in the workflow with time budgeted for it. If you expect atomic commits during generation, you will get worse output and more cleanup pain.

      Attribution:
    • danpalmer #1
    • ulrikrasmussen #1
    • hbogert #1
  2. 02

    Feature slices beat task lists

    Models can break work into steps, but that does not automatically produce reviewable PRs. The comments that had this working were explicit about slicing by user-visible or system-level increments, then binding those slices to commits or tasks with enough context to complete them independently. That is closer to release engineering than prompt cleverness.

    Define reviewable slice templates for your team. Ask for backend scaffold, schema, flag, UI hook-up, and rollout steps rather than generic subtasks.

      Attribution:
    • gosolozero #1
    • Twirrim #1
    • packetlost #1
    • garfij #1
  3. 03

    Review fails when nobody wants feedback

    If the author sees review as a bureaucratic checkpoint, they will optimize for getting past it, not for making the change understandable. That is why advice about smaller PRs often bounces off. The real leverage is whether the organization values feedback before code is written, or only values the ticket moving to done.

    Change the process before you change the prompt. Require design buy-in or early reviewer pairing for risky work so review starts before the PR exists.

      Attribution:
    • gensym #1
    • skydhash #1
    • lokar #1
  4. 04

    Huge PRs erase local system knowledge

    Submitting code you cannot personally review means the model, not the engineer, is carrying the implementation details. That leaves the organization with weak ownership of its own software and makes contributors interchangeable at the exact moment domain knowledge should be compounding into an advantage.

    Ask authors to explain and defend the change in plain language before merge. If they cannot, the problem is not PR size, it is that the team is losing its understanding of the product.

      Attribution:
    • ulrikrasmussen #1
  5. 05

    Good review starts before the PR

    The strongest workflow advice was to socialize the plan with the eventual reviewer before or during implementation, then use an early pass on code before the final test-and-polish pass. That turns review into a trust-building process instead of a veto at the end, and it reduces the chance that large AI-assisted changes hide a basic design mismatch until too late.

    For nontrivial features, assign a reviewer early and get verbal or written buy-in on the approach. You will spend less time rewriting code after the fact and less time fighting over PR shape.

      Attribution:
    • throwaway2037 #1
    • mulmboy #1
  6. 06

    Compliance keeps human approval in the loop

    Several comments made clear that companies cannot simply drop approvals even when review quality is collapsing. Requirements like SOC 2 keep a human sign-off step in place, which means teams can easily end up performing review theater unless they tighten standards for what is allowed through that gate.

    If you operate under compliance regimes, redesign the approval step now. Make it explicit what evidence, tests, and decomposition are required so approval is not just a box-check.

      Attribution:
    • stackskipton #1 #2
    • throwatdem12311 #1
    • Seattle3503 #1
  7. 07

    AI PR descriptions are becoming their own noise source

    The irritation was not limited to code. People are also getting flooded with novella-length PR bodies and verbose doc comments that restate the obvious. That extra text does not help review. It hides the few facts a reviewer actually needs, such as scope, risk, migration steps, and what to read first.

    Create a strict PR template with short sections and hard limits. Optimize for reviewer navigation, not for proving the model can write prose.

      Attribution:
    • dpc94 #1
    • hbogert #1
  8. 08

    Verification is the real unsolved bottleneck

    Even people willing to use AI aggressively kept running into the same wall. You can generate and even reorganize more code than humans can comfortably validate. Tools like stacked PRs help presentation, but they do not solve the deeper issue that someone still owns correctness, operational risk, and user impact when the model is wrong.

    Invest more in verification than generation. Better tests, feature flags, rollout controls, and explicit ownership will age better than chasing ever-faster code production.

      Attribution:
    • leeoniya #1
    • moezd #1
    • oliwarner #1
    • sqemo #1
    • TheChaplain #1

Against the grain

  1. 01

    Some large PRs are the honest shape

    Not every thousand-line PR is sloppy. Several comments argued that some features only make sense as a whole, or at least are faster to understand in one place than as a pile of partial PRs that do nothing independently. The useful distinction is not raw size. It is whether the change has a coherent intent and whether splitting it would create fake boundaries that obscure how the system actually works.

    Do not reduce review policy to a line-count fetish. Allow exceptions when authors can explain why the whole change is the clearest unit and how reviewers should traverse it.

      Attribution:
    • sackfield #1
    • throwaway2037 #1
    • orangecat #1
    • dboreham #1
  2. 02

    Replace human review with AI review

    A minority position said the obvious endpoint is to stop making humans inspect most generated code at all. In that view, the author becomes accountable for outcomes while AI handles review at machine speed. The pushback was immediate because this just creates a chain of unaudited models approving one another, but it captures where some teams are clearly tempted to go.

    Expect pressure to automate review away as code volume rises. If you reject that path, you need a credible alternative that preserves speed without turning reviewers into a permanent bottleneck.

      Attribution:
    • thunkle #1
    • 4lx87 #1
    • albatross79 #1
    • ovao #1
    • the_sleaze_ #1
  3. 03

    The no-comments rule still has limits

    The post's swipe at comments landed with many readers, but others pushed back on taking Clean Code too literally. Business rules, external landmines, and historical footguns often belong in comments because they explain constraints the code cannot fully encode. In an AI-heavy workflow, those comments also become guide rails for future edits rather than mere prose clutter.

    Ban explanatory fluff, not comments outright. Keep comments that preserve domain knowledge or operational traps that naming alone will not communicate.

      Attribution:
    • usewik #1 #2 #3
    • throwaway2037 #1
    • lubujackson #1

In plain english

PR
Pull request, a proposed set of code changes submitted for review before being merged into a codebase.
SOC 2
Service Organization Control 2, a compliance framework used to assess how a company handles security and operational controls.
stacked PRs
A workflow where a larger change is split into a chain of dependent pull requests, with each one based on the previous one.

Reference links

PR workflow and review tools

Open source maintainer responses

  • Luxon discussion 1796
    Pointed to as an example of how upstream maintainers may respond to AI-assisted or large contribution workflows.
  • Luxon perf patches branch
    Shared alongside the Luxon discussion as concrete context for a large patch series and review challenge.
  • Warp contributing guide
    Cited as a model where maintainers prefer contributors to submit issues and specs rather than direct implementation PRs.

Products mentioned for chaptered review

  • Stage
    Named as a review tool that split pull requests into chapters for easier review. No explicit URL was provided.
  • Linear Review
    Named as a tool that supports chaptered review of large pull requests. No explicit URL was provided.
  • Graphite
    Named as a tool that helps review large changes in smaller pieces while preserving context. No explicit URL was provided.