Claude Code vs Copilot: $10 now buys you both

Contents

Claude Code vs Copilot: which should you use?

I gave both tools the same six-requirement brief and used the apps they produced. Then I read GitHub’s pricing page and found the thing that makes the comparison obsolete.

Copilot Pro costs $10 a month and includes access to third-party agents. GitHub names Claude Code as one of them.

That is on GitHub’s own plans page, and none of the comparisons I read while researching this mention it. They all assume you are choosing. Increasingly you are not.

	Verdict
Best code quality	Claude Code — integer cents for money, 28 passing assertions, and it was the only one of the two that tested anything
Best value and best free tier	Copilot — $10 against $20, a real free plan, and it now bundles the competitor
Best overall	Depends on the bill you are already paying. If you pay GitHub, start there. If code quality is the whole job, Claude Code direct

C

What happened when both built the same thing

One message, six numbered requirements, no follow-ups. Two deliberate traps: annual plans had to display a monthly-equivalent figure rather than the number entered, and cancelled items had to leave the running total while staying visible.

Both met all six. I verified by serving each app and using it — entering a $2,400 annual plan to see whether $200.00 appeared, cancelling to watch the total move, hard-reloading to test persistence.

Axis	Claude Code	GitHub Copilot	Winner
Requirements met	6 of 6	6 of 6	Tie
Time to working code	~8.5 min	~1 min	Copilot
Exchanges before any code	8	1	Copilot
Lines written	1,052	468	Copilot
Wrote its own tests	Yes, 28 assertions	No	Claude Code
Money handling	Integer cents	Floating point	Claude Code
Output	Files on disk	Browser artifact	Claude Code
Cost of this build	~$2.56 metered	$0 on the free tier	Copilot
Entry price	$20/mo, no free tier	$10/mo, real free tier	Copilot
Alley Rating	4.7	Not rated	—

Two things need stating plainly before anyone reads that table as a scoreboard.

Copilot’s timing is imprecise and I am not going to pretend otherwise. Claude Code was driven headless, so its 394-second build turn came from the CLI’s own JSON output. Copilot ran in a browser chat that gives no completion signal I could poll. About a minute is honest; to the second would not be.

Copilot returned an artifact in the browser, not files on disk. Every other tool I have given this brief wrote a folder. I had to extract Copilot’s output to run it at all. That is a difference in kind, not a quibble, and it is the clearest signal that these two products are built for different moments.

The $10 fact that reframes everything

Here is GitHub’s Pro tier, as listed on its own plans page:

Copilot Pro, $10 per user per month
Everything in Free, plus
Cloud agent and code review
Unlimited code completion and next edit suggestions
Access to 3rd party agents (Claude Code and Codex)
Model selection
Monthly credits	$15

Read that fourth row again. The cheaper product includes access to the more expensive one.

I want to be careful about what that does and does not mean, because it would be easy to overstate. It does not mean $10 buys you unlimited Claude Code. Copilot’s paid tiers run on credits — $15 a month on Pro, $70 on Pro+, $200 on Max — and credits are what runs out. Access is not the constraint; allowance is.

What it does mean is that the framing every comparison uses, including the ones that come up first when you search this, is out of date. The choice is no longer Claude Code or Copilot. For a developer already paying GitHub $10 a month, it is a question about how much agent work you do and whether your credits cover it.

If your answer is “a lot”, a direct Claude subscription still makes sense and the comparison below matters. If your answer is “some”, you may already be paying for this.

How they differ on price

Copilot is cheaper at every comparable tier and it is the only one of the two you can try for nothing.

	Claude Code	GitHub Copilot
Free tier	None	Yes — 2,000 completions a month, no card
Free tier models	n/a	Haiku 4.5, GPT-5 mini and others
Entry paid	$20/mo (Claude Pro)	$10/mo (Pro)
Mid tier	$100 (Max 5x)	$39 (Pro+), $70 credits
Top tier	$200 (Max 20x)	$100 (Max), $200 credits
Annual discount	$200/yr ≈ $17/mo	Not listed on the plans page
Students	Not listed	Student plan for verified students

Two observations that the row-by-row hides.

The credit allowances are worth more than the subscriptions. Pro costs $10 and includes $15 of credits; Pro+ costs $39 and includes $70; Max costs $100 and includes $200. That is unusual and it is a real answer to the complaint that Copilot’s mid-2026 move to credit pricing was a price rise in disguise — at list, the credits exceed the fee at every tier.

Claude Code having no free tier is the sharper difference. Copilot will let you run 2,000 completions a month forever without a card. Claude Code’s floor is $20. If you are evaluating rather than committed, that is not a small gap, and it is the single most practical reason to start on Copilot regardless of which you end up preferring.

How they differ on quality

This is where Claude Code earns its price, and the gap was not subtle.

Money. Claude Code stored currency as integer cents, explaining unprompted that summing 9.99 and 19.99 as floats gives 29.979999999999997. Copilot used floating point, which is what almost every tool does and what almost every tutorial teaches. Both apps display correct totals today. Only one of them will still reconcile after a few hundred entries.

