Claude Code vs GitHub Copilot: seven ways developers split the work, and how much of your Claude Code setup each Copilot surface reads
Copilot runs Claude models at Anthropic's list rates, reads CLAUDE.md and the skills folder, and its CLI even loads Claude Code hooks. So the split is no longer one vendor against the other. It runs surface by surface: each Copilot surface reads a different slice of your Claude Code setup, and the slice decides which rules reach the code.
Contents
GitHub Copilot will run Claude Opus 5.5 for you, bill it at the per-token rate Anthropic lists for its API, and read the CLAUDE.md you wrote for Claude Code. Its command-line tool goes further and loads the hooks from .claude/settings.json. Older comparisons of the two still frame the choice as Copilot’s model against Anthropic’s. By November 2026 the model is the one thing they reliably have in common.
This is the fourth piece in a series, after Claude Code and Codex, Claude Code and Cursor and Claude Code and Gemini CLI. Copilot came up once in the Cursor piece, as a third instruction file somebody kept in sync by hand. GitHub had already removed most of that chore by then: Copilot code review started reading CLAUDE.md on July 17. What it hasn’t done is read the same files everywhere. The cloud agent, the CLI, code review and chat on github.com each take a different slice of a Claude Code setup, and that is where the real split now sits.
Same labels as before. Documented means a vendor’s docs, or a project’s own committed files, show the mechanism. Reported means a named person published their setup or results and I am relaying them without having reproduced them. Everything about Copilot below comes from GitHub’s documentation and those sources, read on November 22.
What separates Claude in Copilot, Claude’s agent on GitHub and Claude Code?
Whose harness runs the model, where it runs, and which account pays. Copilot’s own surfaces (chat, the CLI, the cloud agent) run a Claude model inside GitHub’s loop. VS Code’s harness docs say it for the editor: “selecting a Claude model in a Copilot harness session still uses the Copilot harness.” The tools, the permission prompts and the instruction loading are GitHub’s. AI credits pay.
Anthropic’s agent can also run inside GitHub. GitHub announced on February 4 that “Claude by Anthropic and OpenAI Codex are now available in public preview.” The third-party agents page says the Claude coding agent “uses the Claude Agent SDK and can be powered by your existing Copilot subscription,” still in public preview. It consumes “GitHub Actions minutes and AI credits,” and its model list is its own: Sonnet 5, Opus 4.8 and Fable 5.2 are on it, the 5.5 models are not. GitHub’s Agentic Workflows go one step further: their Claude engine runs Claude Code in Actions and can select “a Copilot-hosted Anthropic model with inference billed through GitHub Copilot.”
Then there is Claude Code on Anthropic’s meter: in a terminal, in cloud sessions started with claude --cloud, or through the @claude GitHub Action, whose setup and secrets I covered separately. Cloud sessions count “toward your plan’s usage limits” with “no separate charge for the cloud VM,” and claude --teleport continues one in your terminal. The Action can also bill through Bedrock, Google Cloud or Foundry.
Does a Claude model cost more in Copilot than on Anthropic’s API?
Per token, no. Copilot’s models and pricing page lists Claude Sonnet 5.5 at $2 per million input tokens and $10 per million output, and Opus 5.5 at $4 and $20. Those are Anthropic’s API list prices. The Fable 5.2 changelog says it outright: “This model is billed at provider list pricing under usage-based billing.” One AI credit is one cent.
The envelopes differ. Copilot’s plans page gives Pro 1,500 credits a month for $10, Pro+ 7,000 for $39 and Max 20,000 for $100, so every tier includes more credits at face value ($15, $70, $200) than it costs, and unused credits are forfeited at month end. Fable 5.2 and, per its September 22 changelog, Opus 5.5 are “available to Copilot Pro+, Max, Business, and Enterprise users,” not Pro. A Claude subscription meters usage windows rather than tokens, so the two don’t compare per token. Which is cheaper depends on how many hours a day the agent runs.
The cloud agent’s compute sits outside the credits. Sessions on GitHub Actions use Actions minutes. Cloud sandboxes are metered for compute and memory while running and for storage while stopped, drawing first on the account’s included compute allowance.
How do Claude Code and Copilot share one set of instructions?
With one file and a pointer, and on these two tools alone the file can now be CLAUDE.md. Committed repositories show the longer version (documented). confluentinc/cli commits CLAUDE.md as a symlink to AGENTS.md, and its .github/ keeps only what Copilot’s reviewer needs:
Author-facing guidance (build/test commands, environment setup, the full
convention reference) lives in `AGENTS.md` (symlinked as `CLAUDE.md`),
`CONTRIBUTING.md`, and the per-package `README.md` files under `pkg/`Taiga UI does the same (documented): a symlinked CLAUDE.md and a Copilot file that sends the reader to AGENTS.md. For more tools, ruler and rulesync generate each tool’s file from one source, and both list Copilot and Claude Code among their targets.
GitHub’s instructions support reference lists AGENTS.md, CLAUDE.md and GEMINI.md for the cloud agent, code review and Copilot CLI, and the CLI also reads .claude/CLAUDE.md. Chat on github.com is the exception: it takes repository-wide instructions only. So a single CLAUDE.md covers both tools, and AGENTS.md earns its place once a third tool reads the repository. Then Claude Code needs the symlink or an @AGENTS.md import, because by default it reads AGENTS.md only when there is no CLAUDE.md or CLAUDE.local.md. In the other direction, Claude Code doesn’t discover .github/ at startup; per its memory docs, /init folds “the relevant parts” into a generated CLAUDE.md.
Skills move in one direction. Copilot’s skills page tells you to create “a .github/skills, .claude/skills, or .agents/skills directory,” and lists the cloud agent, code review and the CLI among the surfaces that load them when relevant. Claude Code reads .claude/skills and not .github/skills.
Can Copilot’s cloud agent write the pull request and Claude review it?
Yes, with one line in the workflow (documented). livetemplate runs Anthropic’s claude-code-action on pull requests with allowed_bots: copilot-swe-agent, changed in July. Wechaty’s claude.yml, changed November 21, lists more in the same field, including Copilot, copilot-pull-request-reviewer[bot] and copilot-swe-agent[bot]. The action refuses bots unless they are listed, so this split is always an explicit choice.
Listing a bot doesn’t make it trusted. The GitHub Action post walks through what the action does for an author without write access, which is how it treats bots even when listed: it restricts package managers and shells, and it restores Claude’s config, CLAUDE.md included, from the default branch. Copilot’s own code review does the opposite. Per the July 17 changelog, “Custom instructions are now read from the head branch of the pull request instead of the base branch.” On one bot-authored pull request, the two reviewers can be following different versions of the same CLAUDE.md. And the job’s permissions: block bounds only GITHUB_TOKEN, not the Claude GitHub App token, so a reviewer meant to be narrow needs its own github_token.
Can Claude fix the threads Copilot’s code review opens?
One repository has built a loop for that (documented). allxsmith/bestax commits a workflow it calls a “Review → fix → verify → converge loop for AI-authored PRs.” Claude answers open review threads from CodeRabbit or Copilot’s reviewer and pushes fixes. The project’s own guide is careful about the trigger: “Do not assume a Copilot review starts a loop run by itself.” A maintainer’s label starts it, there is a “Hard iteration cap (4 fix rounds per PR),” and a run that hits the cap pauses for a human.
Copy the guardrails along with the idea. One more is implied rather than written down. The fixer commits to the head branch, and the head branch is where Copilot’s review reads its instructions. A fixer allowed to touch CLAUDE.md or REVIEW.md can edit the rules its next review runs under.
When does claude-code-action fit better than assigning an issue to Copilot?
When the job’s output must be a comment, not a pull request, and when you want the model pinned. The MCP Inspector’s sdk-watch.yml records why its maintainers chose the action (documented, November 5). Copilot’s agent always produces a pull request, and this job should only file findings. Their second reason:
its model cannot be selected programmatically at all: assignment goes
through `replaceActorsForAssignable`, which takes no model parameter, and
absent an admin-configured picker the agent runs Sonnet. `claude-code-action`
has neither problem: it is told to post a COMMENT and nothing else, and
`--model` says exactly which model runs.Check that second reason before you rely on it. GitHub’s cloud agent API page now shows a model field in a replaceActorsForAssignable example, behind a GraphQL-Features header and marked public preview. The first reason still holds.
The same file is the strongest case for running both tools. Its comments credit Copilot’s review, round by round, with finding holes in the workflow’s own permissions. In one, a prefix grant on gh issue comment would have let a prompt injection pass /proc/self/environ as the body file and post the job’s ANTHROPIC_API_KEY and GITHUB_TOKEN into a public issue. The fix was to let the model post nothing: it returns structured output, and a deterministic step publishes it. Copilot reviewed the workflow that runs Claude and found the hole in its guardrails.
Which tasks go to Copilot’s cloud agent, and which stay in Claude Code?
Small, well-defined ones, if any, by the one team report that counts results. David Pereira wrote in June (reported) about runs in “August 2025, some other months and again in March 2026”: roughly 130 pull requests from Copilot’s agent, about 30 merged. “A lot of Copilot coding agent PRs were spikes/exploration,” he notes, so the merge rate undersells the implementation work. For “the clear well-defined tasks the agent produced a good quality PR that got merged sometimes.” Anthropic’s agent inside GitHub got about five tasks and no merges, too few to compare. His team’s conclusion: “we’ll be doubling down on our adoption of Claude Code as our agentic coding tool.”
GitHub’s limits point the same way. A session on GitHub Actions “has a maximum execution time of 59 minutes”; the newer cloud sandbox has no stated cap and can span repositories. Either way, Copilot “can only work on one branch at a time and can open one pull request per task,” per the Copilot on GitHub.com docs. The same page describes “steering Copilot in the same session,” so redirecting the agent midway is possible there too. What decides it is the shape of the result. A job that ends in one branch and one reviewable diff fits the agent. A job that spreads across branches, or ends in a decision rather than a diff, belongs in an interactive session, Claude Code or Copilot CLI.
Do Claude Code hooks and permission rules work in Copilot?
Partly, and it depends on the surface, so check here before you move agent work into Copilot’s harness (documented). The hooks reference says Copilot CLI reads its own hook files and that “Cross-tool .claude/settings.json and .claude/ files in the repository are also read.” It also accepts event names in PascalCase, the casing Claude Code uses. The cloud agent is narrower: its hooks page covers .github/hooks/*.json files, which “must be present on your repository’s default branch,” and doesn’t mention .claude.
Reading a file isn’t the same as enforcing it the same way. A hook that inspects a tool name or a command is written against one harness’s tool names and payloads, and the reference documents Copilot’s. Permission rules are a separate question. Copilot CLI takes --allow-tool, --deny-tool and --allow-all, Claude Code has six permission modes and its own allow and deny lists in that same settings file, and the hooks reference mentions the file for hooks only. I found nothing in GitHub’s docs saying Copilot applies Claude Code’s permission rules. The Cursor piece found a similar gap. If your hooks are where your guardrails live, test each one under Copilot CLI before trusting it, and expect to rewrite them for the cloud agent.
On output quality, GitHub’s own benchmark by Shibani Basava and Carlos Castro compares Copilot CLI with Claude Code on Sonnet 4.6 and Opus 4.7 and calls the result “effective parity.” It is the vendor measuring its own product on the previous model generation, and for small benchmarks “the best scored run is reported.” Treat it as GitHub’s claim.
Can you run Claude Code on a Copilot subscription?
In GitHub Actions, yes, through Agentic Workflows’ Claude engine described above. On your own machine, only through a reverse-engineered proxy, and that is the setup to skip. ericc-ch/copilot-api has about 4,150 stars and a --claude-code flag that points a local Claude Code at Copilot’s backend (documented). Its README opens with its own warning:
This is a reverse-engineered proxy of GitHub Copilot API. It is not
supported by GitHub, and may break unexpectedly. Use at your own risk.A few lines later it says heavy scripted use “may trigger GitHub’s abuse-detection systems” and “could result in temporary suspension of your Copilot access.” The repository was last pushed in November 2025. The supported routes cover the billing half of what it promised: Claude Code in Actions on Copilot inference, or Anthropic’s agent on Copilot credits. Neither is your local Claude Code with your settings.
Which Claude Code and Copilot split should you start with?
This is my read of the sources, not a measurement. Start with one instruction file: CLAUDE.md if these are your only two tools, AGENTS.md plus a symlink if there is a third. Put skills in .claude/skills. Copilot’s cloud agent, code review and CLI read both.
Then split by what the job produces. If it ends in one branch and one reviewable diff, Copilot’s agent is worth a trial, with a merge count, which is how Pereira’s team ran theirs. If it should end in a comment or must run a pinned model, use claude-code-action. If Copilot reviews and Claude fixes, take bestax’s label trigger and round cap along with the idea. The allow list is one line; the loop is a workflow that holds secrets, so read the MCP Inspector’s comments first.
Who should skip moving agent work into Copilot’s harness: anyone whose guardrails are Claude Code hooks and permission rules, until each hook is tested under Copilot CLI and the permission rules are rewritten. Copilot as the reviewer costs them nothing. In May I wrote that wiring a harness to one vendor’s CLI means the next billing change rebuilds it. Copilot moves where that rebuild lands. The model and the instruction file now travel freely, and hooks reach the CLI but not the cloud agent. Permission rules, as far as the docs say, still stay with the tool you wrote them for.
01 / Discussion
No comment section here — all discussions happen on X.
02 / More articles
Claude Code subagents: when they are worth it, job by job, and when the main session is cheaper
Delegation is billed in tokens and in trust: the subagent pays to read the mess, and the parent gets a paraphrase instead of the raw output. Test runs, codebase search, code review, parallel research and parallel edits each get a verdict, with the list-price break-even behind it and the one case where the arithmetic says stay and you should delegate anyway.
Claude Code Code Mode: auto mode now reviews the script, not each tool call
In a Code Mode session the auto mode classifier reads the script once and never the calls inside it, so a path or host computed at run time gets no review from it. A PreToolUse hook that can't start or times out now refuses the call, but one that exits 1 still lets it through. The checks that see real values are your rules, your hooks and the sandbox.
Claude Code permissions.denyInsteadOfPrompting: the overnight session stops waiting, and refused work raises no error
The new setting removes the wait, not the failure. A refused call ends in a clean exit and a success subtype, so the setting is only half the setup: the other half is a record of what was refused. The same release gave it more to refuse, by taking away auto mode's fallback for sessions that don't fetch feature flags.