How to Use GitHub Copilot: Setup, Chat & Agents 2026
This guide walks through how to use GitHub Copilot from a clean install to shipping a reviewed change. Copilot is an AI assistant that lives inside the editor you already use: instead of a separate application, it installs as an extension in tools like VS Code, Visual Studio, JetBrains, Eclipse and Xcode. Once you sign in, it works through three layers, inline completions as you type, a chat panel for questions and tasks, and a coding agent that can carry out a goal across many files and open a pull request. The first session is quick to start and free to try.
The parts that pay off most, knowing when to lean on completions versus chat versus the agent, choosing a model, and treating output as a draft to review, are not obvious from the install screen. Below we walk the full path in order: picking a plan, installing the extension and signing in, using completions and chat, running the agent, choosing a model, and the habits that keep you in control of the code.
Before anything else: Copilot is free to start, and Pro is $10 per user per month. The plan section below breaks down exactly what each tier includes and who qualifies for Pro at no cost.
Before You Start: Plan and Prerequisites
Before you start, choose a plan and an IDE. Copilot is not a standalone editor. It is an assistant that attaches to an IDE you already use, so the first decision is the plan, and the first action is installing the extension, not switching tools.
Which plan to start on
The Free plan is genuinely useful for learning: it includes a selection of models with limited chat and agent usage, aimed at individuals without organization access. Pro, at $10 per user per month, removes the completion limits and includes the cloud agent, with a monthly credit allowance for premium usage. If you are a verified student, a verified teacher, or maintain a popular open source project, you may qualify for Pro at no cost. Heavier individual use steps up to Pro+ at $39 per month, and teams move to the Business plan at $19 per seat per month or Enterprise at $39 per seat per month.
One thing to settle early: if you work for an organization with rules about where source code can go, check whether Copilot is managed centrally on a Business or Enterprise plan before you point it at proprietary repositories. For a full breakdown of tiers and the credit model, see our GitHub Copilot pricing guide. Policy controls and the available model catalog are set at the organization level on those plans.
Install Copilot & Sign In
The first step in how to use GitHub Copilot is installing it, and the flow is the same shape in every IDE. You add the GitHub Copilot extension from your editor's marketplace, then sign in with your GitHub account to activate it. In VS Code, that is the Extensions view; in Visual Studio, JetBrains, Eclipse or Xcode, it is the equivalent plugin or extension manager. Once you authenticate and your plan is active, completions start appearing as you type and the chat and agent surfaces become available.
Install and sign in, step by step
The activation flow is short, and it is the same idea wherever you work.
2. Search for "GitHub Copilot" and install the extension
3. Sign in with your GitHub account when prompted
4. Confirm your plan is active (Free, Pro, Business or Enterprise)
5. Open a real project, then start typing to see ghost-text suggestions
Because completions and chat are supported in slightly different sets of editors, it is worth knowing which features you get where. Inline completions reach the widest set of tools, while chat and the agent are concentrated in the major IDEs.
| Feature | Where It Works |
|---|---|
| Inline completions | VS Code, Visual Studio, JetBrains, Xcode, Eclipse, Vim/Neovim, Azure Data Studio, Zed |
| Chat and agent | VS Code, Visual Studio, JetBrains, Eclipse, Xcode |
| Chat (additional) | GitHub.com, GitHub Mobile, Copilot CLI |
If completions do not appear after install: the usual cause is not being signed in, or signing in with an account that does not have an active Copilot plan. Confirm you are authenticated with the right GitHub account and that the plan is active before troubleshooting anything deeper.
Completions: Accept & Cycle Suggestions
The feature you will use most often is inline completion. As you type, Copilot offers a suggestion in grey ghost text ahead of your cursor. Press Tab to accept it, keep typing to ignore it, or cycle through alternatives when more than one is offered. The suggestions range from finishing the current line to drafting a whole function, based on the surrounding code and the patterns it sees in your file.
Comment-driven generation
A practical way to steer completions is to describe what you want in a comment, then let Copilot draft the implementation underneath. Writing a clear comment such as a short description of a function's job often produces a more useful first draft than starting from a blank line, because you have given the model the intent to work from.
Next edit suggestions
Beyond finishing what you are typing, Copilot offers next edit suggestions, which predict both the location and the content of your likely next change. After you make an edit, it can point to the related spot that probably needs updating too, such as a call site that should change to match a function you just renamed, so you can move through a change by accepting one suggestion after another.
How to think about it: reach for completions when you know roughly what you want to write and want it faster. Reach for chat or the agent when you would rather describe the outcome and let Copilot work out the approach.
Copilot Chat for Questions & Tasks
Copilot Chat is a conversational panel inside the editor for the questions that do not fit a single completion. You can ask it to explain unfamiliar code, generate tests, find vulnerabilities, and fix bugs, all in the context of the files you are working in. It is available in VS Code, Visual Studio, JetBrains, Eclipse and Xcode, as well as on GitHub.com, in GitHub Mobile, and in the Copilot CLI for the terminal.
Slash commands
To save typing the same framing over and over, chat supports slash commands for common tasks, short shortcuts that tell Copilot what kind of help you want, such as explaining a selection or generating tests for it. Type the slash command, point it at the relevant code, and you skip writing a full prompt each time.
Extending chat with MCP
Chat is also extensible through the Model Context Protocol, an open standard for giving an AI tool access to external systems and data sources. Connecting MCP servers lets chat pull in context and act on tools beyond the editor, so it can reach the services and data your work already depends on rather than being limited to the open files.
A good first chat task: open a file you did not write and ask Copilot to explain what it does. It is low risk, it shows you how chat uses the surrounding code, and it is genuinely useful when you are getting oriented in an unfamiliar codebase.
Agent Mode: Assign a Task
Agent mode is the part of Copilot that takes on a whole task from a goal you assign. Instead of writing every edit yourself, you describe the outcome and the coding agent indexes the repository, plans the work, edits across multiple files, validates what it has done, and opens a pull request for you to review. The pull request is the key detail: nothing lands in your main branch until you have read the changes and merged them yourself.
Where it connects
The agent is built to fit the places work already happens. It integrates with tools such as Jira, Slack, Teams and Linear, so a task can flow from your tracker into a pull request. In preview, it can also delegate parts of a job to Claude and to OpenAI Codex, coordinating more than one model on the same goal. For a deeper look at planning and review, see our GitHub Copilot agent mode breakdown.
For a first task, start small and well scoped. Assign the agent a contained change you can read in a few minutes, review the pull request it opens, and accept or refine it. Once you trust how it works, larger tasks and tighter integration with your tracker follow naturally.
Step by step, end to end
Here is the loop the whole guide builds toward, from a fresh install to a reviewed change.
| Step | What You Do |
|---|---|
| 1. Install | Add the Copilot extension to your IDE, sign in with GitHub, pick a plan |
| 2. Complete | Accept ghost-text suggestions and use comments to steer drafts |
| 3. Chat | Explain code, generate tests, find vulnerabilities and fix bugs |
| 4. Agent | Assign a task, then review the pull request before merging |
| 5. Model | Switch models per task; use extended context only when it helps |
Pick a Model
Copilot is not tied to a single AI provider. The model picker offers a catalog drawn from several labs, so you can match the model to the task. As of June 15, 2026 the catalog included OpenAI's GPT-5.5 and the GPT-5.4 family, Anthropic's Claude Fable 5 and Claude Opus, Google's Gemini, and Microsoft's own in-house models such as MAI-Code-1-Flash. The list moves quickly, with older versions retired as new ones ship, so treat the in-app picker and the supported models documentation as the source of truth rather than any fixed list.
Extended context and reasoning
Select frontier models support an extended one million token context window and configurable reasoning effort, available in VS Code and the Copilot CLI. These help most on tasks that need a large amount of code in view or deeper step-by-step reasoning, but they consume more credits, so they are best reserved for the work that genuinely benefits rather than turned on by default.
How credits work
Premium usage is measured in credits, each worth one cent, rather than the legacy request model. Each paid plan includes a monthly credit allowance: Pro includes roughly $15 of total monthly usage, Pro+ around $70, and the higher individual tier more again. Completions on a paid plan are unlimited, while premium model usage and the agent draw on your credit allowance, which is the main thing to watch if you use the heavier models often.
On model names: the available models change often as providers ship new versions and older ones are retired. Confirm what is currently offered in Copilot's model picker and the documentation rather than relying on any fixed list, including the one above.
How to Use GitHub Copilot Responsibly: Copilot, Not Autopilot
The most important habit is GitHub's own framing for working with the tool well: Copilot not Autopilot. The tool is assistive, and human review is required. Its suggestions are probabilistic predictions of likely code, not vetted answers to copy and paste. That distinction is the single most important habit to carry into every session, because the danger with a fast, fluent assistant is accepting changes you have not actually read.
Used this way, Copilot speeds up the mechanical parts of coding while you stay responsible for the judgment: what the code should do, whether it is correct, and whether it is safe. That balance, fast assistance with human review, is what GitHub means by Copilot not Autopilot, and it is the habit that separates getting value from the tool from getting caught out by it.
Troubleshooting
These are the questions newcomers run into most often when they first work out how to use GitHub Copilot, with the practical answer for each.