Verification. Claude Code wrote a 74-line test file alongside the app: 28 assertions covering corrupt JSON in storage, non-array payloads, a storage API that throws on read, negative and non-numeric inputs, and float precision. I ran it and got 28 passed, 0 failed. Copilot wrote nothing that checked anything.

That second point generalises. Across eight tools given this brief, exactly two wrote and ran real tests, and both were agent-first developer tools rather than assistants. Copilot is not unusual in skipping it. Claude Code is unusual in not.

What each did with the same requirement	Claude Code	Copilot
Money storage	Integer cents	Floating point
Explained the choice unprompted	Yes	No
Test file written	74 lines	None
Assertions	28, all passing	0
Corrupt-storage handling tested	Yes	No
Float-precision tested	Yes	No

Restraint cuts the other way. Copilot did the job in 468 lines against Claude Code’s 1,052. Both are self-contained apps meeting the same six requirements, and less code is less to read when something breaks. Copilot also produced its result in one exchange where Claude Code needed eight.

So the honest summary is not that one writes better code. It is that Claude Code writes more careful code and more of it, and whether that trade is worth double the price depends entirely on whether the thing you are building has to survive contact with next year.

How they differ on shape

The benchmark barely touches the real difference, so it is worth stating directly.

Copilot lives where you type. It is an extension inside VS Code, JetBrains and Visual Studio, built for sub-second inline completion and next-edit suggestions. Its defining feature is that it changes nothing else about how you work — no new application, no migration, no argument with your team about tooling. My build test measures none of that, because a one-shot app brief is not what inline completion is for.

Claude Code lives in the terminal and takes work away from you. You describe an outcome, it plans, executes and verifies, and you review what comes back. It is editor-agnostic precisely because it does not live in one.

That is why “which is better” keeps producing unsatisfying answers. They are optimised for different moments in the same day: one for the code you are already writing, one for the work you would rather delegate. The people who report the best results from either tend to be the ones who stopped trying to make one do both.

What the June 2026 credit change actually did

Copilot’s pricing is the subject of a live argument, and it is worth understanding before the $10 figure above reads as straightforwardly cheap.

In mid-2026 GitHub moved Copilot onto credit-based billing. The reaction was not warm: developer threads from the weeks afterwards carry titles like “GitHub Copilot’s new credit-based pricing is highway robbery”, and one widely shared post reported burning through 7,000 credits in a single afternoon of ordinary work. Interest in the term “GitHub Copilot credits” is up roughly seventeenfold year on year, which is what a pricing controversy looks like in search data.

I have not reproduced that experience, and I want to be precise about why: my build consumed the free tier, not credits, so I have no first-hand measurement of how fast a paid allowance drains. What I can verify is the structure.

Tier	Price	Monthly credits	Credits per dollar
Free	$0	None	n/a
Pro	$10	$15	1.5
Pro+	$39	$70	1.8
Max	$100	$200	2.0

At list, every paid tier returns more credit value than it costs, and the ratio improves as you go up. That is a genuinely defensible design and it is not what “price rise” usually looks like.

The complaint underneath is different from the headline, though, and it is the same complaint I have made about three other tools this month: a credit is not a unit you can feel. A request costs what it costs depending on which model answered and how long the context was, and you learn the rate by exhausting it. The people describing the change as a price rise are mostly describing the loss of predictability rather than an increase in the number.

Which is the honest thing to weigh against Claude Code’s flat $20. One of these bills is legible and one is cheaper, and until you have run a month of your own work through Copilot’s meter you will not know which of those matters more to you.

What I did not test

The limits, because a comparison that does not state them is worth less than it looks.

I did not test Copilot where it lives. My brief was a one-shot app build in a browser chat. Copilot’s actual product is sub-second inline completion inside an editor you already use, and nothing here measures that. A tool built for autocomplete being slower to produce a whole app than an agent built for whole apps would be an unremarkable finding; the interesting thing is that it was faster.

I did not test either on an existing codebase. One greenfield single-page app says nothing about a repository with ten years of history, which is where both products spend most of their real working life.

I did not exhaust a paid Copilot allowance. Everything above about credits is structural, read off the plans page, rather than measured against my own usage.

And I have not reviewed Copilot properly, which is why it carries no rating on this page.

Where these two sit among eight tools

Both of these have now taken the same brief as six other tools, which gives the comparison a scale that a head-to-head cannot.

Tool	Built from one prompt	Time	Lines	Own tests	Cost
Cursor	Yes	under 1 min	581	No	$0 free tier
GitHub Copilot	Yes	~1 min	468	No	$0 free tier
Lovable	Yes	109 sec	Not counted	No	~$0.30
Antigravity	No, approval gate	~2.5 min	2,894	Yes, 6	$0
Codex	Yes	2 min 44	585	No	$0
Bolt	Yes	2–3 min	Not counted	No	~$0.25
Replit	Yes	~4 min	Not counted	No	31% of free plan
Claude Code	No, interviewed first	~8.5 min	1,052	Yes, 28	~$2.56

