GitHub Just Shipped Stacked PRs for Free. Graphite Should Be Worried.

GitHub just ate a startup's lunch

On July 30, 2026, GitHub pushed stacked pull requests into public preview. No waitlist. gh extension install github/gh-stack and you're in.

If that phrase means nothing to you, here's the pitch: instead of opening one 1,200-line PR that sits in review purgatory for a week, you split it into a chain of small PRs, each one building on the last. Reviewers approve layer by layer. You merge the whole stack — or just the bottom layer — with one click, and everything above it retargets and rebases automatically.

This isn't a new idea. It's literally how Google and Meta have shipped code internally for over a decade. What's new is that GitHub just built it natively into the product, and in doing so, put a target on the back of every startup that's been selling this exact workflow as a subscription.

Graphite — founded by ex-Meta engineers, funded to the tune of tens of millions — charges $20-40/user/month for stacked PR tooling. Aviator does something similar. Both companies exist because GitHub didn't do this for fifteen years. Now GitHub did it, for free, inside the UI you already have open all day.

That's not a feature launch. That's a company getting sherlocked in front of 100 million developers.

How it actually works

Forget the marketing page. Here's the real workflow.

gh extension install github/gh-stack

# branch 1: the boring foundational change
git checkout -b feat/db-schema
# ...make your change, commit...
gh pr create --title "Add tenant_id column"

# branch 2: builds on branch 1, not main
git checkout -b feat/api-layer
# ...make your change, commit...
gh pr create --title "Wire tenant_id through the API"

# branch 3: builds on branch 2
git checkout -b feat/ui
gh pr create --title "Add tenant switcher to settings UI"

Each PR targets the branch below it, not main. GitHub renders a stack map right in the PR UI so reviewers can jump between layers without losing context. When you fix something in layer 1 after review feedback, you run:

gh stack sync

That cascades the rebase up the whole stack and force-pushes every branch atomically. No more manually rebasing three branches by hand and praying you didn't fat-finger a conflict resolution on branch 2.

Branch protection rules apply to the final target branch (usually main), not each PR's immediate base — so you don't need to configure required checks four times. CI runs against each PR as if it targeted main directly, which is the part that used to require real infrastructure work if you rolled your own.

It's already wired into the CLI, the web UI, GitHub mobile, and — because it's 2026 and everything needs an agent story — Copilot can drive the whole thing through a gh-stack skill.

The endorsements aren't nobody either: Tim Neutkens (Next.js lead at Vercel) says it let them ship large features in smaller pieces without the usual pain. John Resig — yes, that John Resig — posted about landing five stacked PRs directly into a merge queue in one shot.

The catch nobody's screenshotting

Here's where the crack-engineer part of this post starts, because every "GitHub just killed Graphite" hot take conveniently skips this.

Squash and rebase merges break the stack. They rewrite commit hashes, which destroys the identity tracking that links your branches together. If your team squash-merges everything (and a lot of teams do, because it keeps main clean), your intermediate PRs in a stack need to land as regular merge commits or the chain snaps. That's a real workflow change, not a footnote.

Merge queue support is still rolling out. As of public preview, it's shipping "progressively over coming weeks" — meaning if your org leans on merge queues for high-traffic repos (which is exactly the kind of repo that benefits most from stacking), you're not getting the full experience day one.

There's a practical ceiling. Data from an analysis of 1.5 million PRs backs up what anyone who's used Graphite already knows: PRs in the 200-400 line range get reviewed 3x faster and ship 40% fewer defects than bigger ones. But stacks don't scale infinitely — three to four PRs deep is where most teams top out before the cognitive overhead of tracking the stack outweighs the benefit of small diffs. If you're dreaming of 10-deep stacks, you're going to have a bad time regardless of tooling.

It's public preview, not GA. Preview features change shape. Don't build your team's entire review process around the exact command syntax today — gh-stack went from private preview (April 2026) to public preview (July 2026) in under four months, which is fast-moving by GitHub standards.

So, do you cancel Graphite?

Depends on what you're actually paying for.

If your team uses Graphite purely for stack management — creating, syncing, and merging stacked branches — GitHub's native version does the core job for free, and it has one structural advantage Graphite can never fully match: the enforcement logic lives inside the PR itself. No separate account, no extension your reviewers need to install, no context-switching to a different web app to see the stack map. That's a real moat, and it's GitHub's alone.

If you're paying Graphite for the parts GitHub doesn't touch — their AI code review, their merge queue polish, years of squash-merge edge cases they've already solved that GitHub v1 is still working through — that's a different conversation. Graphite didn't get replaced overnight. It got its core value prop commoditized, which is worse for their pitch deck but doesn't mean their product stopped working.

My honest take: if you're a small-to-mid team just now considering adopting a stacked PR workflow, start with gh-stack. It's free, it's native, and it removes the "we'd need to buy another tool" objection that's killed this workflow at plenty of companies. If you outgrow it — hit the merge queue gaps, need the AI review layer — that's when you evaluate Graphite with actual leverage, instead of paying up front for a problem you haven't hit yet.

Stacked PRs stop being a "big company" workflow the day the tool to run them costs nothing and lives where your reviewers already are. That day just happened.

Try it

gh extension install github/gh-stack
gh stack create

Docs: gh.io/stacks. Feedback thread: gh.io/stacks-feedback. Go break your first stack on a side project before you touch a real one — you will mess up the rebase order at least once, and it's better to learn that on code nobody's reviewing.