GitHub Copilot in VS Code: Setup, Plan vs Agent Mode and Free Tier Limits

Published On: August 9th, 2026|Categories: AI, Programming|20 min read|

This guide covers GitHub Copilot in VS Code end to end: installing the extension, the difference between Plan mode and Agent mode in Copilot Chat, and how the free tier and premium requests work so you can track usage before you hit a limit.

GitHub Copilot Chat has grown from a question-answer box into a tool for building whole projects, and two features drive that: plan mode and agent mode. Plan mode has the assistant lay out an approach before writing any code, and agent mode executes work across your files. Used together, they let you implement a project methodically, approving the direction before the agent runs with it. Understanding how to combine them is what turns Copilot from a helper into a controllable builder.

What plan mode does

Plan mode is about thinking before doing. Instead of jumping straight to code, Copilot proposes a plan, a breakdown of the steps it intends to take, which you can read and adjust, with the behavior covered in the Copilot documentation. This gives you a checkpoint to catch a wrong approach before any code is written, when correcting it is cheapest. Reviewing the plan is where you steer the whole task. A good plan up front prevents a lot of wrong work later.

What agent mode does

Agent mode is where the plan becomes reality. Once you are happy with the approach, the agent carries it out, editing across multiple files, running commands, and iterating toward the goal rather than working one line at a time. This is the mode that puts Copilot among the capable coding agents rather than simple assistants. It handles the execution while you supervise the outcome. Agent mode is the doing that follows the deciding.

Why the two work well together

The power comes from pairing them. Plan mode lets you control the direction, and agent mode lets the tool handle the labor, so you get oversight where it matters and speed where it does not. Approving a plan and then letting the agent execute is far better than either blindly trusting it or micromanaging every line. This mirrors the structured plan-execute-review workflow that balances control and autonomy. Decide together, then let the agent build.

Start with a clear request

The process begins with describing what you want built. A clear, specific request gives Copilot the material to produce a sensible plan, while a vague one leads to a plan that misses your intent. Being precise about the goal up front shapes everything that follows, since the plan is only as good as the request behind it. Take a moment to state the outcome clearly before asking for a plan. Clarity at the start pays off through the whole task.

Review and refine the plan

When Copilot proposes a plan, read it carefully rather than approving it reflexively. If a step is wrong, missing, or in the wrong order, say so and have it revise the plan before any code is written. This review is the most valuable moment in the whole flow, because fixing a plan is far cheaper than fixing built code. Treating the plan as a draft to improve, not a decree to accept, is the right instinct. A little scrutiny here saves a lot of rework later.

Execute step by step

With a good plan approved, you let the agent implement it, ideally in manageable chunks. Executing the plan step by step, reviewing each piece as it lands, keeps you in control and makes problems easy to isolate. Rather than building the whole thing in one opaque run, you watch the project take shape one approved step at a time. This steady rhythm is what makes agent execution trustworthy. Small, confirmed steps beat one giant leap.

Review the code, not just the plan

Approving the plan does not remove the need to check the code. Even a good plan can be implemented with subtle bugs, so reviewing what the agent actually wrote, and running it, is essential before you rely on it. The plan tells you the intent, and the review confirms the execution matched. This is the accountability that applies to any agent output, however well it planned. Verify the build, not only the blueprint.

Give the agent project context

Both modes work better when the agent knows your project. Providing a context file with your conventions, in the spirit of an agents.md file, means both the plan and the execution respect how your codebase works. Without it, Copilot plans and builds in its own default style rather than yours. A little context up front improves every plan and every step that follows. Brief the agent once, and both modes benefit.

When to use plan versus straight to agent

Not every task needs a formal plan. For small, obvious changes, going straight to agent mode is faster, while for larger or trickier work, the plan step is where the value is. Matching the ceremony to the size of the task keeps you efficient, so you reserve careful planning for the tasks that reward it. This is the same measured judgment behind choosing any workflow by its stakes. Plan the big things, and just build the small ones.

