GitHub Copilot Pro: Best $10 AI Coding Plan with Zed IDE & CLI

GitHub Copilot Pro in 2026: how AI Credits changed the $10 plan, what burns your balance, what is still free, and setup for Zed, VS Code, and the CLI.

Updated September 11, 2026Published October 20, 202520 min read

GitHub Copilot Pro is still $10/month, and it is still the cheapest way I know to get a frontier-model coding agent, inline completions, a CLI, and Zed support under one subscription. What changed is what that $10 buys you.

On June 1, 2026, GitHub replaced premium request units with GitHub AI Credits, consumed by actual token usage. Completions are still free. Chat and agent sessions now burn a balance that runs out. That single change flips the “unlimited AI for ten bucks” story into an operations question: how do you keep an agent session from eating your month?

What changed since the first version of this guide

The old model: 300 premium requests per month, fixed cost per model, automatic fallback to a cheaper model when you ran out.

The 2026 model:

Pro is still $10/month, but you now get 1,500 AI Credits per cycle — 1,000 base plus a 500 flex allotment (1 credit = $0.01 of metered usage)
Credits are consumed at the published per-token API rates for whichever model you pick
No fallback. When the balance hits zero, chat and agent work stop until you buy more or the cycle resets
Completions and Next Edit suggestions are still included in every plan and consume zero credits
Copilot Max at $100/month exists for people who run long agent sessions

If you want the full breakdown of the billing change itself, I wrote a separate piece on Copilot usage-based pricing and five cheaper alternatives. This guide is the operational one: what to install, what to type, and what will surprise you on the invoice.

What Copilot Pro costs in 2026

The plan prices did not move. The credit allowances did.

Plan	Price	What you get
Copilot Free	$0	2,000 completions/month, limited chat and agent access, available to everyone
Copilot Pro	$10/month	1,500 AI Credits (1,000 base + 500 flex), unlimited completions, CLI, agent mode
Copilot Pro+	$39/month	7,000 AI Credits (3,900 base + 3,100 flex), everything in Pro
Copilot Max	$100/month	20,000 AI Credits, built for long agent runs
Copilot Business	$19/user/month	Same tooling, no training on your code
Copilot Enterprise	$39/user/month	Business controls plus enterprise policy

Two details worth knowing before you pay:

Code review consumes GitHub Actions minutes on top of AI Credits. If you turn on Copilot review for every PR in a busy repo, you are paying twice: once in credits, once in CI minutes.
Annual plan holders stay on the old premium-request system until the plan expires, but model multipliers went up on June 1. When the annual term ends you drop to Copilot Free and have to choose a monthly plan.

GitHub also ran a transition promo from June through August 2026 that raised Business to $30 in credits and Enterprise to $70. That window is closed, so those plans are back to their standard amounts.

What actually burns the $10

Credit spend is token spend. Here is the order of magnitude, using the published rates as the baseline:

Task	Model class	Rough credit cost
Inline completion	small/fast model	$0.00 (included)
Chat question about one file	mid model	~$0.02
Multi-file refactor	frontier model	~$0.50
Agent session, ~1 hour	frontier model	~$5 to $8
Agent session, ~4 hours	frontier model	~$25 to $40

Read that last row twice. One long agent session with a frontier model costs more than the whole Pro plan. Two or three of those a month and you are buying extra credits or switching to a cheaper model.

GitHub changes the model lineup frequently, and each model has its own rate on the Copilot models and pricing page. Check that page before you kick off a multi-hour agent run, not after.

My defaults for staying at $10

Keep the plan predictable

Completions stay on a small model. Do not switch your completion model to a frontier one. You gain little and pay per keystroke-class request.

Route by task. Small model for refactors and boilerplate, frontier model for the two or three genuinely hard things that week.

Scope agent sessions to one ticket. A vague prompt (“clean up the codebase”) is how a $5 session becomes a $30 session.

Write the instructions file. A repo-level instructions file stops the agent from re-deriving your build, test, and lint commands on every session.

Turn on budget alerts. Copilot supports alerts at 75/90/100% of your credits. Enable all three in the Copilot billing settings.

The instructions file is the highest-value thing on that list. Drop this in the repo root as .github/copilot-instructions.md:

markdown

# Project instructions

