Graphite
Graphite helps development teams create stacked pull requests, review code changes and manage GitHub-based workflows without waiting for every change to merge.
Why it caught my attention
Pull requests are easier to review when they contain one focused change, but real development work rarely fits neatly into isolated tasks. Graphite's stacked pull requests let developers build new changes on top of earlier ones while keeping each review separate. That changes how work can progress.
What problem does this actually solve?
Graphite could be worth considering if you recognise any of these challenges.
Waiting for earlier changes
Developers can continue related work while previous pull requests await review or merging.
Large changes are difficult to review
Related work can be divided into smaller pull requests, giving reviewers a more focused set of changes.
Dependent branches become difficult to manage
Graphite helps update and reorganise connected branches as earlier changes are revised or merged.
Reviews lose context and momentum
Reviewers can see how related pull requests fit together and concentrate on individual changes.
Is this a good fit for you?
A quick way to see if Graphite is relevant for your situation.
- Your development team uses GitHub pull requests for code review.
- You regularly work on changes that depend on other unmerged changes.
- Large pull requests make reviews slow or difficult to understand.
- You want smaller reviews without constantly switching between unrelated tasks.
- Your team wants a more structured way to manage review queues.
- Your team does not use GitHub for its code review workflow.
- Your changes are usually small, independent and reviewed quickly already.
How does it work?
In practice, the workflow looks something like this:
Set up Graphite for your GitHub workflow and install its command-line tool to work with local branches.
Make a focused change, then create another branch on top of it for the next related piece of work.
Publish the stack to GitHub so each branch becomes a separately reviewable pull request with its dependencies preserved.
Reviewers examine individual pull requests while developers address feedback and update dependent branches using Graphite's stack management tools.
Once changes are approved and required checks pass, merge them in dependency order, using Graphite's supported merging workflow.
What else should I know?
A few important things to be aware of before you investigate further.
GitHub is central to the workflow
Graphite builds on GitHub pull requests rather than replacing GitHub as the underlying code hosting platform.
Stacked changes introduce dependencies
Later pull requests depend on earlier changes, so revisions and merging need to respect the stack's order.
Teams need to adopt stacking practices
Developers and reviewers may need to adjust existing branch management and review habits to benefit from stacked pull requests.
Features and pricing vary
Check current plan limits, team features and access to automation or AI-assisted review before choosing a subscription.
Think Graphite could fit your environment?
Visit the Graphite website to find out more, request a demo or speak to their team.
Something you'd like to know about Graphite?
Is there something I haven't covered in my research? Send me your question and I'll look into it and reply personally by email.