Getting Started with GitHub Copilot: Plans, AI Credits, Surfaces (VS 2026, VS Code, Rider, GitHub.com, CLI) and Model Choice

Version note: The code in this post was built and run with .NET 10; GitHub Copilot CLI 1.0.112 was only installed and run with --version and --help, without signing in. Plan, price, model and version information (Visual Studio 2026 18.12, Visual Studio Code 1.146) was taken from docs.github.com, Microsoft Learn and code.visualstudio.com on 15 November 2026; Copilot itself was not tried in a live session for this post.

Guess First

Emre from the team got a Copilot Pro subscription: 10 dollars a month and 1,500 AI credits. In the first week he used inline suggestions all day on Bookstore, the online bookstore used as the shared example across this site's series, and a few times told the agent "add an endpoint for institutional orders and run the tests". Halfway through the month he saw that most of his credits were gone and was surprised: "I mostly pressed Tab."

What is your guess? Which one ate most of the credits: thousands of inline suggestions or a few agent sessions? How many credits does a thirty-step agent session cost, depending on the model? The answer is in the middle of the post, from a small calculation that uses the prices on docs.github.com.

Copilot's Map Today

GitHub Copilot is no longer a single extension; it is a group of features that run in different places behind the same account. In the first post of the AI-Assisted Development series we looked at the tool types (completion, chat, IDE agent, cloud agent) independent of any tool, and in the ninth post of the IDEs series we toured the AI features of Visual Studio, Visual Studio Code (VS Code) and Rider in one post. This series takes the same picture deeper from Copilot's side. First, the names of the parts:

• Inline suggestion: a suggestion that appears as grey text (ghost text) at the cursor while you type. Next to it are next edit suggestions (NES), which look at your last edit and suggest where the next change in the file is and what it is. The topic of the second post.
• Chat: asking questions, explaining code, producing a plan. In the IDE it has modes such as Ask, Plan and Agent; the third post.
• The agent in the IDE: a loop that takes a goal, reads and edits files, runs commands in the terminal, reads build and test output and tries again. The fifth post.
• Copilot in the cloud: agent sessions on GitHub.com and GitHub Mobile that go from an issue to a pull request; formerly the cloud (coding) agent. The seventh post.
• Code review: asking Copilot to review a pull request; the eighth post.
• Copilot CLI and the Copilot app: the agent in the terminal and the desktop app. The CLI is the ninth post.

Not every feature exists everywhere, and they do not always work under the same name. As of 15 November 2026, this is the situation on the surfaces a .NET and Angular developer uses:

Each row is a separate client, but billing and policy live in one place: your GitHub account and the organization you belong to. So let us talk about money first.

Plans and GitHub AI Credits

On 1 June 2026 Copilot's billing model changed. Paid plans used to give a monthly number of "premium requests", and each model drew from that number with a multiplier. With the change announced on 27 April 2026, GitHub dropped premium requests and replaced them with GitHub AI Credits. In the new model the cost is based on tokens: the input sent to the model, the output it generates and the cached tokens read from or written to the cache are multiplied by each model's own price, and the result is converted into credits. One AI credit is 0.01 dollars.

The table on the plans page on 15 November 2026:

Base credits equal the plan price and do not change; the flex part is a variable extra that GitHub says it will adjust as model prices and efficiency change. Base credits are used first, and flex kicks in automatically when they run out. Unused credits do not carry over; the allowance resets on the first day of every month. In Business and Enterprise the users' credits go into a shared pool at the organization level; when the pool runs out, usage is billed separately at 0.01 dollars per credit. On top of that, eligible enterprises have an option called "Copilot access" that includes no credits at all, where usage is metered and billed from the first token.

The most important line is this: inline suggestions and NES do not draw from your credits. On paid plans both are unlimited, and they keep working even with a zero budget or after a spending limit is reached. Credits are drawn by features that send tokens to a model, such as Chat, agent sessions, Copilot CLI, the cloud agent and third-party coding agents. Copilot code review uses both credits and GitHub Actions minutes.

When credits run out on an individual plan there are three options: move to a higher plan (you pay only the price difference), open an additional usage budget in dollars on your current plan, or wait for the monthly reset. If you do not want a surprise bill, GitHub's suggested route is to set the "Bundled AI credits" budget to 0 dollars and turn on "Stop usage when budget limit is reached".

