Why are Claude code and cursor so advanced considering github copilot came first?

Claude Code is suddenly everywhere. Articles like (Claude Is Taking the AI World by Storm, and Even Non-Nerds Are Blown Away) and How Claude Code Is Reshaping Software—and Anthropic capture a fundamental shift - and a groundswell - in how people experience AI-assisted coding.

But there’s an obvious historical caveat.

Both Claude Code and Cursor arrived after GitHub Copilot.

So the real question is this:

Why do Claude Code and Cursor feel so much more advanced, given that Copilot came first—and that Microsoft owns GitHub, which in theory should be the ultimate training advantage?

This question is interesting on multiple levels, and before diving in, a few comments are worth stating.

I’m thinking about this primarily for my students, not as a product critique. The views here are my own. I’ve worked with Microsoft before, but in our courses today we actively use Cursor, Claude, and Gemini. This is a personal analysis, and it may well contain errors or blind spots.

What is clear is that AI-assisted coding is becoming foundational, and we (as a course in #universityofoxford) are continuing to invest heavily in it. At the same time, we’re also focused on full-stack AI platforms like Lovable and Replit, which are aimed more at domain experts than traditional developers.

Cursor and Claude are still IDE-centric, but those IDEs are becoming easier to use. That shift matters: it’s opening the door for non-developers to learn both AI and coding in ways that weren’t realistic even a year ago.

More broadly, I think the enterprise AI space is still very young. The parallel success of Cursor, Claude, and even Databricks points to a genuinely pluralistic AI ecosystem. That diversity is healthy. It creates room for different optimisation strategies—and, ultimately, better innovation.

To understand what’s going on, it helps to look at what Copilot’s original strengths actually became over time.

Copilot was designed around a simple flow:

You write code → Copilot completes the next bit.

In retrospect,that framing turns out to matter a lot.

Cursor and Claude started from a different premise. Cursor executes tasks. Claude reasons about systems. Both were built as thinking environments, not just completion engines.

Copilot’s original product definition was essentially: predict the next few tokens of code. Cursor and Claude asked a different question entirely: how does the model reason over the whole system?

That difference is foundational.

Cursor and Claude are (relatively more) agent-oriented coding systems. Copilot, at least initially, was not. Ironically, Microsoft’s biggest advantage—access to vast amounts of GitHub data—may have been a liability for this kind of reasoning. GitHub is a goldmine of syntax, but it’s a messy place to learn how to think. Public code is full of duplicated patterns, inconsistent abstractions, half-finished experiments, and abandoned ideas.

Claude and Cursor instead lean heavily on long-context reasoning, multi-step planning loops, repository-wide dependency graphs, and error-driven reflection.

So while Copilot is excellent at answering “what usually comes next here?”, Cursor is much better at answering “what is this system trying to do, and how do I change it without breaking everything?”

There’s also an organisational dimension. Copilot lives inside a sprawling Microsoft ecosystem—GitHub, Office, Azure, and more. Every architectural change has to propagate through multiple teams and incentives. Cursor and Anthropic, by contrast, are startups with much tighter product focus. Claude, in particular, is architecturally strong at coherent system-level reasoning, and that strength shows up directly in the product.

Claude models were optimised for things like long-context fidelity, structured reasoning, uncertainty tracking, and safety-aligned reflection.

Cursor, meanwhile, solved a quieter but crucial problem: context packing. Cursor doesn’t just send your entire repository to the model. It constructs call graphs, dependency clusters, test-failure slices, diff-weighted windows, and change-impact cones. The model sees only what matters right now. Copilot, most of the time, sees whatever file happens to be open.

That’s the difference between autocomplete and engineering cognition.

Copilot’s GPT-4-era lineage was optimised for fluency, generality, chat tasks, and short-context generation. Cursor and Claude were optimised for something else entirely.

Seen through this lens, it’s not surprising that Cursor and Claude feel more agentic.

They treat coding as a goal-directed activity. Copilot treats it as token completion with light context.

A genuinely agentic system has a few core properties: it knows the goal, it tracks state, it plans, and it can act, observe, and revise. Autocomplete systems don’t really do any of this by default.

Copilot’s core loop (as originally envisaged) is simple: the user types, the model predicts the next tokens, and they’re inserted. There’s no long-term planning, no task ownership, and no real decision-making. In the literal aviation sense, it’s a co-pilot: it assists when the pilot acts.

Cursor adds a missing layer above the model. Its loop looks more like: user intent, context selection, planning, code changes, diffs, and feedback. That requires goal anchoring, context orchestration, multi-step actions, and an awareness of what changed and why.

Claude pushes this even further. It thinks in plans rather than completions, maintains longer horizons, and treats tools as actions. Reading a file isn’t just input—it’s a deliberate step in a reasoning process.

Another way to understand the difference is to look at how these systems are trained.

Claude starts as a large language model trained on a mixture of licensed data, human-created data, and publicly available text. At that level, it’s broadly similar to other frontier models.

The real distinction comes from Constitutional AI.

Anthropic’s core idea is that instead of relying mainly on humans correcting outputs one by one, the model is trained to critique and improve its own responses using a written constitution of principles. Those principles cover safety, helpfulness, non-deceptive behaviour, respect for human autonomy, and avoiding hallucination or manipulation.

The training loop becomes recursive. Claude generates a response, critiques it against the principles, revises it, and only then involves human supervision. The result is a model that’s more reflective, more explicit about uncertainty, less impulsive, and better at following constraints.

Claude does use reinforcement learning, but in a structured way: with explanations, deliberate reasoning, and fewer reward hacks. That’s why Claude often explains trade-offs, asks clarifying questions, respects “do not infer” constraints, and behaves well as a collaborator rather than just a generator.

What Claude is not optimised for is raw autocomplete speed or aggressive prediction of what the developer wants next. It’s optimised for long-context coherence, role-based thinking, and auditability. The calm, thoughtful, slightly conservative feel of Claude isn’t an accident. It’s a training choice.

Cursor is very different. It isn’t a foundational model at all. It’s a product layer built on top of frontier models, with training, fine-tuning, tooling, and UX tightly integrated.

Cursor’s primary training signal is developer behaviour. It learns from what gets accepted, what gets edited, what survives refactors, what compiles, what fails, and what ultimately persists in commits. This is implicit feedback, not philosophical alignment.

Cursor is trained to support flow: to mirror local style, complete partial thoughts, and make minimal, local changes. It’s not trying to challenge your architecture or slow you down with critique. It assumes you already know what you’re building.

That’s why Cursor feels sharp, fast, and predictive—and why it’s weaker at problem framing, epistemic caution, or governance-style reasoning. Claude is trained to justify its thinking. Cursor is trained to understand and accelerate your workflow.

I’ve always been sceptical of the slogan “data is king.” This comparison makes the limits of that idea very clear.

Copilot had unparalleled access to GitHub data. That alone did not produce the best AI coding product. After a certain threshold, more data yields diminishing returns. Once a model understands common patterns, APIs, and frameworks, the real bottlenecks shift to reasoning quality, intent alignment, interaction design, and error recovery.

GitHub data is excellent for syntax fluency. It’s not a substitute for judgement.

Copilot was initially optimised for predicting the next likely line of code. That’s a training objective, not a developer objective. Developers care about correctness across files, refactoring, understanding existing systems, and reasoning about change. Cursor and Claude optimised for those loops instead.

The deeper difference is in the feedback cycles. Copilot’s loop is short: type, suggest, accept or reject. Cursor’s loop spans navigation, modification, compilation, testing, and diffs. Claude’s loop is explicitly cognitive: explain, critique, revise, justify, reflect.

Owning the data source didn’t guarantee owning the best product. The more important question isn’t who had more data, but what behaviour the system was trained to reward.

Copilot rewarded speed and fluency. Cursor rewarded developer flow. Claude rewarded justified reasoning.

Data still matters—you can’t reason without enough of it—but once you’re past “good enough,” product design and cognitive loops dominate outcomes. Owning data doesn’t automatically create value. Designing the right thinking system does.

Data gets you into the game. It’s not what wins it.

The views expressed here are my own (Ajit Jaokar) and not related to any organisation I am associated with.

This story is a classic large company misstep - where companies become too confident and also are too closely tied to serving their existing customers - to miss a blind spot.

In the case of Copilot, one more market it missed (and for the same reasons) is the fullstack AI. Lovable and others dominate that market now.

Also, this shows the risk of companies playing it safe (Copilot is only your assistant) - that narrative led naturally to code completion - leaving a much richer agentic future untapped.

I am particularly pleased about the ‘data is not king’ angle (at least in this case). Its too easy for people to propagate that rather simplistic view. As we see above, more is at play

I note with some interest :) - Claude Code is suddenly everywhere inside Microsoft - Microsoft sells GitHub Copilot to its customers, but it increasingly favors Claude Code internally

If you want to explore these ideas further with me, see Erdos Research