Choosing a Copilot Plan: Core AI Credits Billing Concepts

1. How Copilot Billing Works: The AI Credits Model

Every Copilot plan you'll evaluate in this chapter runs on the same billing mechanism, so it's worth understanding before you look at plan names or prices.

Effective 2026-06-01, GitHub moved all Copilot plans from the old flat-quota "premium request" system to usage-based GitHub AI Credits. Under the current model, 1 AI Credit = $0.01 USD, and the number of credits a request consumes is calculated from the tokens it actually processes — input tokens, output tokens, and cached tokens — at each model's published per-token rate. A longer, more complex chat exchange against a larger model costs more credits than a short one against a smaller model; there's no flat "one request, one charge" pricing anymore. (Chapter 7 is an optional lookup chapter you can consult when needed rather than read in sequence — it covers the retired premium-request system and its historical per-plan quotas in full if you want the legacy detail; this chapter only needs the 2026-06-01 cutover as context for why AI Credits is the current model. Chapter 7 also owns the full per-model credit-rate table — individual model rates aren't listed here.)

Two everyday activities are explicitly carved out of this metering and remain unlimited on paid plans: code completions and Next Edit suggestions. You can accept as many inline suggestions as your workflow generates without touching your AI Credit balance — only the more deliberate, interactive surfaces (chat, CLI, agents, and similar) draw on credits, as Section 4 covers in detail.

2. The Current Copilot Plan Lineup

As of August 2026, GitHub offers seven current Copilot plans:

• Free
• Student — free for verified students
• Pro — $10/month
• Pro+ — $39/month
• Max — $100/month
• Business — $19/seat/month
• Enterprise — $39/seat/month

These are the names and prices to recognize going forward; Section 3 adds each paid tier's monthly AI Credit allowance on top of this list.

If you've seen older Copilot pricing material, note that it's changed: the plan lineup and pricing have both shifted since earlier sources. Treat any pricing you've encountered elsewhere as potentially stale, and use the figures above as the current baseline — Chapter 7 keeps a fuller historical comparison if you want to see exactly what changed.

Free and Student both exist as no-cost entry points, but each carries its own plan-specific nuances that go beyond this chapter's scope — Chapter 7 covers those in depth. Here, it's enough to know both tiers exist and are free.

3. Monthly AI Credit Allowances by Plan

As of August 2026, each paid Copilot tier publishes a monthly AI Credit allowance:

Notice that Business and Enterprise allowances are stated per user, per month — a 10-seat Business team's allowances total 19,000 credits/month, not 1,900 total. This course's evidence does not establish whether those credits are pooled across seats or used strictly per seat.

Free's allowance is different in kind, not just in size. Current GitHub documentation does not publish a specific number for Free — it states only an unquantified, limited AI Credit allowance. Don't try to estimate or back into a number by comparing it to the paid tiers above; none exists in current documentation to estimate from. If you want the fuller history of what was previously documented for Free, that's Chapter 7's territory, not this section's.

Per-model credit rates — exactly how many credits a specific model consumes per token — aren't covered here either; look those up in Chapter 7 when you need them.

4. What Consumes AI Credits

Beyond the mechanism itself, it helps to know which everyday tools actually draw on your AI Credit balance. Per current GitHub documentation, the following features consume AI Credits:

• Copilot Chat
• Copilot CLI
• Copilot cloud agent
• Copilot Spaces
• Spark
• Third-party coding agents

Treat this as the currently documented list rather than a guaranteed-complete inventory — GitHub's documentation on this point is spread across multiple pages, and this list hasn't been independently re-verified against every one of them for exhaustiveness. If you use a feature that isn't named here, don't assume it's automatically free; check current billing documentation directly.

Note that the Copilot cloud agent appears on this list purely as a credit-consuming feature. Whether a specific plan is actually eligible to use the cloud agent, and how its billing works in detail, is a separate question this chapter doesn't answer — Chapter 3 determines cloud-agent eligibility and billing per plan. Here, just file away that cloud-agent usage is one more thing that draws on your AI Credits.

5. Choosing a Plan for the Reference Project

You now have what you need to make a billing-informed plan choice: how AI Credits work (Section 1), the current plan lineup (Section 2), each plan's allowance (Section 3), and what actually consumes credits (Section 4).

Recall from Chapter 1 that you set up a shared reference project and made your first small Copilot-assisted change to it using completions and chat. That project doesn't yet have a team-size/workflow scenario or a chosen Copilot plan attached to it — Activity 3 below closes both gaps: you'll first state a small team-size and workflow scenario for the project, then use it to pick a plan, using only what this chapter has taught you. Activity 3 also has you record two distinct things — a provisional plan recommendation for that hypothetical team, and separately, which Copilot plan your own account is actually on right now — and the second of those is read again later, so keep it accurate rather than treating it as a passing aside.

Any recommendation you make here is necessarily provisional. This chapter only teaches billing mechanics — plan names, prices, allowances, and what consumes credits. It does not teach which plans are actually eligible for specific credit-consuming features like the cloud agent, and it does not teach which plans include Copilot code review; those determinations belong to Chapter 3 and Chapter 4, later in the course. So when you justify a plan choice, base it strictly on price, AI Credit allowance, your reference project's team size, and its expected mix of credit-consuming activity — never on a claim that a plan is confirmed to support any particular feature.

Three things are deliberately out of scope here and get a pointer rather than an answer: legacy premium-request mechanics, exact per-model credit rates, and Free/Student numeric nuances all live in Chapter 7's reference material, not in this section. And two plan-eligibility questions are validated later rather than here: cloud-agent eligibility for whatever plan you choose is determined in Chapter 3, and Copilot code review's own plan eligibility is determined in Chapter 4.

Activity 1: Trace a Week of Copilot Usage Through the AI Credits Model

Goal: Practice telling billed activities apart from unbilled ones under the current AI Credits model.

Below is a short list of everyday Copilot activities:

1. Accepting an inline code completion
2. Accepting a Next Edit suggestion
3. Asking Copilot Chat a question
4. Running a Copilot CLI command

Steps:

1. Mark each activity as billed via AI Credits or not billed.
2. For every activity you mark billed, write one sentence describing what's actually being measured — token consumption at the model's published rate, not a flat per-use charge.
3. For every activity you mark not billed, name the specific reason it's excluded.

Expected outputs:

• A completed classification list marking each given activity as billed or not billed.
• One sentence per billed activity explaining the token-based basis for its cost.
• One sentence per unbilled activity citing the reason it is excluded from AI Credit consumption.

Hints:

• Code completions and Next Edit suggestions are the two activities explicitly excluded from AI Credit consumption and remain unlimited on paid plans.
• Billed activities are metered by input, output, and cached tokens processed at a model's published per-token rate — not a flat per-interaction charge.
• Don't describe a billed activity's cost using the old premium-request framing; that model no longer applies.

Checkpoint: Completions and Next Edit suggestions should both be marked not billed. At least one interactive activity (e.g., Copilot Chat) should be marked billed, with your explanation referencing token consumption at a per-token rate rather than a flat per-request charge.

This exercise builds the token-based billing mental model you'll draw on when justifying your reference-project plan recommendation in Activity 3 — it doesn't modify the reference project itself.

Activity 2: Build the Current Plan/Allowance Reference Table

Goal: Consolidate the plan lineup and per-plan AI Credit allowances into one reference table you can use for plan selection.

Steps:

1. Create a table listing all seven current plans — Free, Student, Pro, Pro+, Max, Business, Enterprise — with each plan's published monthly price.
2. Add a column for each plan's published monthly AI Credit allowance, where one exists.
3. For the Free plan's allowance cell, write unquantified/limited per current documentation — no number.

Expected outputs:

• A plan/price/allowance table covering all seven current tiers.
• A Free-plan allowance cell that contains no numeric figure, only the unquantified/limited framing.

Hints:

• Pro, Pro+, Max, Business, and Enterprise each have a published numeric monthly AI Credit allowance; Free and Student do not.
• Don't infer, estimate, or average a number for Free's allowance from the other plans' figures — current GitHub documentation doesn't publish one, and inventing one isn't allowed here.
• Business and Enterprise allowances are stated per user per month; Pro, Pro+ and Max state one monthly total for the individual subscriber.

Checkpoint: All seven current plan names should appear in your table. Your Free row should contain no invented number, only the unquantified/limited framing. Your paid-tier prices and allowances should exactly match: Pro $10/mo, 1,500 credits; Pro+ $39/mo, 7,000 credits; Max $100/mo, 20,000 credits; Business $19/seat/mo, 1,900 credits per user; Enterprise $39/seat/mo, 3,900 credits per user.

You'll consult this table directly in Activity 3 to justify a plan recommendation for the reference project; it doesn't modify the reference project on its own.

Activity 3: Select and Justify a Provisional Copilot Plan for the Reference Project Team

Goal: Turn this chapter's billing concepts into a concrete, provisional plan recommendation for your reference project.

Steps:

1. Define a small team-size and workflow scenario for your reference project. Chapter 1 set up the reference project itself and made a first small Copilot-assisted change to it, but it did not specify who uses the project or how. State that now, in two or three sentences: how many engineers are on the team, and a brief sketch of their expected credit-consuming activity mix (e.g., how often they'd use chat, CLI, cloud agent, Spaces, Spark, or third-party coding agents — see Section 4). Keep this scenario deliberately small; it exists only to give you enough to weigh price, team size, expected usage, and allowance against each other in the steps below.
2. Using the scenario you just defined and the plan/allowance table you built in Activity 2, select one current Copilot plan as a provisional, billing-based recommendation.
3. Write a short justification (a few sentences) that references: your scenario's team size, its expected mix of credit-consuming activity, and the chosen plan's published AI Credit allowance. Base this only on price, allowance, team size, and expected usage volume — do not claim or imply that your chosen plan is confirmed eligible for any specific credit-consuming feature.
4. Add one explicit sentence recording any workflow or capability assumption behind your recommendation that's still unverified — specifically, that plan-based eligibility for features like the cloud agent and Copilot code review hasn't been taught yet (cloud-agent eligibility is covered in Chapter 3, and Copilot code review's own plan eligibility is covered in Chapter 4) and must be validated before your recommendation can be treated as final.
5. Add one explicit sentence naming at least one billing nuance you're deliberately not resolving here because it belongs to Chapter 7's reference material, not to this section — for example, exact per-model credit rates, or Free/Student numeric nuances.
6. Separately from the provisional recommendation above, record which Copilot plan your own account is actually on right now, and note in one line whether it matches or differs from your provisional recommendation.

Expected outputs:

• A short, chapter-defined team-size and workflow scenario for the reference project, stated at the start of this activity.
• A plan recommendation, explicitly labeled provisional, naming one of the seven current plans.
• A justification tying the decision to at least two of team size, expected credit-consuming usage, and published allowance — with no claim of confirmed feature eligibility.
• One sentence naming Chapter 3 and Chapter 4 as where the unverified workflow/capability assumptions — cloud-agent eligibility and Copilot code review's own plan eligibility — get validated.
• One sentence naming Chapter 7 as where a specific deferred billing nuance is covered.
• One line recording the Copilot plan your account is actually on and whether it matches or differs from your provisional recommendation.

Hints:

• There's no single "correct" plan or "correct" scenario. Your team-size/workflow scenario just needs to be small, concrete, and internally consistent enough to support a coherent justification.
• If your scenario involves agentic or cloud-agent work, you can name that expected usage as a factor and weigh allowance headroom and per-seat/per-user framing accordingly — but don't state or imply that any plan is confirmed eligible for cloud-agent or other agentic workflows. Eligibility is determined later, in Chapter 3.
• The deferred-nuance sentence and the unverified-assumption sentence are boundary markers naming Chapter 7 and Chapters 3 and 4, respectively — not an invitation to explain any topic in depth.

Checkpoint: Your write-up should name one of the seven current plans as your provisional recommendation, with a justification tying the decision to at least two of team size, expected credit-consuming usage, and published allowance, and no claim of confirmed feature eligibility. It should contain no invented Free AI-Credit number, per-model rate figure, or premium-request framing anywhere in the text. It should include one sentence naming Chapter 3 and Chapter 4 as where the unverified workflow/capability assumptions get validated, one sentence naming Chapter 7 as where a deferred billing nuance is covered, and one line recording your account's actual Copilot plan and whether it matches or differs from your provisional recommendation.

This produces your reference project's documented, provisional plan recommendation, its justification, and your recorded workflow/capability assumptions. The live Copilot plan record from Step 6 is what Chapter 3's cloud-agent eligibility check reads as its input; the workflow/capability assumptions you recorded in Step 4 are what Chapter 3's and Chapter 4's eligibility teaching validates; and the provisional recommendation itself is what later course synthesis briefly recaps and contrasts against your live plan when explaining which surfaces were available for the end-to-end exercise.

Reference Project Continuity — Chapter 2

Starting state: The reference project exists with the initial Copilot-assisted change made in Chapter 1 (via completions and chat), but has no team-size/workflow scenario and no chosen or documented Copilot plan yet.

This chapter's contribution: Activity 1 builds the token-based billing mental model from Section 1. Activity 2 consolidates the current plan lineup (Section 2) and allowances (Section 3) into a single reference table. Activity 3 first states a small team-size and workflow scenario for the reference project as an explicit input created within this chapter (not attributed to Chapter 1), then uses that scenario together with the Activity 2 table and Section 4's credit-consuming feature list to produce a concrete, provisional Copilot plan recommendation, along with an explicitly recorded workflow/capability assumption still pending validation and a named billing nuance deferred to Chapter 7.

Ending state: The reference project has a small, chapter-defined team-size and workflow scenario, a documented, provisional Copilot plan recommendation reflecting that scenario, and a separately recorded live Copilot plan, all produced in Activity 3, together with recorded workflow/capability assumptions still pending validation. The live plan record is ready for Chapter 3's cloud-agent eligibility check to read as its input; the workflow/capability assumptions are ready for Chapter 3's and Chapter 4's eligibility teaching to validate; and the provisional recommendation is ready for the eventual capstone's brief recap and contrast against the live plan.

Sources

• https://github.blog/news-insights/company-news/github-copilot-is-moving-to-usage-based-billing/
• https://docs.github.com/en/billing/concepts/product-billing/github-copilot-billing
• https://docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing
• https://docs.github.com/en/copilot/get-started/plans