Cursor’s Anysphere Buys Graphite 2026: What Changes for Devs

Anysphere, the company behind Cursor, is buying Graphite — the stacked-PR and AI code-review startup that many fast-moving teams already wedged into their GitHub workflow. The Anysphere Graphite acquisition is the clearest signal yet that the AI coding market has stopped being a land grab for autocomplete and is now a fight over the entire loop: write, review, merge, ship. It lands mid-repricing for the whole category, with Anthropic IPO chatter pulling valuations sideways and every dev-tool vendor suddenly needing a story about owning more of the pipeline. If you pay for Graphite, CodeRabbit, or Greptile today, this is the week to decide whether code review belongs to your IDE vendor or stays independent.

What’s actually new in the Anysphere Graphite acquisition

Graphite built its reputation on two things. First, stacked pull requests: breaking one large change into a chain of small, dependent PRs so reviewers see 80-line diffs instead of 1,200-line ones. Second, Diamond — its AI reviewer, which comments on PRs with context-aware feedback specific enough that teams stopped treating bot review as noise. Anysphere is folding both into Cursor, which already ships Bugbot as its own background reviewer.

The strategic logic is not subtle. Cursor knows what you were doing when you wrote the code — which files you had open, which prompts you ran, which suggestions you accepted, what the agent refactored three commits ago. A GitHub-side reviewer sees only the diff. Merging Graphite’s review layer into the editor gives the reviewer the authoring context, a real technical advantage rather than a marketing one. Stacked PRs get the same benefit: if Cursor’s agent produced the change, it can split that change into a reviewable stack instead of leaving you to untangle it in git rebase -i afterward.

Watch what happens to Graphite as a standalone product. Acquisitions in this category go both ways — sometimes the product runs for years, sometimes it becomes a feature and the CLI quietly stops getting releases. Graphite’s gt CLI has real users with real muscle memory, and Anysphere has an incentive to keep them happy through the transition. The long-run pull, though, is toward Cursor as the surface and everything else as plumbing.

Why the Anysphere Graphite acquisition matters

• Review context stops being a diff problem. Cursor AI code review that knows your prompt history and agent runs can flag “this contradicts the constraint you gave the agent in the last commit” — something a diff-only reviewer structurally cannot do.
• Your IDE choice starts dictating your review stack. If review quality becomes a Cursor feature, a team standardizing on Zed, VS Code, or JetBrains inherits a worse default. That is exactly the lock-in consolidation is designed to create.
• Independent reviewers now differentiate on neutrality. CodeRabbit and Greptile can credibly sell “works with every editor, every language, every CI” — a real pitch to any org running more than one editor.
• Graphite stacked PRs may go mainstream by distribution, not persuasion. Stacking has always been technically great and socially hard to adopt. Bundled into an editor a few million developers open every day, the adoption curve changes.
• Per-seat budgets are about to get consolidated. Finance teams paying for Cursor plus Graphite plus a review bot will ask the obvious question, and the bundled vendor usually wins that conversation regardless of feature parity.
• Dev tool consolidation raises the switching cost of everything. When authoring, review, and merge policy live in one vendor, migrating off stops being an editor swap and becomes a workflow migration.

How to use it today

1. Audit what you are actually paying for. Get the real numbers before any migration decision. Check which repos have review bots installed and how often they comment:

   gh api /repos/:owner/:repo/pulls?state=closed^&per_page=50 \
     --jq '[.[] | {number, user: .user.login, merged_at}] | length'
   
   gh api /repos/:owner/:repo/issues/comments?per_page=100 \
     --jq '[.[] | select(.user.type == "Bot") | .user.login] | group_by(.) | map({bot: .[0], comments: length})'

   If a bot posted 400 comments and your team resolved 12, you are paying for noise and the vendor question is moot.

2. Learn stacking before it gets bundled. The workflow earns its keep on its own merits. With Graphite’s CLI:

   gt repo init
   gt create -am "feat: add rate limiter interface"
   gt create -am "feat: implement token bucket backend"
   gt create -am "feat: wire limiter into API middleware"
   gt submit --stack

   That produces three small PRs, each targeting the one below it. When review lands on PR 1, restack the rest:

   gt sync
   gt restack
   gt submit --stack

3. Turn on Bugbot and give it a real rulebook. Cursor’s reviewer respects your repo rules. Put standards in .cursor/rules/review.mdc so feedback matches your codebase instead of generic lint advice:

   ---
   description: Code review standards for this repo
   alwaysApply: true
   ---
   
   - Flag any DB query inside a loop; require batching or a single joined query.
   - Every new public function needs a test in the sibling *_test file.
   - Reject `any` in TypeScript unless the line has an explanatory comment.
   - Auth checks belong in middleware, never inline in a route handler.
   - Do not comment on formatting; Prettier owns that.