Three things that table says which neither product’s marketing does.

Copilot wrote the least code of anything here. 468 lines, fewer than Codex’s 585 and Cursor’s 581, for the same six requirements. For a tool whose reputation is autocomplete rather than architecture, producing the leanest complete result of eight is not what I expected going in.

Claude Code is an outlier at both ends. Slowest, wordiest, dearest — and the only one of eight with a serious test suite. Every axis where it loses is a speed or cost axis, and the one where it wins is the one that shows up months later.

All eight passed. Six of six requirements, every tool, first attempt, including both traps. If you take one thing from a page comparing two AI coding tools, let it be that on work of this size the capability question is largely settled, and what is left is cost, shape and whether anything checks the result.

The full ranking is in best AI for coding, and the individual results are in the Claude Code review, Codex review and Cursor review.

Who should pick Claude Code

Anyone whose code has to be maintained. The integer-cents decision and the 28-assertion suite are the same instinct twice, and neither shows up on the day you build the thing.

Anyone working on a large existing repository. This is the job it is built for, and my greenfield test does not measure it — the independent reporting consistently favours it here.

Anyone who wants the interview. Its three questions before writing anything are the ones you would otherwise answer by rejecting a first draft.

Not for you if you want to evaluate before paying, since there is no free tier, or if most of your day is autocomplete rather than delegation.

Who should pick GitHub Copilot

Anyone who will not change editor. This is the whole argument and it decides most cases before any benchmark does.

Anyone evaluating on a budget of zero. 2,000 completions a month, no card, indefinitely.

Anyone who already pays GitHub. At $10 with third-party agent access included, the marginal cost of trying the agent workflow is nothing extra.

Students. GitHub lists a Student plan for verified students, which Claude Code does not advertise.

Not for you if you need the tool to verify its own work, or if your workflow is delegation rather than completion.

Why Copilot has no rating here

A note on what this page is and is not.

Claude Code carries an Alley Rating of 4.7, earned across eight months of daily use and documented in is Claude Code worth it. Copilot has no rating, because one controlled build is not a review and I am not going to imply otherwise by inventing a number.

There is also a practical reason the review does not exist yet: the obvious keyword for it is owned by Copilot’s own code review feature, so a product review published against that phrase would be answering a question nobody asked. When Copilot gets a rating here it will be off sustained use, the way Claude Code’s was.

What this page rests on is narrower and, I think, more useful: two tools, one identical brief, every result verified by using the app rather than reading a transcript.

Which one, in one table

If this is you	Pick	Why
Evaluating, budget of zero	Copilot Free	2,000 completions a month, no card. Claude Code has no free tier
Already paying GitHub $10	Copilot Pro	Third-party agent access is already in your bill
Verified student	Copilot	A Student plan exists; Claude Code does not advertise one
Live in VS Code or JetBrains	Copilot	Nothing else about your setup changes
Building something you will maintain	Claude Code	Integer cents, and the only test suite of the two
Large existing repository	Claude Code	The job it is built for, though my test does not prove it
Underspecified work	Claude Code	The interview is faster than rejecting a first draft
Heavy daily agent use	Claude Code direct	A flat $20 beats a credit meter you cannot feel

The row worth dwelling on is the second one. A developer already paying for Copilot Pro has access to both approaches for a single $10 bill, which makes “try the agent workflow before committing to it” close to free. That is a genuinely new situation, and it is the reason this comparison reads differently in August 2026 than it did six months ago.

The final word

Every comparison of these two that I read while researching this frames it as a choice. GitHub’s own pricing page disagrees.

On the measurable work, they split cleanly. Copilot was faster, leaner and free — a complete app in about a minute, 468 lines, on a tier that costs nothing. Claude Code was slower, wordier and more expensive, and produced the better code by a margin that will only show up later: integer cents for money, and the only test suite either of them wrote.

The split, in short
Faster, leaner, free	Copilot, ~1 min, 468 lines, $0 tier
Better code, tested	Claude Code, integer cents, 28 assertions
Cheaper entry	Copilot, $10 vs $20, and it bundles the other
Legible bill	Claude Code, flat, against a credit meter

But the recommendation that actually follows is not “pick the better one”. It is start with the bill you already have. If you pay GitHub $10 a month, you have a free trial of this entire argument sitting in your existing subscription. If you are paying for neither, Copilot’s free tier lets you find out what you need before spending anything, and Claude Code’s $20 is worth it the moment your answer is “the code has to last”.

One practical note before that. If you do end up running both, keep one source of project instructions rather than two. Copilot reads its own configuration and Claude Code reads its own, and the failure mode of a two-tool setup is not conflict — it is two sets of rules drifting apart until you cannot tell which one produced the thing you are looking at.

And one small thing that has now happened eight times out of eight. My brief said cancelled items must leave the total and stay visible. It said nothing about bringing them back. Copilot added a Reactivate button, exactly like every other tool I have given this to. Nobody has asked for it yet. Everybody builds it.