Skip to content

unpopular opinion

Stacked pull requests are not the fix. A better surface is.

Othman Shareef · November 21, 2026 · 6 min read


Every time I complain about reviewing a huge PR, someone tells me to stack. And they’re not wrong, exactly. We ship a lot of code now, the PRs got big, and stacked pull requests are a genuinely good answer to that. I just kept noticing something after we tried it: the reviews didn’t actually get nicer. There were more of them, each one smaller, and each one was still the same slog in the same tab. Stacking fixed the size of the change. It didn’t touch the reviewing.

Does stacking actually work?

Yes, and I’m not going to hedge that. The evidence for small changes is about as solid as anything in this field gets. SmartBear’s peer review guidance puts defect detection in free fall past roughly 400 lines, with reviewers effective at around 500 lines an hour in sessions of about an hour. Google’s engineering practices make small changelists the default and pair it with an expectation that reviewers respond within one business day. Small changes get read sooner, read closer, and revert easier. I’ve argued the same thing myself in how big a PR should be, and nothing here takes it back.

Stacking is the honest way to respect that evidence when the work doesn’t fit in 400 lines. Instead of one 2,000 line PR you get a chain of small dependent ones, each making a single claim a reviewer can actually evaluate. Good idea. It’s a native GitHub feature now too, and in public preview for every repository since July 2026, though plenty of teams still reach for a tool. The mechanics are in what native stacks change.

Who actually pays for stacking?

The author, before review even starts, on every single change. That’s the part the enthusiasm tends to skip. Stacking isn’t a setting you flip on, it’s a workflow, and workflows bill you somewhere.

  • A tool to adopt. A CLI, an extension or a platform, plus the mental model of a chain of branches that stops mapping cleanly onto plain git.
  • Rebase cascades. Change something in a lower layer, which review feedback guarantees you will, and everything above it gets restacked. Automation moves that work around, it doesn’t delete it, and the conflicts between layers are still yours.
  • A team-wide commitment. Stacking only pays off if reviewers read bottom up and comment on the layer that owns the problem. One person approving layer four while layer one is still contested burns the whole structure.

Teams with the discipline budget for that get compounding returns, and the tools built around stacking earn their keep. But a fix that only works for teams already capable of the discipline isn’t a general fix, it’s a reward for teams that were going to be fine anyway. The teams actually drowning in review, shipping under a deadline with a couple of contractors and a coding agent, are exactly the ones least able to pay that tax.

What happens when a change can’t be split?

Then stacking has nothing for you, and no amount of discipline changes that. Some changes are just atomic:

  • A schema migration and the code that depends on it.
  • A codemod applied across 300 files in one pass.
  • A cross-cutting rename that doesn’t compile halfway through.
  • A generated file or lockfile update that’s meaningless in fragments.

Split those and you get layers that don’t build, don’t run, or can’t be judged on their own, which is worse than one coherent change. Coherence beats arithmetic: a 600 line change carrying one idea reviews better than five 120 line fragments nobody can evaluate alone. And these aren’t rare. On my team they’re most of the big ones, and they’re the changes that most need someone to actually look.

Do stacked pull requests make reviewing easier?

Not really, and this is the bit that survives even if you throw out everything above. Give a team perfect stacking discipline. Give them five nicely layered 200 line PRs instead of one 1,000 line monster. Now watch what happens when someone sits down to review layer three.

They open the same surface they had before. Files listed alphabetically, in no order resembling how the change should be read. Scroll position gone since last time. Threads from the previous round collapsed somewhere below the fold. A force push orphaned two comments. If the author pushed a fix yesterday there’s no cheap way to see just the delta, so they start over. None of that changed, because stacking never touched it. Microsoft Research’s study of modern code review, Bacchelli and Bird, found the reviewer’s top challenge is understanding the change. Smaller changes shrink how much there is to understand. They don’t help you understand it.

So the arithmetic cuts both ways: you multiplied the number of review sessions by five and left each one just as expensive per line. If the surface is bad, stacking distributes the pain, it doesn’t remove it. You still have to read the code anyways. Meanwhile a better surface improves every PR you review, including every layer of every stack, and it asks nothing of the author. That asymmetry is the whole argument. As Osmani puts it, generation got cheap and understanding stayed expensive. Stacking attacks volume. The cost lives in understanding.

What actually changes the reading

Disclosure, I work on Pyor, so this is an interested party describing its own bet. The bet is that the reading is the bottleneck, so that’s where the work goes: a file rail built for triage, a reading order that follows the import graph instead of the alphabet, commit-scoped diffs so a re-review only costs you the delta, folder-level viewed tracking, threads that survive a force push, a focus mode. Where it uses AI it groups the diff and points at what matters instead of generating prose you then have to check against the code, because that’s just moving the reading around.

A file rail set to Dependency order, listing the files of a 19-file pull request with the leaf modules first and their consumers below, beside the diff of the first file in that order.A file rail set to Dependency order, listing the files of a 19-file pull request with the leaf modules first and their consumers below, beside the diff of the first file in that order.
Dependency order: the file rail lists leaf modules first and their consumers last, so the reading follows the import graph rather than the alphabet.

Honest caveats: it’s young, and it’s a viewer, not a workflow platform. It doesn’t create stacks, it has no merge queue of its own (it adds PRs to GitHub’s merge queue when a repo uses one), and it will do nothing to keep your PRs small. If small changes are the outcome you want, a stacking tool is the right layer for that, not us.

Stack if you can, just don’t call it a review fix

These aren’t rivals. Nothing stops you stacking rigorously and reviewing each layer in a surface built for reading, and teams doing both are in the best shape of anyone. If you can stack, stack. It’s the structurally right answer to change size, and change size is a real problem.

What’s worth resisting is the slide from “stacking helps” to “stacking is the fix”, because that slide lets everyone stop asking why reading a diff is still this bad. Two different problems, two different owners. One gets paid by the author, once per change, and only some teams can afford it. The other gets paid by every reviewer, on every PR, forever.

Frequently asked questions

Are stacked pull requests worth adopting?

For most teams that can adopt them, yes. Smaller changes genuinely review better, and stacking is the practical way to keep changes small on a multi-week feature. The caveat is that it is a team-wide commitment: everyone learns the tooling, restacks after every lower change, and keeps the layers coherent. Half a team stacking is worse than none.

Why do stacked pull requests not fix code review by themselves?

Because they change the unit of work, not the act of reading. A stack of five small PRs still gets reviewed in whatever surface you already use, so you get five sessions of the same lost scroll position, buried threads and alphabetical file lists. Stacking multiplies the number of reviews without improving any one of them.

What about changes that cannot be split?

Migrations, codemods, cross-cutting renames and generated file updates are atomic by nature. Split them and you get fragments that do not compile, do not run, or cannot be judged alone. Stacking has nothing to offer there. Those changes arrive whole, and the only thing that helps is a surface that stays usable at size.

Review your next PR in Pyor.

Read, comment, approve, and merge in one window. Free for individuals, and it talks to GitHub straight from your machine.