github-copilot

---
name: github-copilot
description: "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`). Do NOT use for how do I invoke the opencode CLI non-interactively? Do NOT use for which free model fits this bulk job? Do NOT use for how do I write the agent's retry loop?"
license: MIT
compatibility: "Markdown, any agent runtime; billing facts current as of 2026-06 (post June-1 usage-based shift)"
allowed-tools: Read
metadata:
  subject: agent-ops
  subjects: "[\"agent-ops\",\"ai-engineering\"]"
  public: "true"
  scope: "When to route work to GitHub Copilot and when not to: its metered cost model (premium requests pre-June-2026 with per-model multipliers; AI credits at 1 credit = $0.01 with token-based billing after the June 1 2026 shift), plan allowances and the no-rollover rule, the always-free completions/next-edit surface, what Copilot is good at (IDE-native completions + frontier-model chat) vs expensive at (agentic multi-file flows), and when a cheaper/free lane is preferable. Portable knowledge about a public product's published billing — no private budget config. Out: the OpenCode runtime (opencode), specific free-model choice (opencode-free-models), agent-loop authoring (autonomous-loop-patterns)."
  taxonomy_domain: agent/harness
  stability: experimental
  keywords: "[\"github copilot\",\"copilot premium requests\",\"copilot ai credits\",\"copilot usage-based billing\",\"copilot pro vs pro plus\",\"when to use copilot\",\"copilot premium request cost\",\"copilot model multipliers\",\"cheaper lane than copilot\"]"
  examples: "[\"is this task worth spending a Copilot premium request on?\",\"how does Copilot's AI-credit billing work after June 2026?\",\"should I run this agent flow on Copilot or a free lane?\"]"
  anti_examples: "[\"how do I invoke the opencode CLI non-interactively?\",\"which free model fits this bulk job?\",\"how do I write the agent's retry loop?\"]"
  grounding: "{\"subject_matter\":\"GitHub Copilot model roster, billing, and plan allowance facts\",\"grounding_mode\":\"hybrid\",\"truth_sources\":[\"skills/agent-ops/github-copilot/references/model-facts.md\"],\"failure_modes\":[\"stale_model_id\",\"stale_context_window\",\"stale_pricing_or_rate_limit\",\"benchmark_claim_without_date\",\"capability_claim_quoted_from_memory\"],\"evidence_priority\":\"repo_code_first\"}"
  relations: "{\"related\":[\"opencode\",\"opencode-free-models\",\"autonomous-loop-patterns\",\"ai-native-development\"],\"suppresses\":[{\"skill\":\"opencode-free-models\",\"reason\":\"I own Copilot's paid premium-request / AI-credit lane and when to avoid it; opencode-free-models owns the free open-weight model alternatives\"},{\"skill\":\"opencode\",\"reason\":\"I own Copilot's IDE-native economics; opencode owns the open-source multi-provider runtime\"}],\"verify_with\":[\"opencode-free-models\"]}"
  mental_model: "A metered AI coding assistant has two glued-together cost surfaces: an always-free completion/next-edit surface that is unmetered, and a metered chat/agent surface drawn from a finite, non-rolling allowance. Routing well means keeping low-complexity and high-volume work off the metered surface and spending the capped allowance only where an in-editor frontier model genuinely earns it."
  purpose: "Prevent waste of a finite, non-rolling metered budget by deciding, per task, whether the work belongs on the free completion surface, on the metered surface, or off the assistant entirely on a cheaper/free lane or a script."
  concept_boundary: "Owns the spend/route decision for a metered IDE coding assistant's published billing. Does NOT own choosing or operating an open-source multi-provider runtime, picking a specific free model, or authoring an agent loop — those are separate concepts."
  analogy: "It 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."
  misconception: "That paying a subscription makes the assistant free or unlimited. The subscription buys unmetered completions plus a capped, non-rolling metered allowance — agent flows consume that allowance fastest, and cost is token-based at a per-model rate, not governed by the retired flat per-request multipliers."
  skill_graph_source_repo: "https://github.com/jacob-balslev/skill-graph"
  skill_graph_project: Skill Graph
  skill_graph_canonical_skill: skills/agent-ops/github-copilot/SKILL.md
  skill_graph_export_description_projection: anti_examples
---

# 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.

## Skill Graph context

<!-- skill-graph-context:start (generated — do not edit by hand) -->

**Classification**
- Subject: `agent-ops` (also: `ai-engineering`)
- Public: `true`
- Domain: `agent/harness`
- Scope: When to route work to GitHub Copilot and when not to: its metered cost model (premium requests pre-June-2026 with per-model multipliers; AI credits at 1 credit = $0.01 with token-based billing after the June 1 2026 shift), plan allowances and the no-rollover rule, the always-free completions/next-edit surface, what Copilot is good at (IDE-native completions + frontier-model chat) vs expensive at (agentic multi-file flows), and when a cheaper/free lane is preferable. Portable knowledge about a public product's published billing — no private budget config. Out: the OpenCode runtime (opencode), specific free-model choice (opencode-free-models), agent-loop authoring (autonomous-loop-patterns).

**When to use**
- is this task worth spending a Copilot premium request on?
- how does Copilot's AI-credit billing work after June 2026?
- should I run this agent flow on Copilot or a free lane?

**Not for**
- how do I invoke the opencode CLI non-interactively?
- which free model fits this bulk job?
- how do I write the agent's retry loop?
- Owned by `opencode-free-models`
- Owned by `opencode`

**Related skills**
- Verify with: `opencode-free-models`
- Related: `opencode`, `opencode-free-models`, `autonomous-loop-patterns`, `ai-native-development`

**Concept**
- Mental model: A metered AI coding assistant has two glued-together cost surfaces: an always-free completion/next-edit surface that is unmetered, and a metered chat/agent surface drawn from a finite, non-rolling allowance. Routing well means keeping low-complexity and high-volume work off the metered surface and spending the capped allowance only where an in-editor frontier model genuinely earns it.
- Purpose: Prevent waste of a finite, non-rolling metered budget by deciding, per task, whether the work belongs on the free completion surface, on the metered surface, or off the assistant entirely on a cheaper/free lane or a script.
- Boundary: Owns the spend/route decision for a metered IDE coding assistant's published billing. Does NOT own choosing or operating an open-source multi-provider runtime, picking a specific free model, or authoring an agent loop — those are separate concepts.
- Analogy: It 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 paying a subscription makes the assistant free or unlimited. The subscription buys unmetered completions plus a capped, non-rolling metered allowance — agent flows consume that allowance fastest, and cost is token-based at a per-model rate, not governed by the retired flat per-request multipliers.

**Grounding**
- Mode: `hybrid`
- Truth sources: `skills/agent-ops/github-copilot/references/model-facts.md`

**Keywords**
- `github copilot`, `copilot premium requests`, `copilot ai credits`, `copilot usage-based billing`, `copilot pro vs pro plus`, `when to use copilot`, `copilot premium request cost`, `copilot model multipliers`, `cheaper lane than copilot`

<!-- skill-graph-context:end -->