What Does One Agent Session Cost?

Let us calculate the question from Guess First. In the agent loop the whole conversation is sent to the model again at every step: the system instructions, tool definitions, custom instructions, the messages so far and the tool outputs. Because the conversation grows at every step, the input tokens grow with every call too. The prompt cache makes this cheaper: the part sent in the previous call is read from the cache, and only the newly added part is written to it. The output of Copilot CLI's copilot help billing says the same thing: every call resends the conversation as input, and input tokens can reach millions.

We added this to the Bookstore repo as a small file-based app. Prices are from the "Models and pricing for GitHub Copilot" page on 15 November 2026, in dollars per million tokens:

#:property PublishAot=false
// Estimates the GitHub AI Credits of one agent session from per-token prices.
// Prices: docs.github.com "Models and pricing for GitHub Copilot", USD per 1M tokens, checked 2026-11-15.
// Run: dotnet run eng/ai-credits.cs -- [steps]
using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

int steps = args.Length > 0 ? int.Parse(args[0]) : 30;

// The agent loop resends the whole conversation on every call.
const int Prefix = 20_000;       // system prompt, tool definitions, custom instructions
const int ToolResult = 2_500;    // file read, build or test output added per step
const int Output = 600;          // reasoning + tool call written by the model per step

ModelPrice[] models =
[
    new("GPT-6 Luna", Input: 0.10m, CachedInput: 0.01m, CacheWrite: 0.125m, OutputPrice: 0.50m),
    new("Claude Sonnet 5.5", Input: 2.00m, CachedInput: 0.10m, CacheWrite: 2.50m, OutputPrice: 10.00m),
    new("Claude Opus 5.5", Input: 4.00m, CachedInput: 0.20m, CacheWrite: 5.00m, OutputPrice: 20.00m),
];

long cached = 0, written = 0, output = 0;
int context = Prefix;
for (int step = 1; step <= steps; step++)
{
    int newTokens = step == 1 ? Prefix : Output + ToolResult;
    cached += context - newTokens;   // already in the prompt cache
    written += newTokens;            // appended on this call, cached for the next one
    output += Output;
    context += Output + ToolResult;
}

Console.WriteLine($"Steps: {steps}, last context: {context:N0} tokens");
Console.WriteLine($"Input sent: {cached + written:N0} (cached {cached:N0}, written {written:N0}), output: {output:N0}");
Console.WriteLine();
Console.WriteLine($"{"Model",-20}{"USD",10}{"AI credits",12}{"Sessions in Pro (1,500)",26}");
foreach (ModelPrice m in models)
{
    decimal usd = (cached * m.CachedInput + written * m.CacheWrite + output * m.OutputPrice) / 1_000_000m;
    decimal credits = usd * 100m;   // 1 AI credit = 0.01 USD
    Console.WriteLine($"{m.Name,-20}{usd,10:F2}{credits,12:F0}{Math.Floor(1_500m / credits),26:F0}");
}

// Input is listed for reference: in this model every new token is written to the prompt cache.
record ModelPrice(string Name, decimal Input, decimal CachedInput, decimal CacheWrite, decimal OutputPrice);

$ dotnet run eng/ai-credits.cs
Steps: 30, last context: 113,000 tokens
Input sent: 1,948,500 (cached 1,838,600, written 109,900), output: 18,000

Model                      USD  AI credits   Sessions in Pro (1,500)
GPT-6 Luna                0.04           4                       364
Claude Sonnet 5.5         0.64          64                        23
Claude Opus 5.5           1.28         128                        11

$ dotnet run eng/ai-credits.cs -- 60
Steps: 60, last context: 206,000 tokens
Input sent: 6,687,000 (cached 6,484,100, written 202,900), output: 36,000

Model                      USD  AI credits   Sessions in Pro (1,500)
GPT-6 Luna                0.11          11                       138
Claude Sonnet 5.5         1.52         152                         9
Claude Opus 5.5           3.03         303                         4

