GitHub Copilot AI Credits switch: Here's what to do before June 1

On June 1, 2026, GitHub Copilot drops its old premium-request model and goes fully token-based. Every interaction (chat, agent mode, code review,...) will now draw down a pool of GitHub AI Credits, where 1 credit = $0.01 USD. Code completions stay free and unlimited, but everything else is metered.

The base plan prices aren't changing. Copilot Business stays $19/month and includes $19 in credits. Copilot Enterprise stays $39/month with $39 in credits. But here's the catch: once your included credits are gone, you either pay overage or you stop. No more "unlimited premium requests with a monthly cap." You get a dollar amount, and you spend it.

That makes budgeting more important than ever — especially for teams and power users running agentic workflows (aren’t we all?).

What you're paying for

Before you can budget, you need to understand the cost drivers. GitHub AI Credits are consumed based on token usage: the number of tokens sent to and received from the model, plus any cached context. The total is multiplied by a per-token rate that varies by model, then converted into credits.

The two big levers in your bill are:

Which model you're using. A lightweight model might cost a fraction of a credit per chat message. A frontier model (Claude, GPT-4o, etc.) costs significantly more per token.
How many tokens you're consuming. Long context windows, multi-step agent workflows, and code review all eat tokens fast. A quick one-liner question is cheap; asking Copilot to refactor an entire module in agent mode is not.

Remark: Code review is a special case — the model is selected automatically and not disclosed, so you can't predict per-token costs precisely. Code review also consumes GitHub Actions minutes on top of AI credits starting June 1.

Step 1: Understand your baseline before June 1

GitHub has launched a Preview Bill feature on the Billing Overview page. This is your most important tool right now. It translates your actual April/May usage into estimated AI Credits under the new model, so you can see whether your current plan's included allowance covers you — or whether you're going to hit a wall in the first week of June.

Detailed instructions can be found in this previous post: GitHub Copilot Is changing how it bills you - Here's how to check the impact

If your estimated monthly usage under the new model regularly exceeds your plan's included credits, you have three choices: upgrade your plan, set an additional usage budget, or change your usage habits.

Step 2: Set a hard budget

GitHub lets you configure an additional usage budget in US dollars. This is the maximum you're willing to spend above and beyond your plan's included credits. Set it to $0 and overage usage is simply blocked. Set it to $20 and you get up to $20 of extra credits before the tap shuts off.

For organizations and enterprises, you can also set user-level budgets — a per-developer cap. When a user exhausts their individual budget, their Copilot access is halted for the rest of the billing cycle, even if the organization's pooled credits still have capacity. This is a powerful tool for teams with uneven usage patterns (e.g., one developer running heavy agent sessions while others use mostly completions).

Check out the configured budget through Organization Settings -> Billing and Licensing -> Budgets and Alerts:

Here you can see the existing budgets configured and add/change them:

To stop any usage and further spending once the budget limit is reached, select Stop usage when budget limit is reached, if available. If you don't do this, you will be notified when budget is exceeded, but usage is not stopped.

Some guidelines:

Situation	Recommendation
Individual, predictable workflow	Set additional budget to $0 initially. Revisit after Month 1.
Individual, runs agentic sessions	Set $10–$20 buffer. Monitor weekly.
Team with mixed users	Set org-level budget + per-user limits for your heaviest users.
Enterprise with compliance requirements	Disable additional usage entirely. Force users to stay within plan.

My current advice: start with a hard cap at $0 and learn from real usage.

Step 3: Identify your high-cost workflows

Not all Copilot usage is created equal. Here's a rough cost hierarchy to help you prioritize where to look:

Low cost (fractions of a credit per interaction)

Simple chat questions using lightweight models
Short code suggestions and completions (still unlimited/free)
Single-file context operations

Moderate cost (a few credits per interaction)

Chat with large context (open files, workspace indexing)
Multi-turn conversations that carry history
Explain/summarize features on medium-sized code

High cost (potentially 10–50+ credits per session)

Agent mode / multi-step autonomous tasks
Code review on large PRs
Long agentic loops with tool calls and retries
Operations using frontier models (Claude Opus, etc.) on large inputs

The biggest risk area for most developers is agent mode. A single agentic task that hits errors and retries can consume a surprising number of tokens. An error loop that keeps retrying the same failed operation can eat credits with nothing to show for it.

Step 4: Build a monthly budget framework

Here's a simple framework that we are using as our current baseline:

Team budget = (Seats × per-user estimate) + buffer for spikes

Recommended structure:
- Set org-level budget cap
- Identify your top 20% of users (they'll use ~80% of credits)
- Set user-level caps for heavy users specifically
- Leave 20% headroom for unplanned agentic work

Use your Preview Bill CSV as your ground truth for these numbers, not guesswork.

You can configure a budget by:

Clicking on New Budget in Budgets & Alerts:

Select Bundled premium requests budget and click on Next:

Select a budget scope and set a budget amount

Remark: This is the additional budget on top of the default credits

Don't forget to configure alerts and add one or more recipients:

That's it!

Step 5: Monitor and adjust

Budgeting isn't a one-time exercise. In the first few months after June 1, our plan is to:

Check the usage dashboard in GitHub's billing settings weekly for the first two months.

After Month 1, compare actual vs. estimated usage from your preview bill.
Adjust user-level caps based on real data, not assumptions.
Watch for sudden spikes.

The bottom line

Free lunch is over. The move to AI Credits is fundamentally a shift from "how many requests did you make" to "how much compute did you consume." It rewards intentional, efficient use of AI and penalizes long agentic loops, heavy frontier-model usage, and retry storms.

GitHub has given you the tools to manage this proactively. The developers and teams who will feel the most pain on June 1 are the ones who don't look at their usage data before then.

You have a few days. Go check your preview bill.

More information

GitHub Copilot Is changing how it bills you - Here's how to check the impact

Usage-based billing for organizations and enterprises - GitHub Docs

VS Code Planning mode

After the introduction of Plan mode in Visual Studio , it now also found its way into VS Code. Planning mode, or as I like to call it 'Hannibal mode', extends GitHub Copilot's Agent Mode capabilities to handle larger, multi-step coding tasks with a structured approach. Instead of jumping straight into code generation, Planning mode creates a detailed execution plan. If you want more details, have a look at my previous post . Putting plan mode into action VS Code takes a different approach compared to Visual Studio when using plan mode. Instead of a configuration setting that you can activate but have limited control over, planning is available as a separate chat mode/agent: I like this approach better than how Visual Studio does it as you have explicit control when plan mode is activated. Instead of immediately diving into execution, the plan agent creates a plan and asks some follow up questions: You can further edit the plan by clicking on ‘Open in Editor’: ...

The art of simplicity

Search This Blog