Cursor Is Building the Workflow

Cursor Is Building the Workflow. Everyone Else Is Still Arguing About Tools.

The more I think about recent Cursor’s acquisition of Graphite, the clearer the pattern becomes. This is not about stacked diffs alone. It’s not even about code review. It’s about who is thinking end-to-end about how software gets built when AI agents are no longer a sidekick, but an active participant.

Right now, most dev tooling still assumes one thing: code lives in Git, humans write it, and pull requests are the unit of progress. AI is bolted on around that model. Cursor is questioning the model itself.

That’s the difference.

Git Is Showing Its Age

One of the most underrated points in this discussion is the limitation of Git in AI-driven workflows. Git works extremely well for what it was designed for: human-authored code, line-based diffs, and a relatively small amount of contextual metadata.

But agentic workflows produce far more than code. They produce

• trajectories,
• intermediate decisions
• abandoned paths,
• rationale that matters during review

None of that fits naturally inside Git. Today, teams either drop that context on the floor or store it in ad-hoc systems glued onto PRs.

Some newer version control systems already hint at where this could go: architectures that treat metadata as a first-class concept rather than an afterthought. That flexibility turns out to be very useful once you want to record how an agent arrived at a change, not just the final diff.

This is why the idea that “Git is fine, just add better tooling around it” feels incomplete. Tooling can paper over limitations for a while, but when workflows fundamentally change, the storage model eventually comes under pressure too.

Ohh yeh, the Git/Github are not disappearing tomorrow. But it’s increasingly clear that it was not built with AI agents in mind.

Why the Graphite Acquisition

Graphite is often described as “stacked diffs and better PRs,” but that undersells it. The real value of stacked diffs is not novelty. Patch series existed long before Git. What Graphite did was make small, reviewable increments the default behavior instead of something that requires discipline and constant hygiene.

That matters because waiting for review is one of the biggest sources of drag in modern teams. Pair programming and continuous integration can reduce this, but they don’t scale cleanly across time zones, org size, or async work. Stacked diffs are not about avoiding Git. They’re about reducing idle time while still keeping review quality high.

What’s telling is that GitHub is now moving in this direction, but on a multi-year timeline. That’s not because stacked diffs are hard. It’s because retrofitting new workflows onto an old mental model takes time, especially at platform scale.

Cursor didn’t have to retrofit. It bought something that already worked.

Thinking in Terms of Workflow

A recurring observation from people actually using Cursor is that it feels like it’s designed around the full development loop, not just “where code lives.” That includes writing, refactoring, reviewing, iterating, and increasingly, supervising AI agents.

That doesn’t mean Cursor is perfect in all ways!

• Onboarding friction exists.
• UX still has rough edges.

But the direction is clear: build an AI-native workflow, not a better GitHub client or a smarter autocomplete.

This also explains why speculation about Cursor eventually building or backing a Git-compatible but AI-aware version control system doesn’t sound far-fetched. If a new standard starts to emerge, it will likely come from a place that already controls the developer’s day-to-day flow, not from a platform trying to defend an existing abstraction.

The Bigger Picture

What’s actually happening here is not “Cursor versus GitHub.” It’s a transition from code-centric workflows to workflow-centric systems where code is only one artifact among many.

AI accelerates this shift because it produces more context than humans ever did. That context has to live somewhere. Review has to adapt. Storage has to evolve.

Cursor is betting on that future. Others are still optimizing the present.

That’s why this acquisition matters. And that’s why it is reasonable to believe that the biggest competitor to GitHub in the next few years might not look like a code host at all.