Claude Code vs GitHub Copilot: the 5 decisions that survive a security review

Five decisions, and a feature table answers none of them

Both products write code, run commands, read a repository and open a pull request. Feature comparisons between them go stale in weeks and decide nothing, because the two tools have converged on capability and diverged on where the control plane sits. GitHub Copilot enforces policy on GitHub's servers against the seat GitHub granted. Claude Code enforces policy on the endpoint, through a managed settings file or an MDM profile, and against whatever organisation the developer's credential belongs to.

That single structural difference produces every consequence below.

We run Claude Code on this site's own repository, which is how we found half of what follows — an AGENTS.md that forces the agent to read the framework's docs before writing code catches more than any permission rule does. We have not run a Claude Code or a Copilot rollout for a customer, so nothing below is drawn from one. The argument is structural: it rests on what each vendor documents its control plane can and cannot enforce, which is also the only part of this comparison that survives the next release of either product.

The state of play below is taken from each vendor's current documentation, read on 4 August 2026. Where a claim is not in a vendor doc, it is marked as our position rather than presented as fact.

Decision one: whose tenant runs the inference, and what measuring it costs

Claude Code can run inference in an account you own; GitHub Copilot cannot. Claude Code authenticates against Amazon Bedrock, Google Cloud's Agent Platform or Microsoft Foundry by environment variable, or through a self-hosted gateway that signs developers in with your own identity provider. Inference then bills through your cloud agreement, runs under your IAM policies and never establishes a commercial relationship between the developer and Anthropic at all.

Copilot's answer is a different shape and, for a lot of organisations, a sufficient one. GitHub documents Copilot with data residency as routing every Copilot request to model endpoints inside the enterprise's designated region, with code, prompts and responses never leaving that region during inference. The regions are the EU and the US. The price is stated on the same page: enforcing it increases AI credit consumption by 10 percent.

Ten percent for residency is the same premium AWS and Google charge for regional Claude endpoints, which is a coincidence worth noticing and not worth reading anything into.

What GitHub does not offer is your tenant. Its model hosting page is unusually candid about the topology: OpenAI models are hosted by OpenAI and by GitHub's Azure infrastructure, Anthropic models by Amazon Web Services, Anthropic PBC and Google Cloud Platform, xAI models on xAI, open-weight models on US-based Azure AI Foundry infrastructure managed by GitHub and Microsoft, and only Microsoft's own MAI-Code-1-Flash is described as hosted in GitHub's tenant. Data residency constrains the geography of that estate. It does not move any of it into your subscription.

Now the part that gets missed, and it is the reason this is decision one rather than decision five. Choosing your own tenant on the Claude side costs you the built-in measurement. Anthropic's documentation states that the Claude Code Analytics API tracks Claude Code usage on the Claude API only, and not usage through Bedrock, Microsoft Foundry, Google Cloud or Claude Platform on AWS. Operational telemetry follows the same pattern: metrics, error reports and feedback all default to off on those providers, and only turn on when the corresponding provider flag is set.

So tenancy and visibility pull against each other on exactly one of the two products. Take Bedrock for residency and you inherit an OpenTelemetry collector as a project, not a checkbox. That is a week of platform work, not a blocker, but it belongs in the estimate rather than in the surprise column.

Managed settings

# The Claude Code control set worth deploying on day one.
# Managed settings outrank every other scope and cannot be overridden.
#   https://code.claude.com/docs/en/settings
#   https://code.claude.com/docs/en/iam

sudo mkdir -p "/Library/Application Support/ClaudeCode"
sudo tee "/Library/Application Support/ClaudeCode/managed-settings.json" >/dev/null <<'JSON'
{
  "forceLoginMethod": "console",
  "forceLoginOrgUUID": "00000000-0000-0000-0000-000000000000",
  "permissions": {
    "disableBypassPermissionsMode": "disable",
    "deny": [
      "Read(//**/.env)",
      "Read(//**/*.pem)",
      "Edit(//**/.env)",
      "Bash(curl *)",
      "Bash(wget *)",
      "mcp__*"
    ]
  },
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_EXPORTER_OTLP_PROTOCOL": "http/protobuf"
  }
}
JSON

# Two caveats the file cannot fix, both from Anthropic's own docs:
#  1. claude setup-token and /install-github-app enforce forceLoginMethod
#     but not forceLoginOrgUUID, so they can mint a token elsewhere.
#  2. Read and Edit deny rules do not bind arbitrary subprocesses.
#     For OS-level enforcement, turn on the sandbox.

Decision four: only one of the two hands you a cost figure per developer

Claude Code produces a per-developer cost figure out of the box; GitHub Copilot produces a per-developer engagement figure and a spend cap. Anthropic's Claude Code Analytics API returns one record per user per day containing sessions, lines of code added and removed, commits and pull requests created through Claude Code, accept and reject counts for the Edit, MultiEdit, Write and NotebookEdit tools, and a model breakdown carrying input, output, cache-read and cache-creation tokens plus an estimated cost in cents USD. It is free for organisations with Admin API access, and data appears within about an hour.