This is a model, not a measurement: the number of steps, the size of tool outputs and how much the cache holds will differ in a real session. Still, three results are clear. First, in a thirty-step session about two million input tokens go to the model, while the model writes eighteen thousand. The cost is driven by the context sent again and again, not by the output. Second, when the number of steps doubles, input grows three and a half times, because every new step carries the grown conversation again. Third, the model choice changes credit use by more than thirty times: on the Pro plan the same session fits 364 times with GPT-6 Luna and 11 times with Claude Opus 5.5.

You can see the cache's share from the same numbers: with Claude Sonnet 5.5, if the 1,948,500 input tokens of the thirty steps were paid at the normal input price (2 dollars per million) without a cache, it would cost about 4.08 dollars including output, that is 408 credits. This also answers Emre's question: inline suggestions spent no credits at all; a few long agent sessions used them up.

Choosing a Model: Auto and Copilot Fusion

Copilot has a model picker on every surface, but on the Free and Student plans only auto selection is available. On paid plans the list contains models from OpenAI, Anthropic, Google, Microsoft, Moonshot AI and xAI; the supported models page on 15 November 2026 lists more than thirty, and the list changes almost every month. That is why the rest of this series does not depend on a specific model name.

When you choose Auto, Copilot picks the model for each task: one system looks at the current health and availability of the services, the other at how hard the task is. Model switches happen at cache boundaries so that the cache is not wasted. Auto has three tiers: Efficiency puts cost first, Intelligence puts quality first, and Balance weighs both. On a paid plan, using auto in Chat and the cloud agent gives a 10 percent discount on model costs; the bill still reflects the price of the model auto picked. Models your admin has disabled and models your plan does not include are not among auto's options. If no model is available, GPT-5.3-Codex, which GitHub marks as the LTS model, is used.

On some surfaces you will see Copilot Fusion in the picker instead of Auto. Fusion is not a model but a router that picks models at run time and, when needed, runs several models together: it can give the task to a single model (Single), have a judge model check a cheap model's draft and escalate to a stronger model if needed (Cascade), or have several models critique a draft in parallel and revise it with the combined feedback (Critique). It has three effort levels called Standard, High and Max. Until 30 November 2026 GitHub gives a 30 percent discount on Fusion usage on paid plans. A practical rule: start daily work with auto or Fusion Standard, and pin a model name only when you see a difference on a task.

Code review is the exception here: GitHub neither lets you choose nor shows the model used for a review. For estimates, the pricing page gives ranges by effort level; a Balanced review averages about 1.50 dollars, not counting Actions minutes. More in the eighth post.

Setup: Visual Studio 2026, VS Code and the CLI

In Visual Studio 2026 you do not look for a Copilot extension on the Marketplace; the prerequisite on Microsoft Learn is Visual Studio 2026 and signing in to Visual Studio with a GitHub account that has Copilot access. The Copilot badge and the Chat window then open according to that account's plan. With 18.12 the new Chat experience built on the Copilot SDK became the default for eligible accounts; it uses the same foundation as Copilot CLI and the Copilot app. If you need to go back to the old experience, turn off "Use new Copilot chat experience" under Tools > Options > GitHub > Copilot > Copilot Chat and restart Visual Studio. A note on Microsoft Learn also matters: since 20 April 2026 no Copilot Pro trials are given; someone without a subscription starts on the Free plan.

In VS Code you choose "Use AI Features" from the Copilot icon in the Status Bar and sign in with your GitHub account; without a subscription, signing in enrolls you in Copilot Free. If you want to turn AI features off completely in a workspace, the chat.disableAIFeatures setting hides chat and inline suggestions and disables the Copilot extension. The new concept you need to know in VS Code is the harness: the framework that runs an agent session. Since 1.143 new sessions open in the Copilot harness by default; the Claude and Codex harnesses can also be chosen. The old Local harness was deprecated in 1.146 and will be removed in February 2027.

For Copilot CLI the documented routes are WinGet, Homebrew, npm and an install script. On Windows you need PowerShell 6 or later; the npm route needs Node.js 22 or later:

# Windows
winget install GitHub.Copilot

# with npm (any platform)
npm install -g @github/copilot

We did not install the CLI globally; we installed it with npm into the work folder and ran it without signing in. The version and help output do not need a login:

$ copilot --version
GitHub Copilot CLI 1.0.112.
Run 'copilot update' to check for updates.

$ copilot --help
Usage: copilot [OPTIONS] [COMMAND]

