Graphite Review (2026)

Graphite Overview

Graphite is an AI-powered developer productivity platform that reimagines the entire pull request lifecycle. Founded five years ago, the company raised a $52 million Series B and was acquired by Cursor (owned by Anysphere) in December 2025 for a reported price exceeding its $290 million valuation. As of early 2026, Graphite serves over 100,000 developers across more than 500 companies, including engineering teams at Shopify, Snowflake, Figma, Asana, Ramp, Vercel, Tecton, and Perplexity. The platform continues to operate as an independent product and brand under Cursor’s ownership, with deeper technical integrations planned throughout 2026.

Unlike most AI code review tools that add AI-generated comments to an otherwise unchanged PR workflow, Graphite rethinks the workflow itself. Its three core capabilities work together as an integrated system: stacked PRs let developers break large changes into small, reviewable increments that build on each other; the stack-aware merge queue validates and merges entire stacks atomically while running CI in parallel; and Graphite Agent provides AI code review with an industry-leading precision rate where less than 3 percent of comments are rated as unhelpful by developers. When Graphite Agent flags an issue, developers change the code 55 percent of the time, indicating that its feedback is genuinely actionable rather than noise.

Graphite occupies a unique position in the developer tools market because it competes both with AI code review tools like CodeRabbit and Qodo Merge, and with workflow platforms like GitHub’s native PR experience. The Cursor acquisition positions it to eventually bridge AI-powered code writing (through Cursor’s editor) and AI-powered code review (through Graphite’s platform) into a seamless end-to-end development experience. For teams using GitHub, Graphite represents the most holistic approach to solving PR bottlenecks available in 2026.

Feature Deep Dive

Stacked PRs for Incremental Development. Stacked PRs are Graphite’s foundational innovation. Instead of opening one large pull request with hundreds of lines changed, developers create a series of dependent PRs where each builds on the last. A developer can continue working on PR number three while PR number one and number two are still under review. When an earlier PR merges, subsequent stacked changes are automatically rebased, eliminating the manual conflict resolution that plagues traditional dependent-branch workflows. This approach reduces individual PR size, making reviews faster and more effective, while keeping developers unblocked.

Graphite Agent AI Code Review. Graphite Agent goes beyond explaining and critiquing code. It helps developers act on feedback by suggesting fixes, updating PRs, and facilitating the merge process. The agent maintains an unhelpful comment rate under 3 percent, which is the lowest reported rate among AI code review tools. This precision-first approach means developers trust the feedback and actually change their code in response, rather than dismissing comments as noise. The agent can be customized with team-specific review guidelines to focus on what matters most to your organization.

Stack-Aware Merge Queue. Traditional merge queues process PRs sequentially, running CI for each one in isolation. Graphite’s merge queue understands stacked PRs and can batch and test multiple PRs in parallel. When a stack is queued, it validates the entire stack as a unit by running CI on the top-most PR (which contains all downstream changes) and merges atomically. This approach dramatically reduces CI costs and wait times. Shopify projected CI cost savings of 15 to 25 percent across their organization by eliminating redundant stack CI runs, translating to hundreds of thousands of dollars annually.

PR Analytics and Cycle Time Dashboards. Graphite provides detailed analytics on PR review times, cycle times, time-to-merge, reviewer response times, and bottleneck identification. Engineering leaders get visibility into where the review process slows down and can make data-driven decisions about team structure, reviewer assignment, and process improvements. These metrics are broken down by team, repository, and individual contributor.

CLI-First Developer Workflow. Graphite’s CLI (gt) is the primary interface for creating and managing stacked PRs. The CLI handles branch creation, rebasing, syncing with upstream, and submitting stacks for review with minimal manual effort. While the CLI has a learning curve, developers who adopt it consistently report that it transforms their daily workflow. The CLI integrates with the web dashboard for visual stack management and review.

Automations and Review Rules. On the Team plan, Graphite supports automation rules that can automatically assign reviewers, apply labels, enforce review requirements, and trigger actions based on PR properties. Custom review guidelines tell Graphite Agent what to focus on, such as specific coding standards, security requirements, or performance patterns relevant to your codebase.

VS Code Extension. Graphite provides a VS Code extension that brings stack management and review features directly into the editor. Developers can view their stacks, check review status, and navigate between related PRs without leaving their IDE.

Startup Program. Early-stage startups can apply to Graphite’s Startup program, which provides a $1,500 credit equivalent to six months of Team plan access for up to five seats. This lowers the barrier for small teams that want to adopt the full Graphite workflow.

Pricing and Plans

Graphite uses a per-user subscription model with significant feature gating between tiers.

