GitHub Stacked PRs Are Live: Slash Review Latency for Incremental Features

What Actually Happened: Native Stacking Lands on GitHub

On July 30, 2026, GitHub shipped native stacked pull requests into public preview. This isn't a third-party CLI hack or a GraphQL gymnastics routine—it's a first-class feature baked into the pull request UI. You can now create a PR that depends on another unmerged PR, forming a directed chain of changes. The announcement is live on the GitHub Changelog.

Before this, engineers who wanted to avoid monster 3,000-line diffs had two ugly options. Option one: branch off main, write the whole feature, and pray your reviewer has a free afternoon. Option two: use git rebase --onto acrobatics with separate branches and manually track dependencies via PR descriptions or labels. Both workflows broke the core GitHub experience—review comments scattered across isolated PRs, CI status hidden from the chain, and merge conflicts that cascaded silently.

Native stacking fixes this by making the dependency graph a visible, interactive part of the repository. A PR now knows its parent. The diff view shows only the incremental changes relative to that parent, not the entire chain. Reviewers see exactly what's new.

Why This Matters for the Working Engineer

Let's be blunt: the primary bottleneck in shipping software isn't writing code. It's waiting for review. A 2024 study by LinearB found that PRs with more than 400 lines of changes have a median review time of 32 hours. The same study showed that breaking that work into three smaller PRs drops median review latency below 4 hours each.

Stacked PRs give you the mechanism to do this without the coordination tax. Here's the engineer's calculus:

• Parallelizable work. While PR #1 (the database migration) sits in review, you're already building PR #2 (the API endpoint) and PR #3 (the frontend component). Each is a clean, reviewable unit. No more blocked days.
• Incremental CI. Each PR in the stack runs its own CI pipeline against its parent. A failing test in PR #3 doesn't muddy the water for PR #1. You can merge PR #1 with confidence even if the feature flag in PR #3 isn't wired up yet.
• Cleaner commit history. The merged result is a linear sequence of well-scoped commits, not a squash-merged behemoth that obliterates the design decisions along the way.

For a Forward Deployed Engineer, this is a game-changer. An FDE's week often involves building a prototype against a messy enterprise codebase, with requirements shifting mid-sprint. The ability to stack small, reversible changes means you can get early feedback from the customer on a partial integration without exposing half-baked code. If you're curious about what that week actually looks like, we broke it down in What a Forward Deployed Engineer Actually Does in a Week.

The workflow also aligns perfectly with the "ship a prototype in 5 days" mentality. When you're racing a deadline, you can't afford to wait for a single monolithic review. The stacking model lets you pipeline your work, which we explore in From Messy Enterprise Problem to Shipped Prototype in 5 Days.

The Core Workflow: Composing a Stack

Here's what the flow looks like architecturally. You start with a base branch (usually main), then create a chain of dependent PRs, each targeting the branch of the PR below it.

To build this in practice:

1. Create your first branch off main: git checkout -b feat/db-migration
2. Make your changes, push, and open a pull request as you normally would. This is the root of your stack.
3. Create your second branch from the first branch, not from main: git checkout -b feat/api-endpoint feat/db-migration
4. Push and open a PR. In the pull request form, you'll now see a "Depends on" dropdown. Select feat/db-migration.
5. Repeat for subsequent PRs. Each one targets the branch of the PR directly below it.

The key mental model shift: you are no longer branching from main for every feature. You're building a chain of branches, each one representing a logical, reviewable step. Your local rebase workflow changes too. When PR #1 gets review feedback, you amend commits on feat/db-migration, then rebase feat/api-endpoint onto the updated feat/db-migration.

The Review Dance: How Your Teammates Interact

When a reviewer opens PR #2, they don't see the combined diff of main..feat/api-endpoint. They see only the changes introduced since PR #1. The files changed tab, the diff view, and the conversation timeline are all scoped to this increment.

This is the feature that kills "I already reviewed this in the other PR" fatigue. If PR #1 changes a function signature and PR #2 uses the new signature, the reviewer of PR #2 only sees the new call site. They don't re-review the function definition.

The dependency graph is visible in the PR sidebar. Clicking on a parent PR takes you directly to it. CI status for the entire stack is summarized, so you can see at a glance if a failure in a lower PR is blocking the whole chain.

A practical tip: when you request review on a stack, always request it top-down. Ask for review on PR #1 first. Once that's approved, move to PR #2. Reviewing bottom-up is possible but disorienting, because the reviewer lacks the context of the foundational changes.

Merging: The Top-Down Cascade

Merging a stack requires discipline. You must merge from the root down. If you merge PR #3 before PR #1, you'll drag unreviewed code from PR #1 and #2 into the target branch, defeating the purpose.

GitHub enforces this. The merge button for PR #3 is disabled until PR #2 is merged. Once PR #2 is merged, the base branch for PR #3 automatically updates to the merge commit of PR #2. You may need to rebase PR #3 if there are conflicts, but GitHub handles the branch retargeting.

The ideal sequence:

