Copilot bills chat and agent sessions and gives Tab away. We ran four ordinary tasks twice on one storefront to find which half of the tool earns the $10.
Editorial Note: This article is based on hands-on use of the tools from our own test accounts, combined with product documentation, benchmark data, and publicly available information. All features, pricing, and benchmark figures are verified through official sources. See our Disclaimer.
Nine re-prompts is what four ordinary tasks cost us in GitHub Copilot before we wrote a 31-line instructions file. Two, after.
The four tasks were routine for a Next.js 15 storefront: add a discount-code field to checkout, fix a production stack trace, write tests for a module nobody had tested, and pull a cart calculation out of a component. Same repository, same $10 Copilot Pro seat, the same four requests. The only thing that changed was what Copilot knew before it started and what we checked when it finished.
GitHub moved Copilot to metered AI Credits on June 1, 2026, and the complaints since have been about bills. On the new meter our four tasks cost 118 credits the first time and 141 the second. One credit is a cent, so that is $1.18 against $1.41. Cost was never the problem. Discarded work was.
.github/copilot-instructions.md, anchor context with #file instead of describing files in prose, approve a plan before Agent mode edits anything, and name the test file as the contract so the agent cannot grade its own work. Expect one limit: none of that configuration reaches Tab completion, and GitHub does not bill Tab in credits either.
| What you are doing | The setting that decides it | What we measured |
|---|---|---|
| Adding a feature that spans files | Agent mode, plan approved before it edits | 7 of 7 files correct against 3 of 7 |
| Fixing a stack trace | #file on the failing file, trace pasted whole | Correct fix either way; only the configured run also wrote the regression test |
| Testing code nobody tested | “Name one change that should break each test” | 0 of 17 tests survived a broken build, against 3 of 11 |
| Keeping an agent out of trouble | Allow-list one command, not a shell | 6 commands proposed, all npm test |
| Enforcing house rules | .github/copilot-instructions.md | 0 convention breaches in review, against 6 |
Copilot Pro is $10 a month with 1,500 credits, split 1,000 base and 500 flex, which GitHub presents as $15 of model usage. Inline completions and next edit suggestions are not billed in credits on any paid plan, so the part of the product most people use all day is flat-rate. Chat, Agent mode, the CLI and code review draw from the pool by the token, and the pool resets at 00:00 UTC on the first of the month.
That splits a cost problem into two different problems. A bad prompt shows up twice: once as a re-prompt you have to read, once as credits. Our default runs spent 118 credits to produce one change we merged without touching it. The configured runs spent 141 and produced four. Per change kept, 118 against 35.
Free still gives 2,000 completions a month with limited chat, and Pro+ at $39 raises the pool to 7,000. If the meter is your worry rather than the workflow, the plan arithmetic is in Cursor pricing vs Copilot pricing.
A repository instructions file is the best half hour you will spend on the product. Ours sits at .github/copilot-instructions.md and says what a contractor would need on day one: the stack, the folder shape, the rules that get broken in review, and how tests are named.
Next.js 15 App Router, TypeScript strict, Drizzle over Postgres, next-intl for every user-facing string, Zod on every route handler. Server Components unless interactivity requires otherwise. No raw SQL strings. No console output in committed code. Vitest beside the file, Playwright under e2e/.
Three details worth knowing before you write yours. The file does not reach inline suggestions. VS Code’s documentation says it plainly: custom instructions are not taken into account for suggestions as you type, so a team that lives in Tab gets nothing from the file. Support differs by surface. Repository instructions work in every client; path-specific files in .github/instructions/*.instructions.md need an applyTo glob and are ignored by GitHub.com chat and Eclipse; personal instructions never reach VS Code chat, though the CLI reads them. Precedence is additive. Personal, repository and organization instructions are all sent, so a narrow file does not silence a broad one.
One switch worth knowing for teams: excludeAgent: code-review in a file’s frontmatter keeps it out of review while the cloud agent still reads it. Review reads instructions from the pull request’s head branch, so a rule change can be tested inside the pull request that adds it.
Our first discount-code prompt named the table in prose, and Copilot queried a discounts table that has never existed. That is not a reasoning failure. The schema was never in the context.
Anchoring costs one line of typing. #file:lib/db/schema.ts puts the schema in front of the model, #file:app/api/checkout/route.ts puts the handler beside it, and #selection scopes a question to what you highlighted. #codebase searches the workspace when you genuinely do not know where something lives, which is slower and, on an 8,700-line repository, offered two wrong files before the right one.
The slash commands carry their own instructions, which is why they beat anything you type by hand: /fix on a selection that will not compile, /tests on a module with no coverage, /explain on code you inherited. We used /tests for task three and it saved more typing than the paragraph we would have written.
Agent mode is where credits disappear, because every step re-sends a growing context. We allow-listed npm test and nothing else. Across the four configured tasks the agent asked to run six commands, all test runs, and we approved six.
On anything wider than one file, make it plan before it writes. Reading a plan takes 30 seconds. Reading a seven-file diff to work out what it decided takes twenty minutes, and the third time we did that we stopped skipping the plan.
In the default run, task three produced 11 tests and we merged them. Then we broke the implementation on purpose, changing a rounding rule and a null check, and 3 of the 11 still passed. A test that passes against broken code is a comment.
The configured prompt asked for one extra sentence per test: name a change to the implementation that should make this test fail. Seventeen tests, four deliberate breaks, no survivors. That is the cheapest quality gate in this workflow, and it is one line in the request.
Six convention breaches reached review in the default runs: the invented table, a raw SQL string that bypassed Drizzle, use client added to a Server Component to make a form work, two English strings hardcoded past next-intl, and a console.log carrying a customer email. None of it is exotic. All of it is the kind of thing a colleague catches in ten seconds and an agent catches only if you told it what the house rules are.
Task four failed differently. The hook extraction took four attempts, 35 credits and 71 minutes, and we merged nothing. The configured pass did it in two attempts with the public props frozen in the prompt.
A change spanning two repositories is a manual job, because the agent reads the workspace and not your other checkouts. Code review is cheap and narrow: about $0.21 a pull request in our earlier test, and it sees the diff rather than the service around it. A long unattended pass over code you have not read is a different tool class, and those comparisons live in Cursor vs GitHub Copilot and the best AI pair programming tool ranking.
No. VS Code’s documentation states that custom instructions are not taken into account for inline suggestions, and GitHub keeps completions and next edit suggestions outside the credit meter on paid plans. The file governs chat, Agent mode, the CLI and, with the right setting, code review. If Tab is how you use Copilot, write the file for your teammates rather than for yourself.
For anyone whose day is mostly completions, yes: those are unmetered and Pro still includes 1,500 credits on top. Our four tasks, run twice, used 259 credits between them, about a sixth of the monthly pool. Where it stops being good value is sustained agent work, because one long session can spend what our entire test spent. Pro+ at $39 with 7,000 credits exists for exactly that.
Anchor the files so it stops searching, approve a plan before it edits, keep one task per session, and allow one command you have named. Our default pass spent 118 credits on four tasks and kept one change; the configured pass spent 141 and kept four. The waste sat in re-prompts and rebuilds, not in the token price.
Use .github/copilot-instructions.md if Copilot is the only agent your team runs, because every Copilot surface reads it, code review included. Use AGENTS.md if you also run Claude Code or Codex, since those read it and Copilot reads it in chat, the CLI and the cloud agent. Keeping two copies in sync is worse than picking one and keeping it accurate.
The effective way to use GitHub Copilot in 2026 is to spend your configuration effort on context rather than on prompt wording. One 31-line file, #file instead of prose, a plan before Agent mode touches a second file, and tests that fail when the implementation breaks. That combination took our four tasks from one mergeable change to four, and from 118 credits per kept change to 35.
Two boundaries are worth stating. If your work is entirely Tab completion, skip all of it: the instructions file does not apply, no credits are spent, and Pro at $10 is already the cheapest useful thing in this category. If your work is a change that spans repositories or runs overnight, this is the wrong tool, and the honest answer is a terminal agent working in its own worktree.
October 21 to 23, 2026. One Next.js 15 App Router storefront, 8,712 lines of TypeScript, 318 Vitest tests and 44 Playwright tests, all green before we started. One $10 Copilot Pro seat with the extension pinned, and the same four prompts run twice on fresh branches with new chat sessions. The default pass used Tab and a single-sentence request in Ask mode, no instructions file, no file references. The configured pass added the 31-line instructions file, #file anchors, a plan approved before any edit, and npm test as the only allow-listed command. Credits were read from the billing page after each pass rather than estimated.
#file:lib/db/schema.ts and #file:app/api/checkout/route.ts in task one.| Metric | Default: Tab + one-line prompt | Configured: instructions, #file, Agent |
|---|---|---|
| Tasks merged without further edits from us (of 4) | 1 of 4 | 4 of 4 ✓ |
| Task 1 files correct on the first attempt | 3 of 7, and one table that does not exist | 7 of 7 ✓ |
| Re-prompts across the four tasks | 9 | 2 ✓ |
| House-rule breaches found in review | 6 | 0 ✓ |
| Credits spent on the four tasks | 118 | 141 |
| Credits per change we kept | 118 | 35 ✓ |
| Wall clock, including the rebuilds | 4 h 20 m | 2 h 05 m ✓ |
| Task 3 tests that passed against a build we broke on purpose | 3 of 11 | 0 of 17 ✓ |
| Terminal commands the agent asked to run | None: Ask mode cannot run one | 6, all npm test, all approved ✓ |
| Comments a second developer left on the branches | 14 | 4 ✓ |
| Winner | 🏆 Configured: instructions file, #file anchors, approved plan | Default: cheaper in credits, 3x the rework |
The same four tasks went from one mergeable change to four after an instructions file and a set of #file anchors, at 35 credits per kept change instead of 118. Completions stay unmetered, so the $10 Pro seat covers the Tab half of your day whatever the agent does with the rest of it.
Keep exploring — these related comparisons and guides help you decide.