Where these modes fit Copilot’s evolution

Plan mode and agent mode reflect how far Copilot has come from simple autocomplete. What began as inline suggestions, listed on the Copilot features page, has grown into a tool that can reason about a task, propose an approach, and carry it out across files. That progression mirrors the wider shift toward agents that plan and act rather than merely assist. Using these modes is really using the most capable form of the tool. They are where Copilot behaves least like autocomplete and most like a real collaborator. Learning them is learning what modern Copilot can actually do.

How Do You Install and Set Up GitHub Copilot as a VS Code Extension for AI-Assisted Coding?

GitHub Copilot is one of the simplest ways to start coding with AI, because it comes to your existing editor rather than asking you to switch. As an extension for VS Code, it adds AI autocomplete, a chat panel, and agent features without disrupting your setup. Getting it installed and configured takes only a few minutes, and it transforms how you write code. This guide walks through the whole process, from installing the extension to your first AI-assisted edit.

What GitHub Copilot is

GitHub Copilot is an AI coding assistant that lives inside your editor as an extension, with its full capabilities described on the official Copilot page. It suggests code as you type, answers questions in a chat panel, and can take on larger tasks through an agent mode. Because it runs inside an editor you already know, it has near-zero switching cost, which is its main appeal. It is the least disruptive way to bring AI into your daily coding. You keep your editor and gain an assistant.

What you need first

Before installing, you need two things: VS Code itself and a GitHub account. VS Code is the free, widely used editor that Copilot plugs into, and you download it from its official site if you do not already have it. A GitHub account is what Copilot uses to authenticate and manage your subscription or free tier. With those in place, the installation is quick. These prerequisites are the foundation the extension sits on.

Installing the extension

With VS Code open, you install Copilot from the built-in extensions marketplace. You open the extensions panel, search for GitHub Copilot, and click install, which adds the assistant to your editor in seconds. The VS Code marketplace handles the download and setup, so there is nothing to configure manually at this stage. Once installed, the extension appears in your editor ready to be connected. It is the same simple process as installing any other extension.

Signing in

After installing, you connect Copilot to your GitHub account. The extension prompts you to sign in, which opens a browser to authorize the connection, and once approved, Copilot is active in your editor. This step is what links the tool to your subscription or free access and enables the AI features. Signing in is usually a one-time step that just works. From here, the assistant is live and ready to help.

Using autocomplete

The first feature you will notice is inline autocomplete. As you type, Copilot suggests the rest of a line or a whole block in faded text, and pressing tab accepts it. This is the everyday face of the tool, quietly speeding up routine typing across your work. Getting comfortable accepting or ignoring these suggestions is the first habit to build. Autocomplete alone makes a noticeable difference in daily coding.

Using Copilot Chat

Beyond autocomplete, Copilot includes a chat panel for conversation. You can ask it to explain code, write a function, fix a bug, or answer a question, all within the editor and aware of your open files. This turns the assistant from a passive suggester into something you can actively direct. The chat is where more deliberate, larger requests happen. It is the difference between hints and a real conversation with your code.

Trying agent features

Newer versions of Copilot add agent capabilities that go beyond single suggestions. In agent mode, it can take on a whole task, planning and editing across multiple files, which moves it closer to the autonomous coding agents category. This is where Copilot handles larger pieces of work rather than line-by-line help. Exploring this mode shows you the tool’s fuller potential. It is the step from assistant toward agent.

Configuring it to your taste

A few settings make Copilot fit your workflow better. You can adjust how aggressive the autocomplete is, choose among available models in some tiers, and enable or disable features per language. Taking a moment to tune these keeps the assistance helpful rather than noisy. Copilot works well by default, but a little configuration makes it feel personal. Small adjustments improve the experience meaningfully.

Understanding the free tier