Free (Hobby) Plan. Includes the core Graphite CLI for stacked PRs, the VS Code extension, and limited access to Graphite Agent and AI reviews. This tier is sufficient for individual developers who want to experiment with stacked PRs and get a taste of AI review. However, the limited AI review credits mean it is not viable for regular team use.

Starter Plan ($20/user/month, billed annually). Adds support for all GitHub organization repositories, team insights, and additional Graphite Agent and AI review credits. This tier is appropriate for teams that want the stacked PR workflow and basic analytics but do not need unlimited AI reviews or the merge queue.

Team Plan ($40/user/month, billed annually). Unlocks the full Graphite experience: unlimited Graphite Agent access, unlimited AI reviews, review customizations, automations, the stack-aware merge queue, and priority support. This is the tier where Graphite’s full value proposition materializes, and it is the plan that enterprise customers like Shopify and Asana use.

Enterprise Plan (custom pricing). Adds SSO/SAML authentication, advanced analytics, custom integrations, dedicated support with SLA guarantees, and security and compliance features. Pricing is negotiated based on team size and requirements.

At $40/user/month for full AI review access, Graphite is more expensive than most dedicated AI review tools. CodeRabbit Pro costs $24/user/month, Qodo Merge Teams costs $19/user/month, and Panto starts at $12/developer/month. However, Graphite’s pricing reflects the fact that it is a comprehensive workflow platform, not just a review tool. Teams that adopt stacked PRs and the merge queue consistently report productivity gains that justify the premium. Shopify saw 33 percent more PRs merged per developer, and Asana reported engineers saving 7 hours per week. These gains typically exceed the cost of the tool within the first month.

How Graphite Works

Getting Started. Graphite integrates with GitHub (and only GitHub). Installation involves connecting your GitHub organization, installing the Graphite CLI (gt), and optionally adding the VS Code extension. The CLI is available via npm, Homebrew, or direct download. Once connected, Graphite overlays its workflow on top of GitHub’s existing PR system, meaning your PRs still appear as normal GitHub pull requests and can be reviewed by team members who are not using Graphite.

The Stacked PR Workflow. Using the Graphite CLI, a developer creates a stack of branches: gt create feature-part-1, then gt create feature-part-2 building on top, and so on. Each branch is submitted as a separate PR with gt submit. Graphite tracks the dependencies between branches and handles rebasing automatically when an earlier PR merges. The web dashboard and CLI both provide visualization of the stack, showing which PRs are pending review, approved, or merged.

AI Review with Graphite Agent. When a PR is opened, Graphite Agent analyzes the changes and posts focused, actionable comments. Unlike tools that generate large volumes of comments, Graphite Agent is tuned for precision, with the explicit goal of keeping the unhelpful comment rate below 3 percent. The agent considers the PR description, linked issues, and the team’s custom review guidelines when generating feedback. Importantly, the agent can also act on its own feedback: it can suggest fixes, update PRs, and help merge code, going beyond passive commentary.

The Merge Queue. When a PR (or stack of PRs) is approved and ready to merge, it enters Graphite’s stack-aware merge queue. The queue batches changes, runs CI, and merges atomically. If CI fails for a batch, Graphite automatically identifies the culprit and removes it from the queue. For stacked PRs, the queue validates the entire stack as a unit rather than processing each PR independently, which eliminates the “merge one, run CI, merge next, run CI” cycle that wastes time and compute.

Analytics and Insights. The analytics dashboard tracks metrics including cycle time (PR open to merge), review time (review request to approval), time in merge queue, PR size distribution, and reviewer load balancing. These metrics help engineering leaders identify bottlenecks and optimize their team’s review process.

Who Should Use Graphite

Fast-moving engineering teams that ship multiple PRs per developer per day are Graphite’s ideal users. The stacked PR workflow is most valuable when developers are frequently blocked waiting for reviews on one change before starting the next. If your team’s primary bottleneck is the PR review and merge process, Graphite addresses it more comprehensively than any other tool.

Medium-to-large engineering organizations (20+ developers) benefit most from Graphite’s analytics, merge queue, and automation features. At this scale, the visibility into review bottlenecks and the CI cost savings from the merge queue provide measurable ROI. Shopify and Asana’s reported results are representative of what large teams can expect.

Teams that value review precision over volume will appreciate Graphite Agent’s approach. If your team has been frustrated by AI review tools that generate too many low-value comments, Graphite’s under-3-percent unhelpful comment rate is compelling. The 55 percent code-change rate on flagged issues demonstrates that developers take the feedback seriously.

Engineering leaders who want data-driven process improvement benefit from Graphite’s analytics dashboard. The cycle time, review time, and bottleneck metrics provide actionable insights that can inform team structure, reviewer assignment, and process decisions.

