GitHub Copilot, answered short enough to quote

Copilot Free costs nothing. Copilot Pro is $10 a month and includes 1,500 GitHub AI Credits; Pro+ is $39 with 7,000 credits; Copilot Max is $100 with 20,000. Copilot Business is $19 per seat and Copilot Enterprise $39 per seat, with credits pooled at the billing entity rather than per user.

Each paid individual plan splits its allowance into base credits, which match the subscription price exactly, and a flex allotment on top that GitHub describes as variable. Base credits are spent first. One AI credit is $0.01, so Pro's 1,500 credits represent $15 of usage inside a $10 subscription.

AI credits are the unit Copilot's AI features are metered in, at $0.01 per credit. Cost is charged per token at a rate that differs by model, so there is no fixed price per prompt: one long agent session on a frontier model can cost more than a hundred short chat questions.

Chat, Copilot CLI, the cloud agent, Spaces, Spark and third-party coding agents all consume credits. GitHub names three drivers of consumption: conversation length and complexity, agentic features that make several model calls per task, and model choice. Paid plans receive a 10% discount on model costs while using automatic model selection.

No. Code completions and next edit suggestions are not billed in credits and are unlimited on every paid plan. Credits are spent only by features that call a model on request: Chat, Copilot CLI, the agents, code review and Spaces. Copilot Free is the exception, capped at 2,000 completions a month.

This decides which plan is worth buying more than the headline price does. A developer who mostly accepts inline suggestions barely touches the allowance, while one running daily agent sessions on a large repository can exhaust Pro's 1,500 credits well before the month ends — same subscription, entirely different economics.

Included credits reset to the full monthly amount at 00:00:00 UTC on the first day of each calendar month. GitHub states this date is fixed and does not move with your subscription billing date. Unused credits do not carry over: whatever is left at the reset is forfeited, not banked.

The allowance period and the billing period are different things, and conflating them is the most common reason a usage estimate comes out wrong. Billing normally starts on the day you subscribed. When working out how many days of allowance remain, count to the first of the month, not to your invoice date.

Not for new subscriptions. Premium requests were replaced by AI credits on 1 June 2026, and GitHub now scopes that documentation to Pro and Pro+ subscribers on an existing annual plan who stayed with request-based billing. Figures such as 300 requests, 1,500 requests or $0.04 per extra request describe the retired scheme.

This is the fastest way to date a Copilot article you find elsewhere. Anything quoting a monthly request count, a per-model request multiplier, or a flat charge of thirteen requests per code review is describing pre-June-2026 billing. The current model is per token, per model, denominated in credits at $0.01 each.

At .github/copilot-instructions.md in the repository root: the .github directory, a hyphen in the filename, the .md extension. Path-specific files live in .github/instructions/, may use subdirectories, must end in .instructions.md, and must open with a frontmatter block containing an applyTo glob.

Agent files follow different rules again: AGENTS.md can sit anywhere in the tree, while CLAUDE.md and GEMINI.md are read from the repository root only. A file at the root without the .github/ directory, or a .instructions.md file outside .github/instructions/, is not an instruction file — it is a Markdown file nothing reads.

It is one of five things, in this order: the file was never discovered; the session loaded a copy before your edit; a path-specific file's applyTo does not match the file you are editing; the rule has no observable effect to follow; or two files in scope contradict each other. Check discovery first.

Discovery is the only one of the five you can observe directly. In the IDEs and on GitHub.com, expand the References section of a chat response — a file that was used appears there. In Copilot CLI, run /instructions, which lists every file discovered for the session. A file absent from that list was not read, whatever it says inside.

For Copilot Chat: VS Code, Visual Studio, the JetBrains IDEs, Xcode and Copilot CLI read them. Chat on GitHub.com and in Eclipse reads the repository-wide file only. The cloud coding agent and Copilot code review read path-specific files everywhere they run, independently of which editor you use.

Where a path-specific file matches and a repository-wide file also exists, GitHub states that instructions from both are used — the scoped file adds to the shared one rather than replacing it. In VS Code specifically, a .instructions.md file carrying no applyTo is never applied automatically; it has to be attached by hand.

No. GitHub states that changes to custom instruction files are not immediately available in active CLI sessions. Exit and resume with copilot --continue, or start a new session, then run /instructions to confirm what loaded. The IDEs and GitHub.com behave differently: they apply instructions as soon as the file is saved.

The CLI also combines every instruction file it discovers, removes duplicates, and defines no general precedence between them — so two contradicting rules both reach the prompt and neither wins by rule. That differs from GitHub.com and the IDEs, where personal instructions rank above repository and then organization, while all relevant sets are still provided.

It is a GitHub Actions workflow at .github/workflows/copilot-setup-steps.yml that runs before Copilot's cloud agent starts a task, so the agent begins with your dependencies already installed. It must contain exactly one job, named copilot-setup-steps, and it takes effect only once it is on the default branch.

The agent honours six keys on that job — steps, permissions, runs-on, services, snapshot and timeout-minutes, capped at 59 — and ignores everything else, job-level env and container included. A failing setup step does not stop the agent: it skips the remainder and starts with whatever state exists. Code review reuses the same file unless copilot-code-review.yml exists.

Use the permission controls rather than the prompt wording. In VS Code the permissions picker sets a level for the whole session: Manual applies your approval settings, Allow all auto-approves every tool call. Configure chat.tools.edits.autoApprove with globs so sensitive paths always prompt, and keep auto-approval scoped to one session.

Terminal commands are governed separately: the agent asks before running them, and with auto-approval on, every subcommand of a compound command must match an approved rule before any of it runs. Agent sandboxing restricts file-system and network access further. A natural-language instruction is not a security boundary — it shapes intent, and nothing enforces it.

Work through six causes in order: the plan includes code review, since Copilot Free does not; organization policy permits it; a branch ruleset requesting Copilot review exists and is Active rather than Evaluate; that ruleset targets the pull request's base branch; the pull request is not a draft; and no review has already run.

GitHub is explicit that unless it is configured to review each push, Copilot reviews a pull request once. Automatic review fires when a pull request opens, and the first time a draft is marked ready — and on nothing else, unless Review new pushes or Review draft pull requests is selected in the ruleset itself.

By default no: Copilot leaves a Comment review, which does not count toward required approvals. Copilot approvals exist in public preview, are off by default, and need two separate settings — permitting Copilot to approve, and permitting those approvals to satisfy merge requirements. Organization or enterprise policy can forbid them outright.

Cost is worth knowing before enabling review everywhere. GitHub estimates $0.05–$1 of AI credits for a Lite review and $0.25–$5 for Balanced, excluding Actions minutes, rising with pull request size and the volume of custom instruction. Code review also reads instruction files from the head branch, not the base branch.

Usually because the expectations were read off the implementation rather than from a requirement, so the tests agree with the code including its bugs. VS Code's own guidance warns that asking an agent to infer every expectation from the implementation risks producing tests that preserve an existing defect rather than catching it.

The decisive experiment takes two minutes: break the implementation deliberately — invert a comparison, delete a guard clause — and run the suite. If it still passes, the assertions are checking that execution finished rather than what it produced, or a mock has replaced the thing under test. Ask for the case list before any code is written.