GitHub Copilot CLI - An AI-powered coding assistant.
...
      --max-ai-credits <credits>
          Set max AI credits for this session
...
      --mode <mode>
          Set the initial agent mode [possible values: interactive, plan, autopilot]
      --model <model>
          Set the AI model to use (use 'auto' to let Copilot pick
          automatically)

The --max-ai-credits option in the help output is the practical side of the calculation above: it puts a ceiling on the credits one session can spend. In the first real session you need to connect to your GitHub account with /login; according to the docs, a fine-grained personal access token with the "Copilot Requests" permission also works. We did none of this for this post; signed-in use of the CLI is covered in the ninth post, based on the documentation.

Why It Is Turned Off on a Company Account

If you use Copilot through a Business or Enterprise seat from your company, the most common reason a feature does not appear for you is a policy. The organization owner turns features and models on and off on the Policies and Models pages under Settings > Copilot on GitHub; a decision made at the enterprise level cannot be changed in the organization. The common ones:

If "Editor preview features" is off, agent mode and editor features in preview do not appear in Visual Studio; the new Chat experience in 18.12 also respects this choice. If the "Copilot CLI" policy is off, the CLI does not work at all. If "MCP servers in Copilot" is off, you cannot add an MCP server to the agent. A model not enabled on the Models page does not appear in the picker, and auto does not pick it either. If you see "External ingest is disabled by your organization's policy" in VS Code, the semantic index for a repo not hosted on GitHub is turned off; in the third post we will see what that does to context.

There is also account confusion. Only individuals without Copilot access through an organization or enterprise can get the Free plan. If you have a personal Pro plan and your company assigns you a seat, the personal plan is cancelled automatically and the remaining period is refunded pro rata; from then on the company's policies apply. The risks of working on company code with a personal account are the topic of the tenth post.

In Production

Set the budget from the start. On a personal account, a 0-dollar additional usage budget with "Stop usage when budget limit is reached" means stopping instead of a surprise when the allowance runs out. Spending controls and per-user usage reports for organizations are in the tenth post.

Keep clients up to date. GitHub publishes the minimum versions for credit-based billing to display correctly: VS Code 1.120, 18.6.0 for Visual Studio 2026, 17.14.33 for Visual Studio 2022, JetBrains plugin 1.9.1, Copilot CLI 1.0.48. Older versions keep working but may show wrong model prices, missing usage information and old terms (premium requests).

Make splitting long sessions a habit. As in the calculation, every step carries the whole conversation again, so carrying the context of a finished subtask into the next task affects both quality and budget. We will look at managing context in detail in the third post.

Common Pitfalls

Reading plan and price information from old blog posts. Most posts from 2025 and early 2026 explain things with premium requests and model multipliers; since 1 June 2026 AI credits have replaced them on monthly plans. The only exception is annual Pro and Pro+ subscribers: they stay on the premium request model until their annual plan ends.

Turning off inline suggestions because you think they are expensive. On paid plans inline suggestions and NES do not draw from credits; the reason to turn them off should be focus and code quality, not cost. When to turn them off is in the second post.

Making the strongest model the default. As you saw in the calculation, the same session can become more than thirty times more expensive when the model changes. Not every task needs the strongest model.

Thinking the Free plan is enough for team work. Free has 2,000 inline suggestions a month, models are chosen only through auto and agent features are limited; features such as Copilot in the cloud need a paid plan.

A Small Experiment

★☆☆ Run eng/ai-credits.cs with 10, 30 and 90 steps. When the number of steps triples, how many times larger does the input token count get? Explain it with conversation growth.

★★☆ Add a "no cache" scenario to the calculation: count all input of every call at the normal input price. For Claude Sonnet 5.5 over thirty steps, how many credits is the difference? Does the result match the roughly 408 credits we calculated by hand in the post?

★★★ Estimate your team's usage for one month: how many agent sessions per person per day, how many steps per session, which model? Is the Business plan's per-person pool of 1,900 credits enough, and if not, how many dollars a month does the additional usage cost? Write your assumptions as a table and compare them with the real usage report a month later.

We continue with inline suggestions, which do not touch your credits. In the second post we will look at using ghost text and NES well, the context that improves suggestion quality, and when to turn completion off, on Bookstore's Entity Framework Core configuration and tests.