GitHub Copilot vs Claude Code

GitHub Copilot and Claude Code get compared as competitors often, even though they cover different scenarios: Copilot is an editor extension that mostly suggests code as you type and answers in a chat panel, while Claude Code is a separate terminal agent that reads a project on its own, edits several files, and runs commands from a task description.

Autocomplete and chat versus an agent

Copilot started as an autocomplete tool: a suggestion appears right on the line as you type, and you accept it with Tab. Chat with the open file's context came later. It's a helper built into the familiar editing loop — it doesn't take over a multi-step task end to end, it assists on each individual step.

Claude Code works differently: you can hand it a task like "figure out why the tests are failing in this module and fix it" — and it will open the relevant files itself, propose edits, show a diff, and, if allowed, run commands to verify. The difference isn't that one is smarter than the other; it's who's driving: with Copilot, the developer stays at the wheel on every line; with Claude Code, the developer approves the agent's steps.

Billing: subscription versus pay-per-token

Copilot is sold on subscription — a flat fee regardless of usage volume within the plan's limits. Claude Code through a compatible gateway is metered differently: you pay for actual tokens consumed by each model. Zukko adds X-Zukko-Cost-Micros (the cost of that specific request in microdollars, 1,000,000 = $1) and X-Fetch-Balance-Cents (the remaining balance after the charge, also in microdollars) to regular (non-streaming) responses. Claude Code streams, and streaming responses do not include these headers — its per-request spend shows up in the dashboard and via GET /v1/usage (account-wide history), so spend is still transparent at the level of a single call, not just a monthly total.

For a team this means different budgeting models: a subscription has a known ceiling in advance, while pay-per-token spend grows with task volume — but it can be constrained precisely, since each API key can carry its own daily and monthly dollar spend limit and a list of allowed models, set in the dashboard on the key's page.

Connecting

Copilot is tied to a GitHub account and runs inside that ecosystem with no separate base-URL setup — that's part of its convenience and, at the same time, its constraint: you can't swap the model provider without swapping the tool. Claude Code, by contrast, is configured through environment variables:

export ANTHROPIC_BASE_URL="https://api.zukko.pro"
export ANTHROPIC_AUTH_TOKEN="fetch_your_key"

Note it's specifically ANTHROPIC_AUTH_TOKEN, not ANTHROPIC_API_KEY — with the latter, Claude Code assumes it should authenticate via an official Anthropic account and prompts for login instead of using the gateway key. The URL is given without /v1, because Claude Code, as an Anthropic-compatible client, appends the path itself and hits POST /v1/messages with the anthropic-version: 2023-06-01 header.

Choosing a model

Inside the Copilot ecosystem, which models are available and how you switch between them in chat is determined by the product and the plan. In Claude Code through Zukko, a model is just a string in the request body, and the catalog includes claude-opus-5-5 (Claude Opus 5.5), claude-sonnet-5, gpt-5.6-sol, gpt-5.6-luna, glm-5.3, and glm-5.3-flash (the current list is at GET https://api.zukko.pro/v1/models). Claude and GPT have a 1,000,000-token context; GLM has 128K and no vision. You can compare how the same task plays out across models on the fly, changing nothing but the model value.

curl https://api.zukko.pro/v1/messages \
  -H "Authorization: Bearer fetch_your_key" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-5.6-sol","max_tokens":512,"messages":[{"role":"user","content":"explain what this SQL query does"}]}'

What happens when something breaks

With Copilot, diagnosing a response problem usually comes down to GitHub's service status and account authorization. With Claude Code through Zukko, errors arrive with a specific code: 401 for an invalid key ({"error":{"message":"Invalid API key. Use Authorization: Bearer fetch_*","type":"authentication_error"}}), 402 for an empty balance (insufficient_balance, checked before the request reaches the model — a failed request costs nothing), 404 model_not_found for a typo in the model name, 503 model_disabled when a model is switched off, 429 when a key's limit is exceeded (key_daily_limit_reached / key_monthly_limit_reached). A response cutting off mid-stream is almost always a client or network timeout, not a token limit — worth checking max_tokens and the HTTP client's timeout settings.

Retries and caching

For an agent that might repeat the same request because of a flaky connection — relevant specifically for a terminal tool like Claude Code — the Idempotency-Key header prevents double-charging: a replay with the same value within 24 hours returns the same response for free. And if the same request is repeated on purpose, say during a repetitive check, an X-Zukko-Cache: true header turns on caching for up to 7 days for chat (temperature: 0 also enables the cache, but only for models that accept it — Claude models may reject a temperature other than 1 with a 400) — a repeat with an exactly matching request body returns instantly, flagged with X-Zukko-Cache: hit in the response. Editor-embedded autocomplete has no need for a mechanism like this by nature — Copilot is solving a different problem.

Which to pick

If the main value is fast, line-by-line suggestions right as you type and a chat panel without leaving the editor, that's Copilot's territory. If what's needed is an agent that works through several steps across a whole project on its own, with a budget tracked by actual token spend and constrained per key, that's Claude Code. Its key is created at zukko.pro/app/api-keys↗ and shown once, at creation — and nothing stops running both tools at the same time, since they aren't competing for the same spot in the workflow.