GitHub's Copilot metrics REST API is a different instrument aimed at a different question. It reports usage statistics, user engagement and feature adoption at enterprise, organisation, repository and user level, with reports available from 10 October 2025 and a year of history. What it does not report is cost. Team-level views have to be assembled by joining user reports against team membership, because the API does not aggregate by team directly.

Copilot's cost control lives in billing instead, and it is genuinely better than Anthropic's on the containment side. Copilot Business includes 1,900 AI credits per user and Copilot Enterprise includes 3,900, pooled at the billing entity rather than held per person, with usage beyond the pool charged at $0.01 per AI credit and budget controls available at user, cost centre and enterprise level. Code completions and next edit suggestions stay unlimited on all paid plans and never draw on the pool.

So one product tells you what a developer cost and the other stops a developer costing more than you decided. Those are not the same control, and a FinOps team that assumes it is buying both will be disappointed by whichever one it picks.

The seat prices, meanwhile, are a distraction, and the arithmetic is worth doing once so nobody has the argument twice. Copilot Business is $19 per granted seat per month. A Claude Team standard seat is $20 per seat per month billed annually, or $25 billed monthly. For a hundred developers on annual terms that is $22,800 against $24,000 — a gap of $1,200 a year, which at GitHub's own $0.01 overage rate buys 120,000 AI credits, or roughly 63 developer-months of the Copilot Business allowance. The seat line is noise. The metered layer above it is the entire cost model.

The tier above is where that gets actively misleading, and the trap is that two different twenty-dollar figures sit on the same page. Team is $20 per seat per month billed annually, and that is the whole price. Enterprise also shows $20 per seat, but as a component — Anthropic's own wording is a seat price plus usage at API rates, with the rest through sales. The capabilities an enterprise is actually buying at that tier, among them role-based permissions and group management, are Enterprise-only, so they never come with the Team figure. Read either seat line alone and the comparison against Copilot Enterprise at $39 per granted seat per month is not a comparison at all.

The two seat fees do not buy the same thing, and this is the one number in this article worth reading twice. Anthropic states that the Enterprise seat fee covers access only and includes no usage — every token the team consumes is billed separately at standard API rates. That is also what separates it from the identically priced Team seat, which does include usage. Copilot Enterprise's $39 includes 3,900 AI credits per user, pooled at the billing entity, with overage at $0.01 per credit. So the cheaper seat is the one with the uncapped meter behind it, and any tier-for-tier table that stops at the seat price has the ranking backwards.

The strongest argument for choosing Copilot anyway

Buy Copilot, because the control plane already exists and you already run it. Your repositories, your identities, your SSO, your audit log, your cost centres and your policy hierarchy are all in GitHub today. Copilot policies land in that same place, apply the moment they are saved, and require no MDM profile, no managed settings file, no endpoint rollout and no argument with the desktop team about who owns a JSON file in /Library.

That argument is the strong one, and we think it should win in most estates. Rollout speed is a real advantage, and a control that ships this quarter beats a better control that ships next year.

It stops winning at two specific requirements, and only two. The first is inference in an account you own — if the answer to "whose subscription processes this prompt" has to be "ours", data residency does not get you there and no amount of GitHub tenancy changes that. The second is a defensible cost figure per developer, which Copilot's metrics API does not produce and Claude Code's analytics API does.

Our position, stated plainly so it can be argued with: for a regulated European organisation whose code is the asset, Claude Code on Bedrock in an EU region is the stronger position, and the price is a telemetry project and a managed settings deployment. For everyone else, Copilot is the faster and cheaper answer, and choosing it is not a compromise.

What is not defensible is running both by accident, which is where most organisations already are, because a personal Copilot subscription and a personal Claude subscription both work perfectly well on a corporate laptop that nobody configured.

Sequence

The five steps, in that order

1. Enumerate the credential paths, per product. Anthropic documents six login paths for Claude Code — terminal, VS Code extension, Agent SDK, setup-token, install-github-app and gateway sign-in — of which three honour forceLoginOrgUUID. Then two categories outside those six: environment credentials, which the pin does block, and cloud provider credentials, which it does not. For Copilot it is the seat, plus whatever personal subscription your endpoint management does not stop.
2. Deploy the policy through the mechanism you already operate. Managed settings via MDM if you have MDM; the enterprise AI controls tab if your control plane is GitHub. Do not adopt a second endpoint management stack for a coding tool.
3. Stand up the telemetry before the second team joins. On Claude Code that means an OpenTelemetry collector if you are on Bedrock or Vertex, and the Analytics API if you are on the first-party API. On Copilot it means the metrics API for adoption and budgets for containment, because those are two separate jobs.
4. Aggregate at team level by default and keep per-user attribution only where a works council agreement or an equivalent policy already covers it. Both products can identify individual engineers; a telemetry stack that does so without agreement gets switched off, and then you have neither the data nor the trust.
5. Run the canary test on a real machine with a real developer watching, and write down which of the three attempts succeeded. That single page is worth more in a security review than any comparison table, including this one.

Keep reading

• Claude in your own cloud tenant: Bedrock or Azure, under your own IAM roles
• Claude Code for enterprise: the three things that block sign-off past the first team
• Claude EU data residency: which platforms keep inference inside Europe, and what it costs
• LLM gateway for Claude: per-team budgets and audit-grade logging on one route