- Package manager: pnpm. Never run npm install.
- Build: pnpm build
- Test: pnpm test --run
- Lint: pnpm lint
- Type check: pnpm typecheck
- Framework: Astro 7 + Tailwind 4. Do not add new dependencies without asking.
- Never edit files under dist/ or .astro/.
- Migrations live in db/migrations. Do not write ad-hoc SQL against the dev database.

VS Code also reads a plain AGENTS.md if you prefer one file that any agent can use. Either way, the point is the same: fewer wrong guesses means fewer round trips means fewer tokens.

Getting started in five minutes

A GitHub account with Copilot Pro active (Free works for testing completions)
One supported editor: Zed, VS Code, JetBrains, Visual Studio
Node.js 20 or newer, only if you want the CLI
The gh CLI, only if you want the older shell-helper extension
A repo you are willing to experiment on, not your production checkout

Step 1: pick a plan

Start on Copilot Free if you just want to test completions. Move to Pro when you want agent mode, the CLI, and model choice.

Open GitHub Copilot plans
Choose Pro ($10/month)
Confirm on the billing page

Verify: go to your GitHub billing overview and confirm the plan shows as active and “AI Credits” shows a usage meter with the current cycle’s balance.

Step 2: enable the models you want

Visit https://github.com/settings/copilot/features and turn on model choice and any preview models. New frontier models often ship behind this toggle first.

Verify: open Copilot Chat in your editor, click the model picker, and confirm the model you enabled appears in the list. If it does not, sign out and back in to refresh the token.

Step 3: install in your editor

Zed (recommended)

bash

# macOS
brew install --cask zed

# Linux / WSL
curl -f https://zed.dev/install.sh | sh

Open Zed, then sign in with GitHub from the Copilot button. The agent panel is where you talk to the model; inline suggestions show up as ghost text as you type.

VS Code

bash

code --install-extension GitHub.copilot
code --install-extension GitHub.copilot-chat

Then sign in with GitHub from the account menu. Agent mode lives in the chat panel, not in the inline suggestion layer.

JetBrains / Visual Studio

Install the GitHub Copilot plugin from the marketplace, restart the IDE, and sign in with GitHub. Completions and chat work the same way. Model choice may lag a release behind VS Code.

Terminal (CLI)

bash

npm install -g @github/copilot
copilot

Interactive session, then /login if you are not authenticated. For one-shot prompts:

bash

copilot -p "summarize what this repo does"

Verify: ask the chat panel something trivial about your repo, like “what does the main entrypoint do?” If you get an answer that references real files, auth and indexing are working. If you get an auth error, your GitHub session is stale. Sign out and back in.

Zed + Copilot: the fast setup

Zed is the editor I reach for when I want completions to appear instantly and the UI out of my way. It is written in Rust, it is not Electron, and the Copilot integration sits in the agent panel next to its own AI features.

Setup, in order:

Install Zed (brew install --cask zed on macOS)
Open the agent panel and pick GitHub Copilot as the provider
Sign in with GitHub when prompted
Pick your model in the panel’s model selector

Verify: with a file open, type a function signature and pause. Ghost text should appear within a second or two. If nothing shows up, check that your Copilot plan is active on the GitHub side first. A stale or expired subscription looks exactly like a broken editor.

Keyboard shortcuts worth memorizing:

