Vibe coding, the natural-language-to-code approach Andrej Karpathy named last year, now ships in over 25 million apps per Inferya's count. That single number should retire the "which AI coding tool is winning" framing — the answer is "all of them, simultaneously, because the substrate won." The more useful question is what each tool is actually for, and the data Exceeds published this July gets us closer to that answer than another model benchmark ever will.
Kyle Daigle, GitHub's COO and a 13-year company veteran who helped ship Copilot to preview back in June 2021, told Observer: "It's not solely about generating code. It's about creating software, and that requires you to do more than just the code portion of it." Read that sentence against the market: Claude Code leads primary tool share at 28%, Cursor at 24%, Copilot at 17%, OpenAI Codex at 11% — and yet Copilot is the tool 40% of large companies have rolled out. The whole GitHub Copilot vs Claude Code conversation collapses onto that gap.
The 40% vs 17% gap is the comparison
That twelve-point spread — Copilot rolled out across 40% of large enterprises, but the primary tool for only 17% of developers — is the cleanest read on what these products actually do. Copilot is the default Microsoft's procurement teams approved. It is not the default developers reach for first.
[[COMPARE: GitHub Copilot's enterprise rollout share at 40% of large companies vs its 17% primary-tool share among developers]]
That isn't a knock on Copilot. It's the natural shape of a tool designed to drop into existing IDEs across a Microsoft-shop estate: cheap to roll out, friction-free to keep, and good enough at the 80% of code generation that has become table stakes. It will be there when a developer opens VS Code. It will not be the thing they pick when the task is hard.
Claude Code, by contrast, earns the developer's deliberate attention. A 28% primary-tool share against a much smaller enterprise footprint suggests the tool has won the recommendation engine — word of mouth, blog posts, "you have to try this" over Slack. Cursor's 24% tells the same story. Coding assistants are now a developer-pulled category, not an IT-pushed one.
What GitHub is actually selling in 2026
Daigle's framing — "more than just the code portion" — points at a strategic move that the headline numbers hide. GitHub isn't trying to win the model arms race. It's positioning itself as the place where you can use Claude Code, OpenAI Codex, and lower-cost open-weight models from inside the same IDE, behind the same auth, against the same repos. The platform is the product.
What that delivers to a developer is a one-switch answer to "this task needs the small model, this task needs the big one, and this task needs a model I trust with proprietary code." It's the same answer Anthropic gives a single-vendor shop — they just bundle it differently. Where Anthropic ships one assistant and asks you to standardize on it, GitHub ships a marketplace and asks you to pick. That strategy is why Copilot's enterprise share will probably stay high even if its primary-tool share keeps shrinking.
The metric you should actually watch
"Primary tool share" rewards tools that earn the recommendation. "Enterprise rollout share" rewards tools that survive procurement. If you're picking for yourself, you want the former. If you're picking for an org, you want the latter. The mistake most comparisons make is collapsing the two into a single chart and asking "who's winning."
A better signal — and one the Exceeds data points at without stating it — is which tool developers keep after the free trial ends. The 17% number for Copilot is suspicious on its face: Copilot has the most generous free tier and the lowest switching cost inside a Microsoft shop. That it's still not the primary tool tells you developers are choosing on raw output quality, not convenience. Convenience is GitHub's calling card. Output is everyone else's.
How to pick, today
The decision matrix below isn't exhaustive, but it's the version I'd hand to a friend.
Solo developer or small team, value legibility: Claude Code or Cursor. Both earn the recommendation engine — developers talk about them in PR comments and on podcasts. The 28% and 24% primary-tool shares reflect "I reached for this first" energy, not procurement energy. You give up nothing by skipping the enterprise wrapper.
Inside a Microsoft shop with a real procurement function: Copilot. The integration story is real — PR review lives in the GitHub UI, repo context sits inside the editor, Actions ties into the rest of your dev pipeline. The 17% primary share is fine. Your engineers don't have a choice, and they'll use it for the easy 60% that doesn't deserve a separate account. The hard 40% will route elsewhere.
Multi-model, multi-tenant, regulated code: GitHub's marketplace surface. It is the only mainstream assistant that lets you route a refactor to one model and a security-sensitive edit to a different one without leaving the editor or re-authenticating. The compliance story writes itself.
Cost-sensitive, batch code generation, or air-gapped repos: Open-weight models through whichever surface GitHub or Cursor exposes. The open-weight capability gap closed in 2025; per-token economics are the actual tailwind here, not benchmark numbers.
Run them side by side in 30 minutes
The fastest way to feel the difference is to put both behind the same prompt. Drop both into one router script and walk away with evidence instead of vibes:
# .env.local
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-... # whichever OpenAI-compatible surface Copilot exposes in your org
# Pick the models your accounts actually expose — aliases rotate, use whatever resolves today.
CLAUDE_MODEL=claude-default
COPILOT_MODEL=copilot-default
// compare.ts — runs three real tasks through both backends, eyeball the diff
import Anthropic from "@anthropic-ai/sdk";
import OpenAI from "openai";
const tasks = [
"write a debounced hook that cancels in-flight calls",
"refactor this 80-line switch into a strategy map",
"explain the race condition in this Go channel snippet"
];
const CLAUDE_MODEL = process.env.CLAUDE_MODEL ?? "claude-default";
const COPILOT_MODEL = process.env.COPILOT_MODEL ?? "copilot-default";
const claude = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
const copilot = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
for (const t of tasks) {
const [c, p] = await Promise.all([
claude.messages.create({
model: CLAUDE_MODEL,
max_tokens: 1024,
messages: [{ role: "user", content: t }],
}),
copilot.chat.completions.create({
model: COPILOT_MODEL,
messages: [{ role: "user", content: t }],
}),
]);
console.log(`\n### ${t}\nCLAUDE:\n${c.content[0].text}\nCOPILOT:\n${p.choices[0].message.content}`);
}
Run it on three real tasks pulled from your own backlog. The gap that matters isn't the benchmark — it's whether the model picks up your repo's conventions on the first pass.
The part that doesn't change when the leaderboard does
Here is the durable layer underneath the churn: every one of these tools reads your repo through the same surface — components, types, naming, file structure. Whichever model wins the next quarter, the convention-aware component layer you shipped is what they read.
OTF is the same component on web, iOS, and Android — one API, one set of primitives, the same Button rendering correctly whether the next edit came from Claude Code, Copilot, Cursor, or the open-weight model you'll route to next quarter. That part of your codebase doesn't churn when the model does. It is the substrate the comparison assumes exists and never names — and it's what you should be investing in while the leaderboard reshuffles.
Top comments (0)