Copilot offers a genuine free tier alongside its paid plans, which is a good way to start. The free option gives you a limited number of completions and chat requests each month at no cost, enough to evaluate the tool properly, and the paid tiers lift those limits, tying into how AI coding tools are priced. Starting free lets you try it on real work before deciding to pay. There is no need to commit money to see if it fits.

Where it fits among the tools

Copilot’s approach, an add-on to your existing editor, is one of several shapes AI coding takes. It contrasts with a full AI-native editor and with a standalone terminal agent, each a different AI coding surface. Copilot suits developers who want AI woven into the editor they already love, with minimal disruption. Knowing where it sits helps you decide whether it is the right starting point for you. It is the gentle on-ramp to AI-assisted coding.

Start small and build up

Once installed, the best approach is to grow into the features gradually. Begin by letting autocomplete speed your typing, then use the chat for questions and small tasks, and eventually try agent mode for larger work as you get comfortable. There is no need to master everything at once. Building familiarity in layers makes the tool feel natural rather than overwhelming. Each feature you adopt adds to what the last one gave you.

GitHub Copilot Free Tier, Premium Requests and Usage Tracking

GitHub Copilot is a popular entry point into AI coding partly because its free tier is genuinely useful, not just a short trial. The catch is that every plan has monthly limits, and paid plans add a separate allowance of premium requests for the most advanced models. This guide explains what you get, how to track your usage and how to choose models in VS Code so you never run out unexpectedly.

What the GitHub Copilot free tier includes

Copilot’s free tier gives you a real, if limited, amount of usage each month at no cost and with no credit card required, as outlined on the Copilot plans page. It typically includes a set number of code completions and a separate allowance of chat and agent requests per month. That is enough to try the tool on real work, not just a token demo, and for learners and light users it can be all you need. It is a real on-ramp, not a teaser.

Genuinely useful free access is rare among AI coding tools. Other tools offer limited free tiers too, but Copilot’s is often singled out as one of the most practical, which is worth weighing when you compare AI coding tools. If a free, low-friction start matters to you, Copilot is a strong candidate on that basis alone.

Completions versus chat and agent requests

The free tier separates two kinds of usage. Code completions are the inline suggestions you accept as you type, while chat and agent requests are the deliberate conversations and tasks you start. They are counted separately, each with its own monthly allowance, so heavy use of one does not necessarily exhaust the other. Two meters, two kinds of work.

Why the limits exist

Each completion and each chat request consumes compute that costs money, so a free tier has to cap usage to stay sustainable. This ties into how AI coding tools are priced on consumption. Seen this way, the limits are reasonable rather than stingy. The free allowance is generous enough for meaningful use but bounded enough to stay free.

How premium requests work on paid plans

Paid tiers give you more usage, and the allowances and included models differ by plan. The key concept is premium requests. Copilot’s most capable models draw on a monthly allowance of premium requests, while simpler base-model interactions are typically unlimited on paid plans.

In practice your heaviest, most capable usage is metered and everyday help is not. Knowing which actions count against the allowance is the first step to spending it wisely, and it shapes every other habit in this guide.

Before you worry about the meter, check what your own tier includes. You cannot budget usage you do not understand, and a quick look at your plan’s limits and included models sets realistic expectations for the month. The Copilot documentation lists what each tier includes.

How to track your Copilot usage

GitHub provides a usage view in your account settings where you can see your consumption against the monthly limits for completions and requests. Copilot and GitHub also expose your premium request usage, so you can see how fast you are using your allowance and whether your habits are sustainable.

Check periodically, especially as the month progresses, rather than discovering the limit when you hit it. Awareness lets you adjust before you run out mid-project. A quick glance at the dashboard is all it takes.

What happens when you hit a limit

If you exhaust an allowance before the month resets, that feature pauses until the next cycle or until you upgrade. Completions may stop suggesting, or chat may become unavailable, depending on which limit you reached. This is not a penalty, just the boundary of the plan, and it resets on schedule.

Choose the right Copilot model per task