Tab - accept a suggestion
Alt + ] / Alt + [ - cycle to the next or previous suggestion
Cmd/Ctrl + Shift + P → “agent” opens the agent panel
Cmd/Ctrl + Enter - send the prompt in the panel

Do not pay for AI twice in Zed

This trips people up. Zed has its own subscription, Zed AI, at $10/month (unlimited edit predictions plus a small token allowance, usage-based beyond that) and Business at $30/seat. If your Copilot Pro subscription already covers agent work, you do not need Zed AI for the Copilot path. Pick one.

My default: Copilot Pro for the coding agent and the CLI, and skip Zed AI unless you specifically want Zed’s own model routing and edit-prediction features. Two $10 subscriptions that do the same job is $240 a year for overlap.

Zed also speaks the Agent Client Protocol, which lets you run external agents such as Claude Code or a Gemini-based CLI as panel agents. That is a separate setup and a separate bill. See using Claude, Codex and Gemini subscriptions with any editor if you go that route.

Copilot CLI

The new Copilot CLI is an agent, not a suggestion box. It reads files, runs commands, and makes changes in your working tree.

bash

# Install (Node 20+)
npm install -g @github/copilot

# Interactive session
copilot

# Non-interactive, good for scripts and CI
copilot -p "find every place we call the legacy billing API and list the files"

Day-to-day this is what I use it for:

bash

# Scoped changes on a branch
git switch -c fix/rotation-lock
copilot -p "the secret rotation job double-fires when the lock expires; add a guard and a test"

# Repo-shaped questions before I touch anything
copilot -p "which services read from the legacy queue directly, and where are the consumers?"

# Commit and PR plumbing
copilot -p "stage the changes in src/, write a conventional commit, push the branch"

There is also the older gh extension, which only does suggest/explain one-liners and does not touch your files:

bash

gh extension install github/gh-copilot
gh copilot suggest -t shell "find files larger than 100MB"
gh copilot explain "find . -name '*.log' -mtime +7 -delete"

Verify: run copilot -p "print the current git branch name". It should answer with the actual branch. If it hangs or errors on auth, run copilot interactively and use /login.

Failure modes I hit first:

command not found after install - the npm global bin directory is not on your PATH. Check npm bin -g and add it.
Node version too old - the CLI needs Node 20 or newer. node -v first, not last.
Agent edits the wrong repo - start copilot from the repo root, not from your home directory. The working directory is the agent’s world.

Coding agents and code review

Two separate features, easy to confuse:

Cloud agent. Assign a GitHub issue to @copilot. It spins up a sandbox, works the issue, and opens a pull request. You review the PR like any other contributor’s. One issue, one PR, credits billed for the tokens the run consumes.

Code review. Ask Copilot to review an open PR. Useful for a first pass on a large diff. Remember it also consumes Actions minutes, so it is not free even at zero credits.

Guardrails that keep this sane:

One issue per run. Do not hand the agent an epic.
Require a passing test suite on the PR before you look at it.
Read the diff. The agent is confident whether or not it is right.
Keep secrets out of reach. A scoped token and no production credentials beats a clever prompt.

Do not build your own agent infrastructure

The standalone agent infrastructure pattern (wiring your own runners in GitHub Actions to call the agent API) is not worth the complexity. You end up maintaining trigger logic, a runner, and secret handling for a job the built-in cloud agent already does.

My default: use the built-in cloud agent for issue-to-PR work, the CLI for local multi-file changes, and skip the DIY option entirely. Same result, no extra plumbing to keep patched.

Models: what to reach for

Copilot is multi-model. The lineup rotates, but the cost shape is stable:

Model class	Examples	Relative burn	Use for
Small / fast	mini-class GPT models	cents per session	Completions, small edits, commit messages
Mid	Sonnet-class Claude, current Gemini	dollars per long session	Most refactors, test writing, review passes
Frontier	Opus-class Claude	several dollars per hour of agent work	Architecture, gnarly debugging, one-off hard problems

The rule I use: start every session on a mid or small model, and only escalate when the mid model visibly fails twice. Escalating early feels productive and costs a lot more for the same diff.

Privacy note: Copilot Free, Pro, and Pro+ train on your interactions by default. Business and Enterprise do not. If you are on Pro and working on client code, open Settings → Copilot and turn off the data-sharing option. It is one toggle and it is on the wrong side by default for a lot of people.

Failure modes and footguns

Credits run out mid-task

Chat and agent work stop until you buy credits or the cycle resets. Completions keep working, which makes it easy to miss the real failure: an agent that has stopped mid-refactor while inline suggestions keep flowing.

Fix: enable the 75/90/100% budget alerts and check the usage meter in the billing overview before starting a long run.

The model I want is missing

Model choice is gated behind a settings toggle for new releases, and some plans lag on the newest frontier models.

Fix: enable model choice at https://github.com/settings/copilot/features, then restart the editor. If it is still missing, the model is not available on your plan tier.

Agent broke code that used to work

This is the real risk with agentic work, not the bill. Long runs touch files that had nothing to do with the ticket.

Fix: work on a branch, require tests to pass before you review, and keep the ticket narrow. A copilot-instructions.md that says “never touch files under db/migrations” prevents a whole class of incidents.

Auth errors after a token change

Rotating your GitHub password, enabling SSO on an organization, or a long-idle editor session all break auth in a way that looks like a broken install.

Fix: sign out and back in from the editor, and re-run /login in the CLI. Do not start reinstalling extensions.

Rollback and cleanup

Nothing here locks you in. To unwind:

Cancel or downgrade: Settings → Billing → Copilot. Annual plans have to run out; monthly can be cancelled immediately and you drop to Free.
Stop credit spend: remove any saved payment method for extra credits so a runaway agent cannot top itself up.
Remove the CLI: npm uninstall -g @github/copilot
Remove the extension: code --uninstall-extension GitHub.copilot and GitHub.copilot-chat
Clean up repo config: delete .github/copilot-instructions.md if other tools now read it and get confused by the Copilot-specific rules.

Keep your AGENTS.md if you wrote one. It is tool-agnostic and works with whatever you replace Copilot with.

When $10 is not enough

If your usage looks like the 4-hour agent session row in the cost table, Copilot Pro is the wrong plan. Options in rough order of what I would try first:

Copilot Max at $100/month if you want to stay in the Copilot ecosystem and stop thinking about credits.
OpenCode with a cheap model, paying per token. The OpenCode Go plan bundles a stack of coding models for $10/month flat, which is the closest thing to the old premium-request model I have found. See the OpenCode Go review for limits.
Agent Router if you want one endpoint that routes to Claude Code, Codex, and Gemini CLI, so model choice stops being a subscription decision.
Codex CLI if you already pay for a ChatGPT plan; the CLI is included.
Local models with Ollama for zero per-token cost. Run it on a box you already own, or a cheap Hetzner instance if you would rather not tie up your laptop. Local models handle routine edits; you will still want a frontier model for multi-file work.

VPS prices jumped across the board in 2026 — if you’re rethinking a rented box, see what changed and when a mini PC wins.

If flat-rate is what you want, the OpenCode Go plan is the closest replacement for the old premium-request model:

OpenCode Go ($10/month flat)

For the full comparison across every tool, see best AI coding tools and agents in 2026. If you want a free path first, Kiro still has a usable free tier (Amp’s is paused at the time of writing), and these open models get close enough for a lot of day-to-day coding.

FAQ

Are premium requests gone for good?

Yes, for monthly plans. Since June 1, 2026, Copilot uses GitHub AI Credits instead of premium request units. Credits are consumed per token at published model rates. Annual plan holders keep the old system until their term ends.

Is Copilot Pro still worth $10?

If you mostly use completions and occasional chat, yes. Completions are included in every plan and consume zero credits, and your chat burn will be small. The value gets worse the more you lean on long agent sessions, because those are billed by token consumption rather than a flat allowance.

What happens when I use all my credits?

Chat and agent features stop until you buy additional credits or your cycle resets. Completions and Next Edit suggestions keep working. There is no automatic downgrade to a cheaper model anymore, which was how the old premium request system behaved.

What is Copilot Max?

A $100/month tier aimed at heavy agentic use. It exists because the $10 Pro allowance is easy to exhaust with long agent sessions. If you are consistently buying extra credits on Pro, Max is the cheaper route. Check the current pricing page before committing, since GitHub has been adjusting these tiers.

Can I use Copilot in Zed for free?

You need a Copilot plan to use Copilot inside Zed, but Copilot Free is now available to everyone, not just students and open source maintainers. It gives you 2,000 completions and 50 chat requests a month, which is enough to evaluate the editor integration before paying.

Does Copilot send my code to external servers?

Prompts, context, and the file content the agent needs are sent to GitHub and the model provider to generate suggestions. Your whole repository does not leave your machine. On Free, Pro, and Pro+, your interactions are used for training by default unless you opt out in Settings → Copilot. Business and Enterprise plans do not train on your code.

Can I cancel anytime?

Monthly plans, yes. Cancel in Settings → Billing → Copilot and you drop to the Free tier. Annual plans run to term, then you move to Free and choose a monthly plan or leave.

Conclusion

Copilot Pro at $10/month is still the cheapest way into a frontier-model coding agent with editor, CLI, and cloud agent coverage in one subscription. In 2026 the feature set is not the problem. The billing model is.

Get started

Start on Copilot Free if you have not tried it
Move to Pro ($10) when you want agent mode and the CLI
Enable model choice at https://github.com/settings/copilot/features
Add .github/copilot-instructions.md to your main repo
Turn on the 75/90/100% budget alerts before your first long agent session

If your workflow is completions plus occasional chat, you will barely notice the credit system. If you live in hour-long agent sessions, decide now between Copilot Max, a flat $10 alternative like OpenCode Go, or paying per token with the model you actually want. Waiting until the balance hits zero mid-refactor is the expensive way to learn your usage profile.

#AI Tools #GitHub Copilot #AI Coding

Table of Contents