4. Keep a vendor-neutral fallback in CI. Whatever happens to pricing, a reviewer you control in your own pipeline is leverage. A minimal GitHub Actions step that calls a model directly on the diff:

   name: diff-review
   on: pull_request
   
   jobs:
     review:
       runs-on: ubuntu-latest
       steps:
         - uses: actions/checkout@v4
           with:
             fetch-depth: 0
         - name: Collect diff
           run: git diff origin/${{ github.base_ref }}...HEAD > /tmp/diff.patch
         - name: Review
           env:
             ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           run: |
             jq -Rs '{
               model: "claude-sonnet-5",
               max_tokens: 2000,
               messages: [{
                 role: "user",
                 content: ("Review this diff. Report only correctness bugs, \
                           security issues, and missing error handling. \
                           Cite file and line. Diff:\n" + .)
               }]
             }' /tmp/diff.patch > /tmp/body.json
   
             curl -s https://api.anthropic.com/v1/messages \
               -H "x-api-key: $ANTHROPIC_API_KEY" \
               -H "anthropic-version: 2023-06-01" \
               -H "content-type: application/json" \
               -d @/tmp/body.json | jq -r '.content[0].text'

   Thirty lines of YAML makes a weak reviewer next to a dedicated product, but no acquisition can take it away from you.

5. Measure before you commit. Run two reviewers in parallel for two weeks on the same PRs and score them on one metric: findings that led to a code change before merge. Track it in a plain file your team can argue with:

   | pr  | reviewer   | findings | acted_on | false_positives |
   |-----|------------|----------|----------|-----------------|
   | 812 | bugbot     | 6        | 3        | 2               |
   | 812 | coderabbit | 11       | 2        | 8               |

   Precision matters more than recall here. A reviewer your team learns to ignore is worth zero, however many real bugs it technically found.

How the AI code review tools of 2026 compare

Tool	Where it runs	Stacked PR support	Editor context	Best fit
Cursor (Bugbot + Graphite)	Editor and PR	Yes, via Graphite	Full — prompts, agent runs, open files	Teams already standardized on Cursor
Graphite standalone	PR only	Yes, native	Diff only	Existing gt users through the transition
CodeRabbit	PR and CI	No	Diff plus repo indexing	The CodeRabbit alternative pitch: mixed-editor orgs
Greptile	PR	No	Whole-codebase graph	Large legacy monorepos
GitHub Copilot review	PR	No	Diff plus Copilot history	Shops deep in the GitHub Enterprise stack
Self-hosted CI reviewer	CI	Manual	Whatever you feed it	Regulated environments and cost control

What’s next

Watch packaging first. If stacked review shows up in Cursor’s existing business tier at no extra cost, that is a deliberate margin sacrifice to make standalone review tools look like an unnecessary line item — and it will work on plenty of finance teams. If it lands as a separate add-on, the independents keep breathing room and the deal reads more like talent-and-technology than bundling.

Watch whether Graphite’s CLI stays genuinely open. Stacking is a git workflow, not a product, and credible open-source paths exist: git-branchless, Sapling, plain git rebase --update-refs. If gt starts requiring a Cursor account, expect a fast migration by the exact power users who made Graphite worth buying. Track the release cadence on the CLI repo, not the blog posts.

Third, watch how the rest of the market answers. Dev tool consolidation of this kind usually triggers counter-moves within a quarter or two: independent reviewers signing editor-agnostic partnerships, GitHub tightening its own native review, and someone loudly repositioning as the neutral option. The macro backdrop matters too. With Anthropic IPO speculation resetting how the market values AI infrastructure, buying a category-adjacent startup gets cheaper than building the same thing, and more of these deals are coming. Whatever you build your workflow on this year, assume the vendor list gets shorter.

Frequently Asked Questions

Does the Anysphere Graphite acquisition mean Graphite is shutting down?

No. The stated plan is integration into Cursor, not shutdown, and existing Graphite users keep their workflow through the transition. The realistic risk is slower independent development over time — feature velocity on a standalone product typically drops once the acquirer’s surface becomes the priority. Keep your stacking workflow portable and you are fine either way.

Do I need Cursor to use stacked PRs?

No. Stacking is a git technique. git rebase --update-refs handles the mechanics natively, and git-branchless or Sapling give you a fuller experience without any vendor relationship. Graphite made stacking pleasant; it did not invent it.

Is Cursor AI code review actually better than CodeRabbit or Greptile?

It is different rather than uniformly better. Cursor’s advantage is authoring context — it knows what the agent was told to do, not just what changed. Greptile’s advantage is whole-codebase understanding, which matters more in large legacy systems. CodeRabbit’s advantage is neutrality and breadth of integrations. Run them in parallel on your own PRs for two weeks and score acted-on findings; the answer is repo-specific.

What happens to our review tooling if we use multiple editors?

Multiple editors is the strongest reason to keep an independent reviewer. If half your team is on JetBrains or VS Code, an editor-bound reviewer gives you inconsistent coverage and a two-tier review culture. In mixed-editor orgs, a CodeRabbit alternative that runs in CI or on the PR is usually the safer architecture.

How does this relate to Anthropic IPO news?

Indirectly but genuinely. Public-market interest in AI infrastructure resets valuations across the category, which changes the build-versus-buy math for every vendor with capital. Consolidation accelerates in that environment. It does not change what any specific tool does tomorrow — it changes how many independent tools still exist in eighteen months.

Should we switch review tools right now?

No. Switching on announcement day is how teams end up migrating twice. Wait for pricing and packaging details, run a two-week bake-off with a precision metric, and make sure whatever you pick can be replaced — repo-level rules in version control, a fallback CI reviewer, and a stacking workflow that survives without any particular vendor.