Teams NOT well served by Graphite include those using GitLab, Bitbucket, or Azure DevOps (Graphite is GitHub-only), teams that want only AI code review without changing their PR workflow, organizations that find $40/user/month too expensive for what is functionally an add-on to GitHub, and teams where the stacked PR concept is unfamiliar and the learning curve represents an unacceptable productivity dip during adoption.

Graphite vs Alternatives

Graphite vs CodeRabbit. CodeRabbit is a dedicated AI code review tool that focuses on analyzing diffs and providing comprehensive comments with 40+ built-in linters. At $24/user/month for Pro, it is cheaper than Graphite’s $40/user/month Team plan. CodeRabbit supports GitHub, GitLab, Azure DevOps, and Bitbucket, while Graphite is GitHub-only. CodeRabbit provides more verbose, comprehensive reviews, while Graphite Agent prioritizes precision with fewer, higher-quality comments. The key differentiator is scope: CodeRabbit adds AI review to your existing workflow; Graphite transforms the entire workflow with stacked PRs, merge queue, and AI review as integrated components.

Graphite vs Qodo Merge. Qodo Merge (formerly CodiumAI) offers AI code review with an open-source self-hosted option (PR-Agent) and cloud Teams pricing at $19/user/month. Qodo focuses specifically on PR review and includes test generation capabilities. Graphite provides a broader platform with stacked PRs and merge queue but at a higher price point and without self-hosted options. Teams that want affordable, focused AI review should consider Qodo; teams that want to transform their entire PR workflow should consider Graphite.

Graphite vs GitHub Native PRs. GitHub’s built-in PR experience is free and familiar. GitHub has added a merge queue feature and, through Copilot Enterprise ($39/user/month), basic AI review capabilities. Graphite’s advantages include stacked PRs (which GitHub does not natively support), a more sophisticated merge queue, higher-precision AI review, and detailed analytics. For teams on GitHub Copilot Enterprise, Graphite adds approximately $1/user/month more for a substantially better workflow experience.

Graphite vs Ellipsis. Ellipsis is an AI code review tool focused on generating code and fixing bugs automatically, also GitHub-only. Ellipsis is more focused on the review-and-fix loop, while Graphite provides the broader workflow platform. At $20/user/month, Ellipsis is cheaper for teams that want AI review without stacked PRs and merge queue.

Pros and Cons Deep Dive

Strengths:

The stacked PR workflow is a genuine productivity multiplier. Development teams that adopt stacked PRs report meaningful improvements: Shopify saw 33 percent more PRs merged per developer, and Asana engineers saved 7 hours per week each. Across 125 engineers at Asana, that represents 83 hours per week recovered from merge process overhead. These are not theoretical gains but measured results from real engineering organizations.

Graphite Agent’s precision is exceptional. At less than 3 percent unhelpful comments, it has the best reported signal-to-noise ratio of any AI code review tool. The 55 percent code-change rate on flagged issues further validates that developers trust and act on the feedback. This stands in contrast to tools where developers routinely dismiss AI comments as irrelevant, which eventually leads to the entire tool being ignored.

The Cursor acquisition provides significant strategic value. Cursor is one of the fastest-growing AI coding tools, and the integration potential between AI-powered code writing (Cursor) and AI-powered code review (Graphite) could create a seamless development-to-review pipeline. The acquisition also provides Graphite with significantly greater financial resources and engineering talent.

The merge queue’s CI cost savings are substantial at scale. By batching stacked PRs and running CI on the aggregate rather than individual changes, teams reduce CI compute costs by 15 to 25 percent. For organizations like Shopify that spend hundreds of thousands of dollars on CI annually, these savings partially or fully offset the cost of Graphite itself.

Weaknesses:

The GitHub-only limitation is Graphite’s most significant constraint. Teams using GitLab, Bitbucket, or Azure DevOps simply cannot use Graphite, which eliminates a large portion of the market. There has been no public commitment to supporting additional platforms, and the Cursor acquisition may further cement the GitHub-first direction.

The $40/user/month Team plan pricing is high for teams that primarily want AI review. If stacked PRs and the merge queue are not part of your workflow, you are paying nearly double what CodeRabbit charges for dedicated AI review ($24/user/month) without the broader platform benefits. The pricing only makes sense for teams that adopt the full Graphite workflow.

The stacked PR learning curve is real. Teams that have never worked with stacked diffs (common in Mercurial and Phabricator workflows but rare in Git) need time to learn the concept, the CLI, and the mental model. During the transition period, productivity may temporarily decrease before the long-term gains materialize. Some developers find the CLI-first approach less intuitive than GUI-based workflows.

The Cursor acquisition introduces product direction uncertainty. While Graphite continues operating independently for now, long-term integration decisions could change the product in ways that benefit Cursor users but not teams that use Graphite standalone. Teams should consider whether they want their code review platform’s direction influenced by an IDE company.