1. All PRs in the stack are approved.
2. Merge PR #1. CI runs.
3. PR #2's base auto-updates. Merge PR #2. CI runs.
4. Repeat until the stack is fully landed.

This top-down cascade ensures that main always moves forward in a clean, tested sequence. If a late-stage PR introduces a bug, you can revert just that merge commit without unwinding the entire feature.

A Balanced Take: Where It Shines and Where It Breaks

Let's be honest about the rough edges in this public preview. This isn't a panacea for all branching headaches.

Where it shines:

• Large features with clear seams. If you're building an integration that requires a schema change, a service layer, and a UI, stacking is a perfect fit. The boundaries are natural.
• Teams with async review patterns. If your team spans time zones and reviews happen in bursts, stacking lets everyone stay unblocked.
• FDE and prototyping workflows. As we mentioned, the ability to iterate in small, reversible steps is critical when you're building against a customer's live environment.

Where it breaks:

• Highly coupled changes. If PR #2 fundamentally refactors the approach taken in PR #1, you're in rebase hell. The stack model assumes linear, additive changes. A radical pivot mid-stack means you're rewriting multiple PRs simultaneously.
• Immature CI pipelines. If your CI is flaky, a failure at PR #1 blocks the entire stack. You can't merge PR #2 to "just get it out" while you debug PR #1's tests.
• Over-stacking. A 10-PR stack is a code review nightmare, regardless of tooling. The cognitive load of tracking context across that many diffs is high. Limit stacks to 3-5 PRs.

There's also a social risk. Stacked PRs can encourage "fire and forget" behavior—opening five PRs and walking away while reviewers drown. The tool doesn't replace the need for a team agreement on work-in-progress limits and expected review turnaround.

The feature is also, as of this writing, in public preview. Expect edge cases. The automatic base retargeting on merge can be finicky with force pushes. The API for programmatic stack management is still evolving. If you're building internal tools that script PR creation, test against a sandbox repo first.

Getting Started Today

Stacked PRs are available for all repositories on GitHub.com, but they must be enabled at the organization or repository level. A repository admin needs to navigate to Settings > Pull Requests and enable the "Stacked pull requests" feature preview.

Once enabled, any contributor can start stacking. There's no new CLI to install. The gh CLI has been updated with gh pr create --parent <branch> support.

A quick litmus test to see if your team is ready:

1. Pick a feature you're about to start that has at least two natural layers (e.g., backend + frontend).
2. Create a 2-PR stack. Don't over-engineer it.
3. Run through the full review and merge cycle with one teammate.
4. Retro briefly: Did the incremental diffs speed up review? Did the rebase workflow feel natural?

If the answer is yes, you've just unlocked a significant lever for your team's throughput. If the answer is no, you've learned that your particular codebase or team dynamic doesn't benefit from stacking—and that's valuable data too.

For those who want to dive deeper into building effective workflows, especially in customer-facing contexts where speed and accuracy are paramount, the skill of writing clear technical documentation becomes even more critical when you're shipping incremental changes that customers will see. We've written about how to communicate these changes effectively in Writing Customer-Facing Technical Docs That Engineers and Execs Actually Read.

FAQ

Do stacked PRs work with squash merging?

Yes. When you squash-merge PR #1, the resulting commit on main becomes the new base for PR #2. PR #2 will need a rebase, but GitHub handles the retargeting. The commit history on main remains a clean sequence of squashed commits, one per PR in the stack.

What happens if I force-push to a parent PR?

All dependent PRs will show a conflict and require a rebase. This is by design—the dependent PRs are tracking the parent branch, and a force-push rewrites that history. Communicate force-pushes clearly in your team's chat. A quick "force-pushed feat/db-migration, please rebase your stacks" saves frustration.

Can I reorder PRs in a stack?

Not natively in the UI. You would need to close the PRs, rebase the branches manually, and open new PRs with the corrected dependency chain. This is one of the preview limitations. If reordering is a common need, your PRs might be too tightly coupled.

How does this compare to Graphite or other stacking tools?

Third-party tools like Graphite offer more sophisticated CLI commands for rebasing entire stacks, navigating between PRs, and visualizing complex DAGs. GitHub's native implementation prioritizes simplicity and integration with the existing PR workflow. It's a subset of the functionality, but it's available without adding another tool to your chain. For most teams, the native version is sufficient. For teams with extremely complex stacking workflows (10+ concurrent stacks), a dedicated tool may still be warranted.

Does this work with protected branch rules?

Yes. Each PR in the stack must individually satisfy the branch protection rules of its target branch. If main requires a passing CI and an approving review, PR #1 must meet those requirements. PR #2 targets PR #1's branch, so it must satisfy the rules configured for that branch (which may be different).

What's the impact on git bisect?

A clean, top-down merge history makes git bisect more effective. Since each merged PR represents a small, logical change, a bisect will land on a commit that isolates a specific layer of the feature. This is a significant improvement over squash-merging a monolithic PR, where a bisect lands on a single commit touching 50 files.