01 GitHub Copilot Now Has Six Pricing Tiers — And Most Developers Are on the Wrong One
GitHub Copilot's pricing has become genuinely confusing. What started as a simple $10/month subscription now spans six tiers: Free, Student, Pro, Pro+, Business, and Enterprise. Each tier has different code completion limits, different premium request allocations, different model access, and different feature gates. The difference between being on Pro ($10/month) and Pro+ ($39/month) is not just price — it is access to entirely different AI models and nearly five times the premium request budget.
Most developers pick a tier based on the price column and never check whether they are actually using the features their tier includes — or hitting limits their tier imposes. This article breaks down exactly what each tier gives you, what "premium requests" actually cost, which models you can access where, and when the new coding agent makes the higher tiers worth the premium.
The stakes are real. A 50-developer team on GitHub Enterprise plus Copilot Enterprise pays approximately $3,000 per month — just for GitHub and Copilot. That number justifies careful examination of what you are actually getting.
"GitHub Pro + Copilot Pro = $14/month. GitHub Enterprise + Copilot Enterprise = $60/user/month. A 50-developer team pays $3,000 monthly just for GitHub and Copilot." — UserJot pricing analysis
02 The Complete 6-Tier Breakdown — Every Number That Matters
Here is the full comparison as of March 2026, sourced directly from GitHub's official documentation:
| Feature | Free $0/mo |
Student $0/mo |
Pro $10/mo |
Pro+ $39/mo |
Business $19/user/mo |
Enterprise $39/user/mo |
|---|---|---|---|---|---|---|
| Code Completions | 2,000/mo | Unlimited | Unlimited | Unlimited | Unlimited | Unlimited |
| Premium Requests | 50/mo | 300/mo | 300/mo | 1,500/mo | 300/user/mo | 1,000/user/mo |
| Chat Messages | 50/mo | Unlimited | Unlimited | Unlimited | Unlimited | Unlimited |
| Coding Agent | ✗ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Agent Mode | ✗ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Models | Haiku 4.5, GPT-4.1 | = Pro | Sonnet 4.5/4.6, Gemini 2.5 Pro, GPT-5 mini/5.1 | All Pro + Opus 4.5/4.6, GPT-5.2/5.4, Codex, Grok | = Pro | All premium models |
| Extra Requests | ✗ | ✗ | $0.04/ea | $0.04/ea | $0.04/ea | $0.04/ea |
| Org Management | ✗ | ✗ | ✗ | ✗ | ✓ | ✓ |
| IP Indemnity | ✗ | ✗ | ✗ | ✗ | ✓ | ✓ |
| SAML SSO / Advanced Security | ✗ | ✗ | ✗ | ✗ | ✗ | ✓ |
Free exists for evaluation — it lets you see what Copilot feels like, but the 50-message cap means you will hit the wall within a day or two of serious use.
Student is identical to Pro in functionality — same model access, same coding agent, same agent mode. The only difference is you do not pay. Verification is through GitHub's existing student developer pack.
Pro is the sweet spot for individual developers who write code daily but do not need the heaviest models.
Pro+ exists for power users who burn through 300 requests in a few days and want access to the most capable models. The jump from 300 to 1,500 premium requests is the primary value proposition.
Business is the tier for companies that need compliance and administration, not necessarily more powerful AI.
Enterprise is the same price as Pro+ for individuals, but you get 1,000 requests instead of 1,500, traded for enterprise compliance features including SAML SSO enforcement and advanced security.
The pattern that catches most developers off guard: regular code completions do NOT consume premium requests (except on the Free tier, where completions are capped at 2,000/month). Premium requests are consumed by Copilot Chat conversations, agent mode sessions, pull request summaries, code review suggestions, and usage of non-default AI models. If you primarily use Copilot for inline tab completions and rarely use Chat, the Pro tier's 300 premium requests may never run out.
There is a nuance in the Student tier that most guides miss: students get 300 premium requests per month — the same as Pro — plus unlimited completions and full access to the coding agent and agent mode. The Student tier is not a limited "educational" version. It is functionally identical to the $10/month Pro plan. Combined with GitHub's Student Developer Pack (which includes GitHub Pro for free), a verified student gets GitHub Pro + Copilot Pro for $0/month versus $14/month for a non-student. Over a 4-year degree, that is $672 in savings — and the habit formation is exactly what GitHub is counting on.
The model availability gap between tiers deserves emphasis. On the Free tier, you get Claude Haiku 4.5 and GPT-4.1. These are capable models, but they are the "economy" options. Pro adds Claude Sonnet 4.5/4.6, Gemini 2.5 Pro, GPT-5 mini, and GPT-5.1 — a significant step up in reasoning, code generation quality, and context understanding. Pro+ and Enterprise unlock the flagship models: Claude Opus 4.5/4.6, GPT-5.2, GPT-5.4, all Codex models, and Grok Code Fast 1. The difference between GPT-4.1 on Free and GPT-5.4 on Pro+ is not incremental — it is generational. If you are evaluating Copilot on the Free tier and finding it underwhelming, the model access might be the bottleneck, not the tool itself.
03 What Actually Burns Through Premium Requests — And How to Stretch Them
The "premium request" system is where Copilot's pricing gets nuanced. Not all interactions cost the same. A simple inline code completion is free (on paid tiers). But once you start using Chat, Agent Mode, or the coding agent, every interaction consumes premium requests — and the rate depends on which model you are using.
Activities that consume premium requests:
Copilot Chat conversations — Every message you send in the chat panel uses a premium request. Long conversations with many back-and-forth turns burn through them quickly.
Agent mode for autonomous coding — Each step the agent takes in a multi-step coding task counts. A single "implement this feature" prompt might trigger 5-15 premium requests as the agent reads files, writes code, runs terminal commands, and iterates on errors.
Pull request summaries — Asking Copilot to summarize a PR uses premium requests.
Code review suggestions — Automated code review on PRs consumes them.
Non-default model usage — If you switch from the default model to a premium model (like Claude Opus on Pro+), the request may consume more from your allocation.
What does NOT consume premium requests (on paid tiers): inline code completions (tab completions), which is the feature most developers use most frequently. This is an important distinction — if your primary Copilot workflow is writing code and accepting tab suggestions, you can stay on the Pro tier comfortably.
When you exceed your allocation, you can buy extra requests at $0.04 each across all paid tiers. That sounds cheap until you do the math: 500 extra requests in a heavy month costs $20 — doubling the Pro tier's price. If you consistently exceed 300 requests, the Pro+ tier at $39/month with 1,500 requests is more economical once you cross roughly 675 monthly requests ($10 base + $0.04 x 375 overage = $25, versus $39 flat for 1,500).
04 The Coding Agent That Creates PRs While You Sleep — What It Can and Cannot Do
The most significant Copilot feature addition in 2025-2026 is the coding agent — an autonomous AI that works in the background like a human developer. It creates branches, writes code, commits, and opens pull requests. You assign it a task and come back later to review the PR.
"With Copilot coding agent, GitHub Copilot can work independently in the background to complete tasks, just like a human developer." — GitHub official documentation
You can trigger it from three places: GitHub Issues (assign an issue to Copilot or mention it in the issue body), VS Code (via the agents panel), or any GitHub page (agents panel is available site-wide).
What the agent automates: branch creation, code changes, commit message writing, pushing to remote, opening PRs, and writing PR descriptions. The entire git workflow that a junior developer would follow — create branch, make changes, commit, push, open PR — the agent handles end to end.
What it handles well: fixing bugs with clear reproduction steps, implementing incremental new features on well-structured codebases, improving test coverage for existing functions, updating documentation to match code changes, and addressing straightforward technical debt (renaming, extracting functions, updating deprecated API calls).
What it does not handle well: large architectural changes, ambiguous requirements, tasks that need human judgment about UX tradeoffs, and anything requiring domain knowledge that is not in the codebase.
GitHub has been iterating on this agent rapidly. In just one week in March 2026, the changelog shows:
March 17: "Copilot coding agent works faster with semantic code search" — the agent can now search your codebase semantically, not just by filename.
March 18: "Configure Copilot coding agent's validation tools" — you can now specify which linters, test suites, and validation steps the agent should run before opening a PR.
March 19: "Copilot coding agent now starts work 50% faster" — cold start time cut in half.
March 20: "Trace any Copilot coding agent commit to its session logs" — full auditability of what the agent did and why.
The coding agent evolved from the earlier Copilot Workspace, which had a more linear, structured flow and was not deeply integrated into GitHub's experience. The new agent is a fundamentally different product.
Availability: the coding agent requires Copilot Pro, Pro+, Business, or Enterprise. The Free tier does not include it. The Student tier does.
One practical consideration: the coding agent works best with well-structured repositories that have existing test suites. When the agent can run tests to validate its own changes, the success rate increases dramatically. If your repository has no tests, the agent has no way to verify that its changes work — it is essentially writing code blind and hoping the PR reviewer catches issues. Investing in test coverage is not just good engineering practice; it directly improves the quality of AI-generated code in your repository.
The March 18 update — "Configure Copilot coding agent's validation tools" — is particularly significant. You can now specify which linters (ESLint, Pylint, Rubocop), formatters (Prettier, Black), type checkers (TypeScript, mypy), and test suites (Jest, pytest, RSpec) the agent should run before opening a PR. This turns the agent from "write code and hope" into "write code, validate against the same standards humans use, and only open a PR when everything passes." If your team has a CI pipeline, configuring the agent to run the same checks locally before creating the PR dramatically reduces review cycles.
05 .github/copilot-instructions.md — The File That Makes Copilot Actually Understand Your Codebase
Most Copilot users do not know this file exists. Create .github/copilot-instructions.md in your repository root, and Copilot will read it as context for every interaction in that repository. It is the Copilot equivalent of Cursor's .cursor/rules/ or Claude Code's CLAUDE.md — and it is dramatically underused.
Here is a real-world example of what belongs in this file:
"Repository custom instructions let you provide Copilot with repository-specific guidance and preferences." — GitHub official documentation
This file transforms Copilot from a generic code generator into one that understands your project's conventions. Without it, Copilot might suggest console.log for debugging in a codebase that uses a structured logger. It might generate class components in a functional-components-only React project. It might use Jest patterns when your test runner is Vitest.
Beyond the repository-level file, Copilot supports three additional instruction layers:
Personal custom instructions — per-user preferences that apply across all repositories. Set these for your coding style preferences that do not change between projects (e.g., "I prefer const over let" or "Always use async/await over .then()").
Organization custom instructions (currently in public preview) — org-wide standards that apply to all repositories in the organization. This is where you put company-wide coding standards, security requirements, and architectural patterns that every team should follow.
Prompt files — reusable prompt templates stored in the repo. These are pre-written prompts that team members can invoke rather than writing from scratch each time.
The instructions cascade: organization-level instructions provide the base, repository-level instructions add project specifics, and personal instructions add individual preferences. All three layers are visible to Copilot simultaneously.
If you commit .github/copilot-instructions.md to your repository, every developer on the team gets the same Copilot behavior. This is the single highest-impact, lowest-effort change you can make to improve Copilot's output quality — and it takes five minutes to set up.
06 The Extensions Ecosystem — Docker, Perplexity, and Building Your Own
GitHub Copilot Extensions reached general availability in February 2025 and are available across all Copilot license tiers. They let you integrate external tools directly into Copilot Chat using natural language, wherever you develop — VS Code, Visual Studio, JetBrains IDEs, and GitHub.com.
"GitHub Copilot Extensions are now generally available for users across all Copilot license tiers. With Copilot Extensions, you can integrate and prompt your favorite tools directly in Copilot Chat using natural language wherever you develop." — GitHub blog
The extension marketplace is at github.com/marketplace?type=apps&copilot_app=true. The most notable extensions as of early 2026:
Docker: Container management and Dockerfile generation directly from Copilot Chat. Ask "Create a multi-stage Dockerfile for my Node.js application" and Docker's extension generates it with best practices for layer caching, security scanning, and minimal image size.
Perplexity AI: Web search and research within Copilot Chat. Instead of switching to a browser to look up documentation or Stack Overflow answers, ask Perplexity through Copilot and get web-sourced answers inline with your development context.
Stack Overflow: Search Stack Overflow directly from Copilot Chat. The answers come with the same community voting and verification that makes Stack Overflow valuable, but without leaving your editor.
Mermaid Chart: Diagram generation from natural language. Describe your system architecture or data flow in plain English and get a rendered Mermaid diagram.
For teams that want custom integrations, there are two approaches to building your own extensions:
Copilot Skillsets: A lightweight implementation path for simpler integrations. Faster to build, less flexible.
Copilot Agents: A full agent implementation with context passing from the user's editor. More powerful, more complex to build. The agent receives the user's current editor state — open files, cursor position, selected text — and can act on it.
The GA release also introduced OpenID Connect (OIDC) support, replacing the previous X-Github-Token authentication model. This reduces API round trips and improves security for extension developers.
Extension availability is expanding: VS Code, Visual Studio, and JetBrains IDEs are all supported. GitHub Mobile support is rolling out. The ecosystem is young — Docker and Perplexity are the clear leaders by usage — but the extension API is mature enough for production use.
One extension category worth watching: internal tool integrations. The extension API lets companies build private extensions that connect Copilot to internal systems — documentation wikis, internal APIs, proprietary databases, CI/CD dashboards. A company could build an extension that lets developers ask "What's the current status of the deployment pipeline for service X?" or "Show me the most common errors in our logging system this week" directly from Copilot Chat. The OpenID Connect support makes this secure enough for enterprise use.
For the broader ecosystem comparison: Cursor's MCP (Model Context Protocol) integrations serve a similar purpose — connecting the AI to external tools and data sources. The difference is architectural. Copilot Extensions are built as GitHub Apps that communicate through a standardized API. Cursor MCPs are lightweight servers using the open MCP standard. Both enable the same fundamental capability — connecting AI to external tools — but Copilot Extensions are more tightly integrated with the GitHub ecosystem while MCPs are more portable across tools that support the standard, including Cursor, Claude Code, and others.
07 Which Tier Actually Fits You — A Decision Framework Based on How You Work
The tier decision depends on three factors: how you use Copilot (completions vs. chat vs. agent), how often you use it, and whether you need organizational features.
If you primarily use tab completions and rarely use Chat: Pro ($10/month). You get unlimited completions, 300 premium requests you probably will not exhaust, and access to solid models. The Free tier's 2,000 completion cap will frustrate any active developer within the first week.
If you use Chat and Agent Mode daily: Pro+ ($39/month). The jump from 300 to 1,500 premium requests is the deciding factor. If you are using agent mode for multi-step tasks — implementing features, debugging, refactoring — each task can consume 5-15 premium requests. At that rate, 300 requests lasts roughly 20-60 agent tasks per month. Heavy users blow through that in the first week. Pro+ gives you 5x the headroom plus access to the most capable models.
If you are a student: Student tier ($0). It is functionally identical to Pro with 300 premium requests, unlimited completions, full coding agent access, and agent mode. Claim it through the GitHub Student Developer Pack.
If you are on a team that needs compliance: Business ($19/user/month). The feature set matches Pro (300 premium requests per user), but adds centralized billing, policy management, audit logs, and IP indemnity. The IP indemnity alone justifies the premium for companies concerned about AI-generated code in their products.
If you are on an enterprise team that needs both compliance and power: Enterprise ($39/user/month). You get 1,000 premium requests per user (more than Business but less than individual Pro+), all premium models, plus SAML SSO enforcement and advanced audit capabilities.
If you are evaluating Copilot against competitors: The comparison points that matter: Cursor Pro is $20/month with up to 1M token context windows and background agents at that price point. Claude Code runs on API pricing at roughly $2/hour of active coding. Windsurf Pro is $20/month with daily quota-based limits. Copilot's advantage is native GitHub integration — the coding agent creates PRs directly, extensions work across the GitHub ecosystem, and the .github/copilot-instructions.md file travels with your repository.
For developers or teams evaluating multiple tiers or needing quick access to specific Copilot plan accounts — especially for comparison testing against tools like Cursor or Claude Code — services like acccup.com offer pre-configured accounts across various tiers. This is useful for teams running time-boxed evaluations where provisioning through official channels would take longer than the evaluation itself.
08 Setup in 10 Minutes — The Minimum Configuration That Maximizes Value
Whether you are on the Free tier evaluating Copilot or on Enterprise deploying to 200 developers, the setup steps that deliver the most immediate value are the same:
following existing test patterns
Then review the PR
The models available to you matter. On the Free tier, you are limited to Claude Haiku 4.5 and GPT-4.1 — capable but noticeably less powerful than what Pro and Pro+ offer. On Pro, adding Claude Sonnet 4.5/4.6 and Gemini 2.5 Pro gives you meaningfully better code generation, especially for complex multi-file changes. On Pro+ and Enterprise, Claude Opus 4.5/4.6 and GPT-5.4 are the most capable models available in any coding tool — period. The model gap between tiers is larger than the pricing gap suggests.
One final consideration: the competitive landscape is moving fast. Cursor's background agents operate at $20/month with a 70-80% one-shot success rate. Claude Code runs on API pricing at approximately $2/hour of active coding, with heavy users spending $150-400/month. Windsurf offers a Pro tier at $20/month with daily quota-based limits and a proprietary SWE-1 model. Each tool has different strengths — Copilot's native GitHub integration, Cursor's multi-file editing speed, Claude Code's terminal-based pipeline automation, Windsurf's flow-aware context understanding.
The decision is not just about which tool is "best." It is about which tool fits your workflow. If your team lives on GitHub, uses Issues for task management, and wants an agent that creates PRs autonomously, Copilot's coding agent has no equal. If you want the most powerful multi-file editing with the largest context window, Cursor wins. If you want terminal-based automation with hooks and headless mode for CI/CD, Claude Code is the answer. If you want the best free tier to evaluate before committing, Copilot Free plus Windsurf's free SWE-1.5 model give you the broadest evaluation at zero cost.
The .github/copilot-instructions.md file is the thread that ties everything together. Regardless of which tier you are on, that single file shapes every Copilot interaction in your repository. Create it first. Evaluate the tier second. The instructions file costs nothing and delivers the most immediate improvement in output quality across all Copilot tiers.