# Github Copilot

> Use when deciding whether to spend GitHub Copilot's metered budget on a task (its premium-request / post-June-2026 AI-credit model, where 1 credit = $0.01 and cost = tokens × per-model rate), what Copilot is good at vs expensive at, which plan allowance (Pro 300 / Pro+ 1500, no rollover) applies, and when a cheaper or free lane should take the work instead. Covers the June 1 2026 shift from premium-request multipliers to usage-based token billing, the always-free completions/next-edit surface, and the IDE-native frontier-model lane. Do NOT use for choosing or operating the OpenCode runtime (use `opencode`), for picking a specific free model (use `opencode-free-models`), or for authoring an agent loop (use `autonomous-loop-patterns`).

- Skill: `jacob-balslev/github-copilot-2` (Agent Skill, multi-file: 5 files)
- Install (CLI): `npx skillmds@latest add jacob-balslev/github-copilot-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/jacob-balslev/github-copilot-2/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- License: MIT
- Author: jacob-balslev (https://skillmd.com/u/jacob-balslev)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/jacob-balslev/github-copilot-2

---


# GitHub Copilot

## Concept of the skill

**What it is:** A routing-and-cost discipline for GitHub Copilot — knowing when its metered budget is worth spending on a task, how its billing works (premium requests with per-model multipliers, replaced June 1 2026 by usage-based AI credits at 1 credit = $0.01), what surfaces are always free, and when a cheaper or free lane should take the work instead.

**Mental model:** Copilot has two cost surfaces glued together: an *always-free* completions/next-edit surface (unmetered) and a *metered* chat/agent surface (premium requests → AI credits). Routing well means keeping low-complexity and high-volume work off the metered surface and reserving the finite, non-rolling metered allowance for work that genuinely benefits from an IDE-native frontier model.

**Why it exists:** The metered allowance is finite and expires each cycle (no rollover), and agent-like flows burn it fastest — so spending it on boilerplate or work a free lane handles is pure waste. A deliberate routing rule prevents that waste while still using Copilot where its IDE-native flow earns the spend.

**What it is NOT:** It is not a model and not a runtime — it is a metered access lane to frontier models inside the IDE. It is not "unlimited because I pay a subscription": the subscription buys completions plus a capped metered allowance, not unlimited agent flows.

**Adjacent concepts:** the metered allowance (the finite budget); the always-free completion surface; the per-model token rate that converts usage to credits; the cheaper/free lane that should absorb low-complexity work.

**One-line analogy:** Copilot is a prepaid toll lane bundled with a free service road — the service road (completions) is unlimited, the toll lane (agent/chat credits) is fast but metered and the balance does not roll over, so you only take the toll lane when the trip is worth it.

**Common misconception:** That "I pay for Copilot, so using it is free/unlimited," or that the old per-model multipliers still govern cost. Neither holds post-June-1-2026: cost is token-based (input + output + cached × per-model rate → credits), the allowance is finite and non-rolling, and agent flows consume it fastest.

## Coverage

- Copilot's two cost surfaces: the always-free completions/next-edit surface vs the metered chat/agent surface
- The current billing model (post-June-1-2026): GitHub AI Credits at 1 credit = $0.01, token-based cost, and what it replaced (legacy premium-request multipliers)
- Plan allowances (Pro ~300, Pro+ ~1500, Business/Enterprise per-seat) and the no-rollover rule
- The routing decision: which work earns metered Copilot spend vs which should go to a free/cheap lane or a script
- What Copilot is good at (IDE-native completions, frontier-model chat) vs expensive at (agentic multi-file flows)
- The models reachable through Copilot and that they bill at published per-token rates

## Philosophy of the skill

Copilot's metered allowance is a finite, non-rolling budget, and the single most expensive mistake is treating it as unlimited because a subscription was paid. The always-free completion surface is its strongest, cheapest value and needs no budgeting; the metered surface is where discipline matters. The rule is to spend metered budget only where an IDE-native frontier model genuinely earns it — context the IDE already has, work that benefits from the in-editor flow — and to push boilerplate, repetitive transformations, and high-volume mechanical work to a free lane or a script. Spending metered budget on low-complexity work is not a small inefficiency; with no rollover, every wasted request is gone at cycle end, and agent flows burn the allowance fastest of all.

## The routing decision

Spend metered Copilot budget only where an IDE-native frontier model earns it. Push everything else to a free surface or a cheaper lane.

| Work type | Route to | Why |
|---|---|---|
| Inline code completion, next-edit suggestions | Copilot (always-free surface) | Unmetered; not billed in AI credits — its cheapest, strongest surface |
| Genuine IDE-native frontier chat/refactor that needs context the IDE already has | Copilot metered surface | This is what the premium allowance is for |
| Boilerplate, formatting, small edits, repetitive transformations | Free/cheap lane (a script, or a free model) | Wastes finite metered budget on a low bar |
| Bulk classification / triage / high-volume mechanical work | Free model lane (see `opencode-free-models`) | Volume × premium credits is the fastest way to burn the allowance |
| Anything a deterministic script can do | No model at all | Don't meter what code can do for free |

## Cost model and plan allowances

| Fact | Value (2026) |
|---|---|
| Billing unit (post-June-1-2026) | GitHub AI Credits; **1 credit = $0.01 USD** |
| Cost formula | (input + output + cached tokens) × per-model rate → credits |
| Legacy (pre-June-1-2026) | Premium requests with per-model **multipliers** (e.g. premium model 1×, Copilot code review 13×) |
| Always free | Code completions + next-edit suggestions (not credit-billed) |
| Rollover | None — unused allowance expires each billing cycle |
| Pro | $10/mo, ~300 premium-requests-equivalent allowance/month |
| Pro+ | $39/mo, ~1500 allowance/month (≈5× Pro) |
| Business / Enterprise | $19/seat (300/user) / $39/seat (1000/user) |

Models reachable through Copilot include OpenAI (GPT-5 mini through GPT-5.5 tiers), Anthropic (Claude Haiku 4.5 → Opus 4.8), Google (Gemini 3 Flash / 3.1 Pro / 3.5 Flash), and Microsoft fine-tuned models — billed at their published per-token rates.

## Strengths and weaknesses

**Strengths:** best-in-class, unmetered inline completions and next-edit suggestions; deep IDE integration (VS Code, JetBrains); frontier-model chat without separate vendor accounts.

**Weaknesses:** agent-like flows (multi-file edits, complex refactors, agentic loops) burn the metered allowance fast and surprise teams; no rollover means an oversized plan still wastes budget at cycle end; sticker-price comparisons hide real per-token cost; the metered surface is rarely the cheapest place to run mechanical or high-volume work.

## Verification

Use this checklist to confirm a Copilot spend decision was made correctly.

- [ ] The work was classified as always-free surface (completions/next-edit), metered surface, or route-off-Copilot before spending
- [ ] Metered Copilot budget is spent only where an IDE-native frontier model genuinely earns it
- [ ] Boilerplate, repetitive transformations, and high-volume mechanical work were routed to a free/cheap lane or a script, not the metered surface
- [ ] Cost reasoning uses the current model (AI credits at 1 credit = $0.01, token-based), not the retired premium-request multipliers — unless the account is explicitly on legacy annual billing
- [ ] The finite, non-rolling nature of the allowance was accounted for (an oversized plan does not prevent end-of-cycle waste)
- [ ] No assumption that a paid subscription makes metered agent flows free

## Do NOT Use When

| Instead of `github-copilot` | Use | Why |
|---|---|---|
| Choosing or operating the OpenCode runtime | `opencode` | That is an open-source multi-provider runtime, not Copilot's metered IDE lane |
| Picking which free/cheap model fits a task | `opencode-free-models` | This skill owns Copilot's paid economics; that one owns free-model selection |
| Authoring the agent loop / retry / claim logic | `autonomous-loop-patterns` | Loop authoring is separate from where you meter the model |
| The work is unmetered Copilot completion usage | Just use it | The always-free surface needs no budgeting decision |

## References

- `references/model-facts.md` — current (2026-06-08) Copilot billing model, plan allowances, model list, and the June-1 usage-based shift with sources.