The biggest lever you have is matching the model to the task. Spending premium requests on trivial edits burns your allowance, while spending them on hard problems earns a return. This deliberate model selection follows the same tiering logic that applies to any AI tool.

Use base models for routine work

Much of coding is routine, and base models handle it well. Let the base model do boilerplate, simple edits and quick questions, since it is often perfectly capable and preserves your premium allowance. Defaulting to it for everyday work stretches your plan a long way.

Save premium requests for hard tasks

Complex reasoning, tricky architecture and problems where a weaker model would waste your time are exactly where an advanced model earns its cost. Escalate to a premium model deliberately, when a task proves genuinely hard. The allowance exists for these moments.

Select models in VS Code

Model selection happens right in VS Code. Copilot’s model picker in the chat or agent interface lets you choose which model handles a request, so switching between a base and a premium model is a couple of clicks. It sits alongside Copilot’s other settings, much like your broader Copilot project setup. The picker is where your usage strategy turns into action, task by task.

Stretch your allowance and avoid wasted requests

Careless habits burn requests fast. Vague prompts that need many follow-ups, regenerating instead of refining, and using a premium model where a base one would do all waste your allowance. Clear prompts, targeted edits and right-sized models conserve it. Efficiency in how you prompt directly extends your usage.

On the free tier, spend your limited chat requests on the tasks where AI helps most and do simpler work yourself. Lean on completions for routine typing, and be intentional about when you invoke the pricier agent features. This is the same efficiency mindset that helps with any coding agent on a budget, and a well-managed free plan can carry a lot of learning and light building.

When to upgrade from the free tier

A clear signal tells you when to move on. If you regularly hit the limits and the tool is genuinely saving you time, the paid tier that lifts those caps is likely worth it. Base the decision on your measured usage, whether the free version keeps blocking real work you would pay to unblock, not on marketing. Outgrowing the free tier is a good reason to upgrade, and the right one.

Upgrading does not end the need for discipline. On a paid plan the same habits apply to premium requests: default to base models, escalate deliberately and keep an eye on the meter so the allowance lasts the whole month.

Check the current terms at the source

Pricing, allowances and included models change often, so confirm the exact numbers in the official Copilot documentation rather than trusting any article. Treat a specific figure as a snapshot and verify it before you plan around it. The same habit serves you across all AI coding surfaces.

Common questions

What is plan mode in GitHub Copilot Chat?

A mode where Copilot proposes an approach, a breakdown of the steps it intends to take, before writing any code. You review and adjust the plan, catching a wrong direction while it is cheap to fix.

What is agent mode in Copilot?

The mode where Copilot executes work across multiple files, running commands and iterating toward a goal rather than suggesting one line at a time. It handles the labor while you supervise the outcome.

Why use plan mode and agent mode together?

Plan mode gives you control over the direction and agent mode handles the execution, so you get oversight where it matters and speed where it does not, rather than blindly trusting or micromanaging.

Should you review the code if you approved the plan?

Yes. A good plan can still be implemented with subtle bugs, so reviewing the actual code and running it is essential. The plan shows intent; the review confirms the execution matched it.

Do you always need to use plan mode?

No. For small, obvious changes, going straight to agent mode is faster. Reserve the formal plan step for larger or trickier work where reviewing the approach up front pays off.

What do you need to install GitHub Copilot?

VS Code and a GitHub account. VS Code is the free editor Copilot plugs into, and your GitHub account handles authentication and your subscription or free tier.

How do you install the Copilot extension?

Open VS Code, go to the extensions panel, search for GitHub Copilot, and click install. Then sign in with your GitHub account when prompted to activate the AI features.

What features does GitHub Copilot provide?

Inline autocomplete that suggests code as you type, a chat panel for questions and tasks aware of your files, and newer agent features that can plan and edit across multiple files.




Related Articles

If you enjoyed reading this, then please explore our other articles below:

More Articles

If you enjoyed reading this, then please explore our other articles below: