View as Markdown

Mergify Stacks vs Graphite

An honest comparison of Mergify Stacks and Graphite's stacking workflow.


Graphite is a developer workflow platform built around stacked pull requests. It ships a CLI (gt), a custom PR review UI, AI reviews, and a merge queue. This page focuses on how the two tools handle stacking: how you create, update, and land a chain of PRs. A short Beyond stacks section near the end covers how the broader platforms differ.

Both tools solve the same core problem (big PRs are hard to review, so split them into a chain of small ones), but they take different approaches to get there.

The biggest difference is how each tool thinks about branches.

Mergify Stacks Graphite
Local model One branch, many commits One branch per PR
Identity Change-Id trailer in commit message Branch name
Who manages branches Mergify auto-creates remote branches Developer creates and names them
Mental model “Chain of commits” “Chain of dependent branches”

Both produce the same result on GitHub: chained PRs where each targets the previous one’s branch. The difference is what you deal with locally.

Mergify Stacks: one branch, many commits

Section titled Mergify Stacks: one branch, many commits

You work on a single branch. Each commit maps to a PR automatically:

feat/auth A B C PR #1 base: main PR #2 base: PR #1 PR #3 base: PR #2 feat/auth A B C PR #1 base: main PR #2 base: PR #1 PR #3 base: PR #2

Under the hood, mergify stack push creates a remote branch per commit and chains the PRs:

Local Commits Remote Branches GitHub PRs A: add model stack/.../add-model--a1b2c3d4 PR #1 B: add endpoint stack/.../add-endpoint--d4e5f6a7 PR #2 C: add tests stack/.../add-tests--b7c8d9e0 PR #3 Local commit Remote branch GitHub PR A: add model stack/.../add-model--a1b2c3d4 PR #1 B: add endpoint stack/.../add-endpoint--d4e5f6a7 PR #2 C: add tests stack/.../add-tests--b7c8d9e0 PR #3

You never see or manage these remote branches. They're an implementation detail.

You create and name a separate branch for each change with gt create. Each branch becomes a PR that targets the branch below it:

main A A' B C C' add-model base: main add-endpoint base: add-model add-tests base: add-endpoint main A A' B C C' add-model base: main add-endpoint base: add-model add-tests base: add-endpoint

Three branches, three PRs: add-model targets main, add-endpoint targets add-model, add-tests targets add-endpoint. You navigate between them with gt up, gt down, gt top, and gt bottom.

Feature Mergify Stacks Graphite
Create a stack mergify stack new <name> + commits gt create [name] per branch
Push changes mergify stack push (rebase + push + PRs) gt submit (force-push + PRs)
View the stack mergify stack list gt log
Edit mid-stack mergify stack edit <commit> (targeted pause) gt modify (auto-restacks)
Absorb fixups Not supported gt absorb (auto-routes staged hunks)
Split a commit Not supported gt split (by commit, hunk, or file)
Reorder changes mergify stack reorder or mergify stack move gt reorder (interactive)
Squash / fold mergify stack squash or mergify stack fixup gt squash / gt fold
Undo Git reflog gt undo (reverts recent gt operations)
Sync after merge mergify stack sync gt sync
Navigate between PRs N/A (single branch) gt up / down / top / bottom
Open PR in browser mergify stack open (interactive picker) gt pr
Collaboration mergify stack checkout Shared stacks + frozen branches
Branch naming Auto-generated (configurable) Developer-chosen
Alternate base branch mergify stack new <name> --base <remote>/<branch> Multi-trunk support
IDE integration CLI only VS Code extension
AI agent integration Skills for Claude Code and skills.sh agents gt mcp
Merge Queue Native Mergify integration Graphite merge queue
Merge a stack Bottom-up via Merge Queue gt merge (stack-aware)

Simpler Git model. One branch, standard Git. You don’t create branches or navigate between them. You commit and rebase like you already do. The branching complexity lives on the remote side where you don’t have to think about it. Graphite’s one-branch-per-PR model is more expressive but asks you to learn a new set of commands (gt up, gt down, gt modify, gt restack) and keep a tree of local branches in your head.

One command does more. mergify stack push rebases on the target branch, pushes all changes, and creates or updates PRs in a single step. Graphite splits the flow across several operations (gt create, gt modify, gt submit) depending on where you are in the stack.

Merge Queue depth. Mergify’s Merge Queue has batching, priority lanes, speculative checks, and queue pause. Graphite has a merge queue too; Mergify’s is more configurable and has been in production longer.

No one else needs Mergify. Only the stack author installs the CLI. Reviewers, teammates, and anyone else interacting with the PRs use GitHub’s native UI: no Mergify sign-up, no install, no account required. Graphite’s full review, navigation, and approval flow lives inside the Graphite app, so to get the complete experience everyone on the team needs a Graphite account.

gt absorb saves real time. After a review round, you often need to amend several commits with different fixes. Graphite’s gt absorb looks at your staged hunks and routes each one into the commit that last touched those lines. Mergify doesn’t have an equivalent; you amend each commit by hand.

gt split breaks big commits apart. When a commit grows too large during development, gt split carves it into smaller commits by file or hunk. Useful when what started as one change turns out to need separating for review.

gt undo is a safety net. Graphite tracks its own operations and can revert them with a single command. Mergify relies on Git’s reflog, which is harder to navigate when something goes sideways.

Frozen branches for collaboration. Graphite can freeze branches that other contributors are working on to prevent accidental force-pushes. mergify stack checkout supports handoff too, but Graphite’s explicit locking prevents more foot-guns on shared stacks.

IDE integration. Graphite has a VS Code extension that lets you manage the stack visually. Mergify is CLI-only today.

Stacking is one feature of Graphite, not all of it. The rest of the product includes:

  • AI reviews and Graphite Chat: automated review comments and an AI assistant that answers questions and edits code on PRs.

  • Custom PR review UI: inbox, code tours, diff versions, keyboard shortcuts.

  • Developer velocity analytics: PR throughput, review time, per-person metrics.

  • Native integrations: Linear, Slack (including review and merge from Slack).

Mergify has invested in a different direction:

  • Rules engine: 70+ pull request attributes, 18 actions, cascading logic for Workflow Automation.

  • Merge Queue maturity: batching, priority lanes, speculative checks, queue pause.

  • CI and test intelligence: CI Insights for cost and timing analytics, flaky test detection, quarantine, and test reporting.

  • Open CLI, review in GitHub: Stacks works with GitHub’s native review UI; there’s no separate app to learn.

If AI review and a custom PR experience are what you want, Graphite is built around that. If you want a deep Merge Queue, Workflow Automation, and CI/test intelligence, Mergify is built around that. For stacking alone, the choice comes down to the Git model and the feature gaps above.

Pricing. The Mergify CLI and Stacks are free and work without a Mergify subscription. Graphite has a free tier for the CLI and charges for platform features (AI reviews, merge queue, analytics) on team and enterprise plans.

Platform support. Both tools target GitHub today.

Review surface. Graphite encourages review inside its own app. Mergify Stacks keeps review in GitHub’s native UI, which matters if your team doesn’t want to move PR review off GitHub.

If you’ve been using Graphite and want to try Mergify Stacks, the main shift is moving from “one branch per PR” to “one commit per PR on a single branch.”

Terminal windowbash
curl -fsSL https://raw.githubusercontent.com/Mergifyio/mergify-cli/main/install.sh | sh
mergify stack setup

This installs the CLI and adds a commit-msg hook that generates Change-Ids for your commits. See the setup guide for details.

Graphite Mergify Stacks
gt create (create a branch) git commit (create a commit)
gt modify git commit --amend or mergify stack edit <commit>
gt submit mergify stack push
gt up / down / top / bottom Not needed (single branch)
gt restack Automatic on mergify stack push
gt sync mergify stack sync
gt log mergify stack list
gt absorb No direct equivalent (amend each commit by hand)

With Graphite:

Terminal windowbash
gt create add-model
# work on first change
gt create add-endpoint
# work on second change
gt submit

With Mergify Stacks:

Terminal windowbash
mergify stack new feat/my-feature
git commit -m "add model"
git commit -m "add endpoint"
mergify stack push

The result on GitHub is the same: two chained PRs, each showing one change.

Was this page helpful?