Table of contents
- Introduction to Graphite
- History and development
- Key features and what they do
- Why teams are using Graphite today
- Installation and setup
- Onboarding and support
- Conclusion
- FAQ
Introduction to Graphite
Graphite is a developer platform that layers on top of Git and GitHub to make code review, change management, and delivery faster, smoother, and more predictable. It centers around stacked diffs (or stacked pull requests) — sequences of small, dependent changes — and complements them with automation, AI tools, and dashboards so that teams can ship high-quality code more often and with less friction.
History and development
Graphite was inspired by the code review systems used at major tech companies like Google and Meta. The founders, who have experience with the stacked diffs workflow at these companies, realized the potential of this system for improving productivity and decided to make it accessible for teams using GitHub.
Key features and what they do
Below are what Graphite offers today, with explanations of why each feature matters.
| Feature | What Graphite does | Why teams care |
|---|---|---|
| Stacked diffs / stacked pull requests | You can break big changes into smaller, dependent ones. Each pull request in the stack builds on the previous, so work can continue even if earlier diffs are waiting review. Graphite’s CLI and UI help manage creation, rebasing, restacking, syncing, and ordering of these stacks. | Reduces code review size and cognitive load; allows parallel progress; fewer large merge conflicts; faster feedback loops. |
| Bidirectional sync with GitHub and Git tooling integration | Changes in Graphite stay synced with GitHub and your local Git branches. Tooling (CLI, VS Code extension) works alongside existing Git workflows. | Low friction adopting Graphite; teams don’t have to rewrite workflows; consistency across team environments. |
| Merge queue and smarter CI | Graphite lets you queue pull requests such that they merge in the proper order, managing dependencies. CI runs are optimized — skipping redundant tests, only triggering what’s needed. | Helps keep main branches green; reduces wasted CI time and cost; less manual work managing merge order. |
| AI-powered review tools (Graphite Agent) | Automatic scanning of opened PRs for bugs, logical errors, style or pattern issues. It’s context-aware (it knows about the rest of the codebase) to avoid pointless comments. High-signal feedback, low false positives (claimed < 3 %). | Speeds up the first pass of reviews; frees up human reviewers to focus on architecture and design rather than nitpicks; improves code quality earlier. |
| Chat / interactive assistant in PRs | Ability to ask questions in-context in a pull request, request improvements or suggested fixes directly, converse with code change history, and more with Graphite Chat | Reduces context switching; helps contributors understand changes; aids onboarding and knowledge sharing; fewer misunderstandings. |
| Visibility, insights, and metrics | Dashboards that track throughput, PR wait times, merge queue performance, and bottlenecks in review flow. You get historical trends to see where the slowdowns are. | Helps engineering leads and managers make informed decisions; identifies blockers; continuously improves process. |
| Privacy and security considerations | Code stays private; AI tools are built to avoid leaking or mis-training on your source; integrates with your existing Git / GitHub permissions. | Reduces risk when adopting new tools; important for regulated or proprietary codebases. |
Why teams are using Graphite today
Teams adopt Graphite now because of a confluence of pressures, opportunities, and tool maturity. These are the main drivers:
Speed of iteration matters more than ever As feature cycles shorten, internal and external expectations increase. Teams don’t want developers waiting days for reviews; stacked diffs and fast AI feedback help keep momentum.
Volume of code and contributors has grown Open source, distributed teams, remote developers, contractors: many people may be contributing. Better workflows and tooling are needed to keep review scalable without wiping out reviewer bandwidth.
Cost of CI and review cycles climbs Running full suites over big PRs, or waiting for merged dependencies, or manually managing rebases: all of that costs time and infrastructure. Automation and smarter CI optimizations help reduce those costs.
Quality doesn’t scale automatically Code quality, style consistency, catching bugs early: as teams move faster, human reviewers may miss things. AI-assisted tools like Graphite Agent act as a guardrail while preserving human oversight.
Avoiding merge conflicts and maintenance debt Big PRs often lead to conflicts or large refactors later. Incremental changes, frequent rebases, and dependency sequencing make codebases more stable and maintainable over time.
Visibility drives continuous improvement With metrics and dashboards, teams see where reviews lag, where CI is slow, and where people are overloaded. That feedback loop lets them tune process, distribution of reviewer load, or adjust policies.
Lower risk of adopting new tools Graphite fits into existing Git and GitHub workflows; minimal disruption. The barrier to try it is lower now — you can start with small feature teams, try stacked diffs on one repo, then gradually roll out.
Installation and setup
Getting started with Graphite is straightforward and designed to integrate seamlessly with your existing Git and GitHub workflows:
Installation options:
- npm:
npm install -g @withgraphite/graphite-cli@stable - Homebrew:
brew install withgraphite/tap/graphite - Direct download: Available from the Graphite website
Initial setup:
- Authenticate with GitHub: Run
gt authto connect your GitHub account. - Initialize in your repo: Use
gt repo initto set up Graphite in your repository. - Create your first stack: Start with
gt branch create "feature-name"to create a new branch.
Onboarding and support
Team onboarding best practices:
- Start small: Begin with a single repository or small team to build familiarity
- Commit to the process: Teams typically see full benefits after 1-3 months of consistent use
- Gradual rollout: Expand usage across teams and repositories as confidence grows
- Leverage AI features: Enable [Graphite Agent](https://graphite.dev/docs/Graphite Agent-setup) for automated code reviews and Graphite Chat for interactive assistance
Conclusion
Graphite is an innovative solution for modern development teams looking to improve their code review and management workflows. Its focus on stacked changes, combined with an intuitive CLI, seamless GitHub integration, and cutting-edge AI features like Graphite Chat and Graphite Agent, positions Graphite as a powerful ally in the realm of developer tools. The AI-powered capabilities accelerate development cycles while maintaining privacy and security standards, making Graphite a comprehensive solution for teams seeking to optimize their code review process.
FAQ
How does Graphite differ from traditional Git workflows?
Graphite builds on top of Git and GitHub, adding stacked diffs workflow and AI-powered features. While traditional Git requires manual branch management and large PRs, Graphite automates dependency management and breaks work into smaller, reviewable chunks.
Is Graphite compatible with my existing Git and GitHub setup?
Yes! Graphite integrates seamlessly with your existing Git and GitHub workflows. You can start using Graphite alongside your current processes without disrupting your team's workflow.
Does Graphite work with private repositories?
Yes, Graphite supports both public and private repositories on GitHub. All data remains secure and private, with AI features maintaining strict privacy standards.
Can I try Graphite before committing my team?
Absolutely! Graphite offers a free tier that allows individual developers to try the platform. You can start with a single repository and gradually expand usage as you see benefits.