GitHub Copilot passed 20 million all-time users in 2025, and about 4.7 million of those now pay for a subscription, according to a 2026 developer-tools roundup from BuildMVPFast. That makes it the most widely adopted AI coding assistant by raw user count, even as competitors like Cursor and Claude Code win specific benchmarks. If you have never installed it, or installed it once and never got past the default settings, this walkthrough covers how to set up GitHub Copilot from scratch: your GitHub account, the Visual Studio Code extension, Copilot Chat, Agent Mode, the command-line tool, and a small working project that ties the pieces together.
Budget about 70 minutes if you follow every step, including the hands-on project near the end. Most of that time goes to waiting on installs and typing prompts, not reading documentation. By the end, you will know how to use GitHub Copilot’s full toolkit day to day, not just accept its first suggestion and move on.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Is GitHub Copilot and Why It Matters in 2026
GitHub Copilot is an AI pair programmer that runs inside your code editor. It reads the file you have open, and depending on your settings, other files in your workspace, then suggests completions as you type. Microsoft’s GitHub team built it on top of large language models from multiple providers now, not a single model lineage like the original 2021 preview. According to GitHub’s own product page, current plans give you access to models including Haiku 4.5 and GPT-5 mini by default, with premium models such as Opus available once you move to a paid tier that supports them.
The tool does three broad jobs. It completes code inline as ghost text while you type. It answers questions and edits files through Copilot Chat, a conversational panel. And through Agent Mode, it takes a plain-language task, plans the work, edits multiple files, runs terminal commands, and iterates on its own errors before handing you a diff to review.
Copilot’s install base gives it an edge that has little to do with raw model quality. It ships as a first-party extension inside the editor most professional developers already use, and it bills through the same GitHub account that hosts their repositories. The The cited **42%** figure refers to **GitHub Copilot’s share of paid AI coding tools**, not a claim that Copilot always wins head-to-head comparisons; recent 2026 roundups say Copilot leads on installed base, while Cursor leads on revenue and Claude Code leads on satisfaction[11][20] It is because switching costs are close to zero when the tool is already sitting in your Extensions panel. If you want the deep head-to-head numbers against Cursor or Claude Code, separate comparisons linked at the end of this guide cover those. Here, the focus is getting Copilot itself running correctly and configured well.
The product has changed shape more than once since its 2021 technical preview. Early Copilot only handled inline completions, drawing from a single model family. The current version bundles inline completions, Chat, automated pull request review, Edits, and Agent Mode under one subscription, which is part of why the setup process below has more steps than a typical single-purpose extension. You are not just installing a smarter autocomplete. You are configuring five distinct tools that happen to ship together under one icon in the status bar.
Prerequisites: What You Need Before You Set Up GitHub Copilot
You do not need much to get started, but a few pieces have to be in place before Step 1.
- A GitHub account. Free to create at github.com. If you already use GitHub for version control, reuse that account.
- A supported code editor. This tutorial uses Visual Studio Code, the latest stable, auto-updating release, since it has the most complete Copilot feature set. Copilot also runs in Visual Studio, JetBrains IDEs such as IntelliJ IDEA, PyCharm, and WebStorm, plus Neovim, Vim, Azure Data Studio, and Eclipse, though Copilot Chat is currently limited to VS Code, JetBrains, and Visual Studio.
- An operating system Copilot supports. Windows 10 or later, macOS, or Linux all work fine.
- A stable internet connection. Copilot sends context to GitHub’s servers for every suggestion, so it will not function offline.
- Node.js 22 or later, only if you plan to install the standalone Copilot CLI in Step 10 via npm.
- A payment method, only if you choose a paid plan. The Free tier needs nothing beyond a GitHub account.
That is the full list. No API keys to manage, no local GPU, no separate license server. Whatever friction shows up later tends to live in configuration, not installation.
GitHub Copilot Pricing Plans Compared
GitHub restructured Copilot’s pricing around an AI credits system, where 1 credit equals $0.01. Code completions and next-edit suggestions never consume credits and stay unlimited on every paid plan. Credits get spent on premium model requests and heavier Chat or Agent Mode sessions. Here is how the tiers break down, based on GitHub’s published plan details:
| Plan | Price | Completions | Chat / Credits | Best For |
|---|---|---|---|---|
| Free | $0/month | 2,000/month | 50 chat requests/month | Trying Copilot before you commit |
| Pro | $10/month | Unlimited | $15 in monthly AI credits | Individual developers |
| Pro+ | $39/month | Unlimited | $70 in monthly AI credits, premium models | Power users who want Opus-tier models |
| Business | $19/user/month | Unlimited | Org-pooled credits | Small and mid-sized teams |
| Enterprise | $39/user/month | Unlimited | Priority access, roughly 2x the usage of Business | Large orgs with compliance requirements |
For most individual developers, the decision comes down to Free versus Pro. The Free tier’s 2,000 monthly completions sound generous until you remember that one active coding session can burn through dozens of suggestions per hour. The 50-chat-request cap is the tighter constraint in practice: debugging a single gnarly bug with back-and-forth Chat questions can eat a third of your monthly allowance in an afternoon. Pro’s $10/month removes both ceilings for completions and adds a $15 credit pool for anything that does consume credits, which for most people is enough to stop thinking about billing entirely.
Business and Enterprise exist for organizations that need centralized billing, policy controls (including the ability to disable Chat org-wide, which shows up later in this guide’s troubleshooting section), and audit logging. If you are setting Copilot up for yourself, skip straight to Free or Pro.
Step 1: Create or Verify Your GitHub Account
If you already have a GitHub account, sign in at github.com and confirm your email address is verified under Settings, then Emails. Skip to Step 2.
If you are starting from zero, go to github.com/join, pick a username, and verify your email. Use whichever address makes sense for how you plan to pay: a personal one for an individual Pro subscription, or a work address if your employer will eventually move you onto a Business or Enterprise seat. Changing this later is possible but tedious, since it touches every repository permission tied to the account.
While you are in account settings, turn on two-factor authentication. GitHub has required 2FA for contributors to some repositories for years, and Copilot’s OAuth sign-in flow in Step 3 goes faster when you are not fumbling for a code mid-setup. A separate walkthrough on setting up TOTP-based MFA covers the long version if you want it.
Step 2: Install Visual Studio Code and the Copilot Extension
Download VS Code from code.visualstudio.com if you do not already have it, and install it like any other desktop application. Once it is open, there are two ways to add Copilot.
Through the UI: open the Extensions view (Ctrl+Shift+X on Windows and Linux, Cmd+Shift+X on macOS), type “GitHub Copilot” into the search box, and click Install on the extension published by GitHub. GitHub’s own quickstart documentation puts the step just as plainly: “Install the GitHub Copilot extension for Visual Studio Code from the Extensions panel.” VS Code will usually prompt you to also install GitHub Copilot Chat, a separate extension that powers the conversational panel. Install both.
Through the command line, if you would rather script it or you are setting up several machines, the process is the same two-extension split. A developer writing on dev.to about getting better results from Copilot describes it this way: “Install it from the Extensions panel or via the CLI”. The CLI version looks like this:
code --install-extension GitHub.copilot
code --install-extension GitHub.copilot-chatBoth commands pull directly from the Visual Studio Marketplace. If `code` is not recognized as a command, VS Code is not on your PATH yet. On macOS, open the Command Palette (Cmd+Shift+P), search “Shell Command,” and run “Install ‘code’ command in PATH.” On Windows, the standard installer does this automatically as long as you leave the “Add to PATH” checkbox ticked during setup.
Step 3: Sign In and Authenticate Copilot
With both extensions installed, look at the bottom status bar of VS Code for the Copilot icon. Hover over it and select the sign-in option, which opens a browser window pointed at GitHub’s OAuth authorization page. Approve the request, and VS Code reconnects automatically once the browser confirms the login.
If you already have an active Copilot subscription tied to your account, VS Code detects it immediately and you are done. If you do not, GitHub signs you up for the Free plan automatically, with no separate signup form required.
One thing worth knowing before you hit it by accident: GitHub’s own documentation notes that “if you have access to GitHub Copilot via your organization, you won’t be able to use GitHub Copilot Chat if your organization owner has disabled chat.” If Chat looks greyed out after a clean install and sign-in, that is almost always the cause rather than a bug on your end. It comes up again in the troubleshooting section below.
Step 4: Verify Copilot Is Generating Suggestions
Create a new file with a .js extension and type a plain function signature. GitHub’s own quickstart uses this exact example:
function calculateDaysBetweenDates(begin, end) {Within a second or two, Copilot should display a suggestion as grayed-out ghost text, continuing the function body. Press Tab to accept the whole suggestion, Esc to dismiss it, or keep typing to ignore it and write your own logic. A typical accepted suggestion looks like this:
function calculateDaysBetweenDates(begin, end) {
const oneDay = 24 * 60 * 60 * 1000;
const diffInTime = end.getTime() - begin.getTime();
return Math.round(diffInTime / oneDay);
}If nothing appears after 5 to 10 seconds, do not assume it is broken yet. Click the Copilot icon in the status bar and confirm it reads “Ready” rather than showing a warning triangle. A warning usually means the sign-in from Step 3 did not fully complete, or the file type you are testing in is disabled in settings, which Step 6 covers. Trying the exact function-signature example above rules out prompt quality as a variable while you debug.
Step 5: Learn the Core Copilot Keyboard Shortcuts
Copilot is faster once the shortcuts are muscle memory instead of mouse clicks. These are the VS Code defaults, all of which you can rebind under File, Preferences, Keyboard Shortcuts if they collide with something else you use.
| Action | Windows / Linux | macOS |
|---|---|---|
| Accept inline suggestion | Tab | Tab |
| Dismiss inline suggestion | Esc | Esc |
| Show next suggestion | Alt+] | Option+] |
| Show previous suggestion | Alt+[ | Option+[ |
| Trigger suggestion manually | Alt+ | Option+ |
| Open Copilot Chat panel | Ctrl+Alt+I | Control+Command+I |
| Open inline chat | Ctrl+I | Cmd+I |
The two worth prioritizing are Tab to accept and Ctrl+Alt+I (Control+Command+I on Mac) to open Chat, since you will use both dozens of times a day once Copilot is part of your workflow. The manual trigger, Alt+, matters more than it sounds: if you have disabled automatic suggestions to cut down on visual noise, this is how you still call one up on demand.
Step 6: Configure Copilot Settings and Privacy Controls
Default settings are reasonable, but a few changes are worth making before you rely on Copilot daily. Open Settings (Ctrl+, or Cmd+,), search “Copilot,” and toggle behavior through the UI. For anything more specific, editing settings.json directly is faster:
{
"github.copilot.enable": {
"*": true,
"plaintext": false,
"markdown": true,
"yaml": false
},
"editor.inlineSuggest.enabled": true
}The github.copilot.enable block lets you turn suggestions off for specific languages. Disabling plaintext and YAML is common advice, since Copilot tends to guess badly in config files, where a wrong suggestion can silently break a deployment rather than just fail to compile.
Exclude Files From Copilot’s Context
On Business or Enterprise, organization admins can set content exclusions, blocking specific paths or entire repositories from ever being sent to Copilot as context. That matters for anything with embedded credentials, customer data samples, or code under a license that restricts AI training use. Individual Pro users have a lighter version of this control in personal settings, though the org-level exclusion is the one that actually prevents Copilot from reading the files at all, rather than just asking it not to.
Check this setting before you point Copilot at a monorepo that mixes public-facing code with internal tooling. The default behavior is permissive: if a file is open or referenced, Copilot can see it.
Step 7: Master GitHub Copilot Chat
Chat is where Copilot stops being autocomplete and starts being a collaborator you can actually argue with. Open it with Ctrl+Alt+I (Control+Command+I on Mac) or the chat icon in the title bar, type a question, and press Enter.
Chat Participants and Slash Commands
Two features make Chat more useful than a generic chatbot bolted onto your editor: participants and slash commands. Participants, prefixed with @, tell Copilot which context to draw from. Slash commands, prefixed with /, tell it what kind of task to perform.
@workspace explain how authentication works in this repo
/fix the null pointer exception in this function
/tests generate unit tests for this file
/doc add docstrings to every public function in this module@workspace is the one to learn first. It gives Copilot awareness of your whole project structure instead of just the open file, which matters enormously for questions like “where is the rate limiter configured” in a codebase you did not write. @terminal does the same thing for shell history and error output, useful when you want Copilot to explain a stack trace you just pasted.
According to GitHub’s own best-practices documentation, if a response is not useful, the fix is rarely to give up on Chat entirely. As the guidance puts it, “rewrite your prompts to generate different responses. If Copilot is not providing a helpful response, try rephrasing your prompt, or even breaking your request down into multiple smaller prompts.” That single habit, splitting one vague ask into two or three specific ones, fixes more bad Copilot sessions than switching models does.
Step 8: Use Copilot Edits for Multi-File Changes
Chat answers questions and proposes snippets. Edits mode goes a step further: you describe a change, and Copilot proposes a diff spanning however many files the task touches, all reviewable before anything lands on disk.
Open Edits from the same Chat panel by switching modes at the top, or through the Command Palette. A typical use case is renaming a function used across a dozen files, or adding a new required field to a shared interface and updating every place that constructs it. Copilot shows each proposed file change individually, so you can accept the ones that look right and reject or manually fix the ones that do not, rather than an all-or-nothing apply.
The practical limit is scope. Edits works best on changes you could describe in one or two sentences and verify by eye. Once a task needs its own research, like figuring out why a query runs slow and fixing it, that is Agent Mode’s job instead.
Step 9: Turn On Agent Mode for Autonomous Coding Tasks
Agent Mode is the closest Copilot gets to an autonomous engineer. Instead of a single edit, you hand it a task, and it plans the work, edits multiple files, runs terminal commands to test its own changes, reads the errors, and retries, before stopping to show you a final diff.
Switch to Agent mode in the Chat panel’s mode selector, then describe the task with enough detail that Copilot does not have to guess at requirements:
Add rate limiting to the /api/login endpoint using a sliding window
of 5 requests per minute per IP address. Include a unit test that
confirms the 6th request within a minute returns HTTP 429.Watch the first few runs closely rather than walking away. Agent Mode will install packages, run test suites, and execute terminal commands on your behalf, and while it generally asks for confirmation on destructive actions, “generally” is doing some work in that sentence. Review the diff the way you would review a junior engineer’s pull request: read every changed line, do not just skim the summary Copilot writes for itself.
Step 10: Install the GitHub Copilot CLI
Copilot’s command-line tool reached general availability in February 2026 and now ships as its own package rather than living only inside gh, GitHub’s official CLI. As of mid-2026 there are several supported install paths, per GitHub’s setup documentation:
# Via npm (requires Node.js 22 or later)
npm install -g @github/copilot
# Via Homebrew (macOS or Linux)
brew install --cask copilot-cli
# Via WinGet (Windows)
winget install GitHub.Copilot
# Via the GitHub CLI, if you already have gh installed
gh copilotThe gh copilot route is the path of least resistance if you already use the GitHub CLI for pull requests and issues: run it once, and it prompts to install the standalone Copilot CLI automatically, then forwards your command to it. Once installed, running copilot in any project directory drops you into an agentic terminal session that can read your codebase, propose shell commands, and edit files without ever opening VS Code, which is handy for server work over SSH or quick fixes in a CI debugging shell.
Because the CLI shipped GA only a few months before this guide was written, expect flags and default behavior to keep shifting. Check GitHub’s changelog before you build automation on top of specific CLI output formatting.
Step 11: Build a Complete Project With Copilot: A Task Tracker API
Reading about ghost text only goes so far. This section builds a small but complete FastAPI task tracker end to end, using Copilot for the parts it is actually good at, so you can see the real workflow rather than a cherry-picked demo.
Set Up the Project Folder
mkdir copilot-task-tracker && cd copilot-task-tracker
python3 -m venv venv
source venv/bin/activate
pip install fastapi "uvicorn[standard]"
code .Create a folder called app with an empty __init__.py, then a new file at app/models.py.
Let Copilot Generate the Data Model
Type only a comment describing what you want, and let inline suggestions do the rest:
# Pydantic model for a Task with id, title, done flag, and priority (low/medium/high)Press Enter, wait for the ghost text, and Tab to accept. A typical result looks like this:
from pydantic import BaseModel, Field
from typing import Literal
from uuid import uuid4
class Task(BaseModel):
id: str = Field(default_factory=lambda: str(uuid4()))
title: str
done: bool = False
priority: Literal["low", "medium", "high"] = "medium"Suggestions will not always match exactly, since the model is non-deterministic. If it defaults id incorrectly, say a bare str(uuid4()) evaluated once instead of a Field with default_factory, every task would get the same ID. That is a real failure mode worth knowing about, not a hypothetical one. Read every suggestion before accepting it, even short ones.
Prompt Copilot Chat for the API Routes
Switch to Copilot Chat and reference the workspace so it can see the model you just wrote:
@workspace Using the Task model in app/models.py, create a FastAPI router in
app/routes.py with endpoints to create a task, list all tasks, mark a task
done, and delete a task. Store tasks in an in-memory dictionary keyed by id.Chat will propose a full file. After trimming it down, app/routes.py should look close to this:
from fastapi import APIRouter, HTTPException
from app.models import Task
router = APIRouter()
tasks: dict[str, Task] = {}
@router.post("/tasks")
def create_task(task: Task):
tasks[task.id] = task
return task
@router.get("/tasks")
def list_tasks():
return list(tasks.values())
@router.patch("/tasks/{task_id}/done")
def mark_done(task_id: str):
if task_id not in tasks:
raise HTTPException(status_code=404, detail="Task not found")
tasks[task_id].done = True
return tasks[task_id]
@router.delete("/tasks/{task_id}")
def delete_task(task_id: str):
if task_id not in tasks:
raise HTTPException(status_code=404, detail="Task not found")
del tasks[task_id]
return {"status": "deleted"}Add a short app/main.py that creates a FastAPI instance and includes the router, then run it.
Run It and Check the Output
uvicorn app.main:app --reload
# In a second terminal:
curl -X POST http://127.0.0.1:8000/tasks
-H "Content-Type: application/json"
-d '{"title":"Ship the Copilot tutorial","priority":"high"}'A working setup returns something like this:
{"id":"3f29a1b0-6e1d-4c3a-9f2e-8b7d1a0c5e44","title":"Ship the Copilot tutorial","done":false,"priority":"high"}From here, try the /tests slash command against app/routes.py to generate a pytest file, or switch to Agent Mode and ask it to add a GET /tasks endpoint that filters by priority and done status, with a test included. That last prompt is a good measure of whether your setup actually works end to end, since it touches routing, query parameters, and test generation in one pass.
Step 12: Optimize Your Workflow With Advanced Copilot Tips
Once the basics work, a handful of habits separate people who know how to use GitHub Copilot well from people who install it, get a few bad suggestions, and quietly stop using it.
Keep your workspace tidy while you work. GitHub’s own best-practices guidance is direct about this: “provide Copilot with helpful context: if you are using Copilot in your IDE, open relevant files and close irrelevant files.” Copilot builds context from what is open, and a dozen unrelated tabs dilutes that context with noise.
Write a .github/copilot-instructions.md file at your repository root. Copilot Chat and Agent Mode read it automatically and use it as standing context, so instead of re-explaining your test framework or naming conventions in every prompt, you state them once. Teams that adopt this report far less repetitive prompt-writing than any single model upgrade delivers.
Name things before you write them. A function called calculateDaysBetweenDates gets a far better suggestion than one called calc, because Copilot is pattern-matching against your own naming, not just general code corpora. The same logic applies to comments: a one-line comment describing intent before a block of code consistently outperforms writing the code first and asking Copilot to explain or refactor it afterward.
Pick your model deliberately if you are on Pro+, Business, or Enterprise. Premium models cost more credits per request but handle larger, more ambiguous refactors better. Save them for Agent Mode tasks and multi-file Edits, and let the default lighter models, Haiku 4.5 and GPT-5 mini, handle routine inline completions where speed matters more than reasoning depth.
5 Common Pitfalls When You Set Up GitHub Copilot
Most GitHub Copilot setup problems trace back to one of these five mistakes, all avoidable once you know to look for them.
- Installing the extension but never actually signing in. VS Code lets the extension sit there dormant with no error message, no suggestions, and no obvious indicator beyond a small icon state in the status bar. If Copilot seems installed but does nothing, check sign-in status first before troubleshooting anything else.
- Leaving dozens of irrelevant files open. Every open tab is potential context. A workspace cluttered with unrelated files, old branches, or scratch notes measurably drags down suggestion quality, since Copilot draws patterns from all of it rather than just the file you are actively editing.
- Burning through the Free tier’s 50 monthly chat requests in one debugging session. It happens faster than people expect. A single back-and-forth session working through a tricky bug easily runs 15 to 20 messages. Track usage if you are on Free, or budget for Pro if Chat is central to how you work.
- Enabling workspace-wide context in a repo that still has secrets in plaintext files. Copilot reads whatever is open or referenced. Rotate any credentials sitting in .env files or config before you let Copilot index the whole workspace, and make sure those paths are gitignored regardless.
- Writing one giant vague prompt instead of several specific ones. “Fix my app” produces worse results than “fix the 500 error thrown when the request body is missing a title field.” This is the single most common reason people conclude Copilot Chat is not very good, when the actual issue is prompt scope.
- Assuming a personal Pro subscription and an organization seat stack. They do not. If your employer assigns you a Business or Enterprise seat, cancel any personal Pro subscription tied to the same account first, or you end up paying twice for overlapping completions and credits.
Setting Up GitHub Copilot for a Team or Organization
Everything up to this point covers an individual setup: one developer, one GitHub account, one editor. Rolling Copilot out to a team changes the entry point from Settings inside VS Code to your organization’s settings page on GitHub.com, and it is worth doing deliberately rather than letting individual engineers self-serve Pro subscriptions on expense reports.
An organization owner assigns Copilot access from the organization’s settings, not through each member’s personal account. On Business, at $19 per user per month, or Enterprise, at $39 per user per month, admins choose who gets a seat, and unused seats can be reassigned rather than sitting on a per-person contract. That matters for teams where only some engineers write code daily, since you are not paying for seats that never open an editor.
Policy controls live in the same admin panel. The Chat toggle covered in Step 3 is set here, and if it comes up as a support request from a confused developer whose Chat panel is greyed out, this is the first place to check. Content exclusions from Step 6 are also organization-wide settings, applied by repository or path, and they take priority over anything an individual developer configures locally. If legal or security flagged specific repositories as off-limits for AI context, set the exclusion at the org level rather than trusting every engineer to configure it themselves.
Roll it out in two phases rather than switching every seat on at once. Pilot with a handful of engineers on Business for a month and watch which workflows actually save time. Code review comments and boilerplate generation tend to land first, while complex refactors take longer for a team to trust. Then expand. The low switching cost mentioned earlier works in your favor here: once Copilot is approved at the org level, adding new engineers is a seat assignment, not a new procurement conversation.
One feature worth enabling alongside the core extension: Copilot can review pull requests automatically when added as a reviewer, leaving inline comments the way a human reviewer would on style, obvious bugs, and missing tests. Turn it on per repository under branch protection settings once your team is comfortable with Copilot’s suggestions elsewhere. It will not replace a human review on anything architecturally significant, but it consistently catches small issues, like an unhandled null case, before a person has to.
Troubleshooting: 8 Common GitHub Copilot Problems and Fixes
Even a clean install runs into friction eventually. These eight issues cover most of what shows up in GitHub’s own support forums and community discussions.
| Problem | Likely Cause | Fix |
|---|---|---|
| No suggestions appear at all | Not signed in, or Copilot disabled for this file type | Check the status bar icon for a warning state, sign in again, confirm the language is enabled in settings.json |
| Sign-in fails or times out | Browser blocked the OAuth popup, or a corporate firewall/proxy intercepted it | Allow popups for github.com, retry, or ask your network admin about proxy allowlisting |
| Suggestions are low quality or off-topic | Too much irrelevant context open, or a vague prompt | Close unrelated tabs, add a comment describing intent before the code, rewrite the prompt more specifically |
| Copilot Chat is greyed out | Your organization owner has disabled the Chat policy | Contact your GitHub organization admin to enable the Copilot Chat policy |
| “You’ve reached your monthly chat limit” | Free tier’s 50 chat requests used up before the reset date | Wait for the monthly reset, or upgrade to Pro for unlimited chat access |
| Extension installed but icon missing from the status bar | VS Code needs a restart after installation | Reload the window with Ctrl+Shift+P, then “Developer: Reload Window” |
| Agent Mode stalls or never finishes a task | The task was too large or ambiguous for one pass | Break it into smaller sub-tasks with explicit, checkable acceptance criteria |
| The copilot or gh copilot command is not found in the terminal | CLI not installed, or not on your shell’s PATH | Reinstall using the npm, Homebrew, or WinGet method from Step 10, then restart your terminal session |
How GitHub Copilot Compares to Other AI Coding Assistants
This guide is about setting Copilot up correctly, not picking a winner, but a quick sense of where it sits is useful context.
| Tool | Starting Price | Free Tier | Best For |
|---|---|---|---|
| GitHub Copilot | $10/month (Pro) | 2,000 completions/month, 50 chat requests | Teams already living inside GitHub |
| Cursor | $20/month | Limited completions on a credit-based system | Developers who want an AI-first editor rather than an extension |
| Claude Code | Usage-based, plan options available | Limited free usage | Complex, multi-file agentic tasks |
Copilot’s advantage is distribution: it is already inside the editor most developers use, billed through an account they already have, and its Free tier requires no separate signup. Cursor and Claude Code both post strong scores on specific coding benchmarks in various 2026 rankings, and if raw agentic capability matters more to you than integration friction, the Claude Code versus GitHub Copilot comparison and GitHub Copilot versus Cursor comparison go deep on the benchmark numbers. If you are choosing between more than two tools at once, the Best AI Coding Assistants 2026 ranking lines up seven of them side by side.
Weigh IDE lock-in too. Copilot follows you across every supported editor, which matters if your team is not fully standardized on VS Code. Cursor and Windsurf are forks of VS Code itself, so switching to either one means switching editors, not just extensions. That is a bigger decision than it looks on the surface, and it is worth factoring in before you commit a whole team to a tool that also decides which editor everyone uses.
For a lot of developers, though, the choice is not really a contest. If your team’s code already lives on GitHub, Copilot is the path with the fewest new accounts, billing relationships, and context switches to manage, which is exactly why this guide exists.
Frequently Asked Questions About GitHub Copilot Setup
Is GitHub Copilot free to use?
Yes. The Free plan needs only a GitHub account, no credit card, and includes 2,000 code completions and 50 chat requests per month. It resets monthly and does not expire.
Does GitHub Copilot work outside of VS Code?
Yes. It supports Visual Studio, JetBrains IDEs like IntelliJ IDEA and PyCharm, Neovim, Vim, Azure Data Studio, and Eclipse. Copilot Chat specifically is currently limited to VS Code, JetBrains, and Visual Studio, so the conversational features covered in Steps 7 through 9 of this guide are not yet available everywhere Copilot itself runs.
What’s the real difference between Pro and Pro+?
Pro is $10/month with $15 in monthly AI credits and unlimited completions. Pro+ is $39/month with $70 in credits and adds access to premium models, including Opus-tier models for harder reasoning tasks. Most individual developers are well served by Pro. Pro+ makes more sense once you are running Agent Mode on non-trivial tasks daily.
Can my company stop Copilot from reading certain files or repos?
Yes, on Business and Enterprise plans. Admins can set content exclusions by path or by repository, which prevents Copilot from using those files as context at all, not just from suggesting code that resembles them.
Does GitHub train its models on my private code?
Business and Enterprise plans do not use customer code to train GitHub’s shared models. Individual and Free-tier users can review and adjust code-matching and training-related settings from their personal Copilot settings on GitHub.com, since defaults have changed over time and are worth checking directly.
What happened to the old gh copilot extension?
It still works, but GitHub Copilot CLI is now also available as a standalone tool you can install directly through npm, Homebrew, or WinGet, independent of the GitHub CLI. Copilot CLI reached general availability in February 2026, and running gh copilot will prompt you to install the standalone version if you have not already.
Can I use Agent Mode on the Free plan?
Yes, but it draws from the same 50-monthly-chat-request allowance, and autonomous multi-step tasks tend to use several requests per run. If you plan to use Agent Mode regularly rather than occasionally, Pro removes the ceiling.
Which AI model actually generates my suggestions?
It depends on your plan and the type of request. Free and Pro default to models like Haiku 4.5 and GPT-5 mini for most completions and chat. Pro+, Business, and Enterprise plans can route requests to premium models, including Opus, when the task calls for deeper reasoning. You can see the current model list under Copilot’s model picker in the Chat panel, or check GitHub’s supported models reference.
Related Coverage
- Claude Code vs GitHub Copilot 2026: 80.8% vs 72.5% SWE-bench and a $10 Price Gap
- GitHub Copilot vs Cursor 2026: The Definitive AI Coding Assistant Comparison
- How to Master Cursor AI in 12 Steps [2026]
- Windsurf vs Cursor vs Copilot: $200 vs $39 Gap [2026]
- Cline vs Claude Code vs Copilot: Free vs $20 vs $10 [2026]
- Best AI Coding Assistants 2026: 7 Tools Ranked by Speed, Price & IDE Support
- How to Set Up TOTP MFA: 12 Steps, 60 Min [2026]
