GitHub Copilot · Getting Started

Getting Started

Understand what Copilot is made of, pick the right plan, install it, and get fluent with the daily drivers — completions and chat.

What’s actually in “GitHub Copilot”

☺ Like you’re 10: “Copilot” isn’t one toy — it’s a whole LEGO set with lots of pieces. Some pieces help you finish a sentence, some chat with you, and some can go build things on their own.

People say “Copilot” to mean one thing, but it’s a suite. Here’s the map (we go deep on each across the course):

Plans, models, and “premium requests”

☺ Like you’re 10: Think of an all-you-can-eat buffet: the everyday food is unlimited, but the fancy dishes come with a monthly ticket. Copilot lets you use its normal helper as much as you want, but the extra-powerful stuff uses up special tickets called “premium requests.”

Copilot’s billing has two layers, and understanding them saves money and frustration:

1. A base model with effectively unlimited use. Every paid tier lets you use a capable default model as much as you want for everyday completion and chat.
2. A monthly budget of premium requests for frontier models. Reaching for the most powerful models — or running agentic, multi-step work — draws from a monthly allowance. Run out, and additional premium requests are billed per-request (a few cents each at time of writing).

Why this matters: agent mode and the cloud agent iterate, and each iteration can be a premium request. A single “build this feature” run can quietly consume several. That’s not a reason to avoid agents — it’s a reason to scope tasks well.

The tiers, roughly (verify current pricing in the docs): Free — limited completions and chat, fine for this topic. Pro — unlocks agent mode, the cloud agent, a premium-request budget, and model choice. Pro+ — heavier budget plus extras like the natural-language app builder. Business / Enterprise — team features: policy management, audit logs, IP indemnity (Enterprise), org-wide instructions, a single control plane. Max — for sustained, high-volume agent workflows, with a large credit allowance.

Models

☺ Like you’re 10: A model is like the brain Copilot borrows to think. Copilot keeps several brains on a shelf — some are quick, some are extra clever — and you can pick the right one for the job, or just say “you choose.”

Copilot is multi-model. You’ll see a model picker in chat, in agent mode, and in the cloud agent’s Agents panel — typically GPT-class, Claude-class, and Gemini-class models, with an Auto setting that lets GitHub choose. The practical rule: leave it on Auto until you have a reason not to; switch to a stronger model for hard, multi-file reasoning and a faster one for routine edits. For a full guide to switching models, bringing your own, and running a local LLM (including inside a Windows 11 / VirtualBox VM), see Models & Local LLMs.

Install it

In VS Code (recommended start)

1. Install the GitHub Copilot extension from the Marketplace (it bundles Copilot Chat).
2. Sign in with your GitHub account when prompted.
3. Open any code file and start typing a function — grey suggestion text should appear. Tab accepts, Esc dismisses.
4. Open the Chat panel with Ctrl+Alt+I (Windows/Linux) or ⌃⌘I (Mac).

Agent mode is GA and works out of the box once the extension is installed — no flags. It also works in Visual Studio, JetBrains IDEs, Eclipse, and Xcode.

In your terminal (Copilot CLI)

The CLI is a separate install (npm, Homebrew, or WinGet). Once installed you run it from your shell and chat with Copilot about the current repo — it can plan, edit files, run commands, and open pull requests without you leaving the terminal. We use it properly in the Building and Multi-Agent topics.

---

Everyday Copilot: completions & chat

☺ Like you’re 10: These are the two things you’ll use every single day — like a bike’s pedals and handlebars. One quietly finishes your code as you type, and the other lets you ask Copilot questions in plain words.

Now the daily-driver features and the prompting habits that make all of it better.

Completions and Next Edit Suggestions

☺ Like you’re 10: It’s the same as when your phone guesses the next word while you text — Copilot guesses your next bit of code. The “Next Edit” part is even smarter: after you fix one spot, it points to the next spot you probably need to fix too.

Inline completions predict the next chunk of code from surrounding context (the open file, related open files, the symbols in your project). The key skill is context shaping: write a clear comment before the code you want, keep relevant files open in nearby tabs, and name things descriptively — Copilot mirrors your naming and intent.

Next Edit Suggestions (NES) is the evolution. Instead of only completing at your cursor, it predicts where in the file your next edit will be. Rename a variable, and NES points you to the next place that needs the same change — you tab through a sequence of related edits rather than typing each one.

The three chat modes: Ask, Edit, Agent

☺ Like you’re 10: Picture three helpers with different rules. “Ask” only talks and never touches your stuff, “Edit” changes only the pages you hand it, and “Agent” is trusted to go do the whole chore by itself.

Choosing the right mode is half the battle.

Ask mode — conversational Q&A. It answers and suggests but doesn’t touch your files. Use it to understand unfamiliar code, scope a problem before acting, or learn a concept.

Edit mode — you point Copilot at specific files and describe a change; it proposes a diff across the files you named, and you accept or reject hunks. Surgical and predictable; use it when you know exactly what changes and where.

Agent mode — you describe a task, not a file edit, and Copilot decides which files to touch, makes the edits, runs commands, reads the output, and iterates until done. (Its own topic, next.)

One task, three modes. Take “add input validation to the signup form.” The mode decides who’s driving:

Same request, escalating autonomy: start in Ask when unsure, drop to Edit for a known change, reach for Agent when the work spans files.

Context tools: telling Copilot what to look at

☺ Like you’re 10: Before a helpful librarian can find your answer, you have to point at the right shelf. These little tags are how you say “look at THIS file” or “search the whole project” so Copilot isn’t just guessing.

Chat is only as good as the context you give it. The main levers: #file (pull in a specific file), @workspace (reason over the whole project via semantic search — in 2026 it can find your auth middleware from a description of a “login bug” even if no file says “login”), #selection (focus on highlighted code), and slash commands like /explain, /fix, /tests, /doc.

Prompting fundamentals

☺ Like you’re 10: A prompt is just the instructions you give, like a recipe. The clearer the recipe — how many servings, which ingredients, one step at a time — the better the dish Copilot cooks up.

The same principles carry through the whole course, whether you’re in chat or driving an autonomous agent:

1. State the goal and the constraints. “Add pagination to /users, 25 per page, keep the existing response shape” beats “add pagination.”
2. Give relevant context, not all context. Attach the two files that matter, not the whole repo. Precision beats volume.
3. Ask for a plan first on anything non-trivial. You catch wrong directions cheaply.
4. Reference patterns you already use. “Follow the existing pattern in userController.js” is how you get code that fits your codebase.
5. Iterate in small steps. One coherent change per request. Giant prompts produce giant, hard-to-review diffs.

Check your answers

1. Three surfaces: Copilot is a suite that runs across many surfaces — for example code completions in your IDE, Copilot Chat (IDE, GitHub.com, and mobile), Agent mode in your editor, the cloud agent in a GitHub Actions sandbox, and Copilot CLI in your terminal. Any three of these count.
2. Base model vs. premium request: Every paid tier gives you a capable base model with effectively unlimited use for everyday completions and chat. A premium request draws from a monthly budget spent on frontier models or agentic, multi-step work; once that allowance runs out, extra premium requests are billed per request (a few cents each).
3. Edit mode over Agent mode: Use Edit mode when you already know exactly what needs to change and where — you point Copilot at specific files, it proposes a diff, and you accept or reject hunks. It’s surgical and predictable, whereas Agent mode is for describing a whole task and letting Copilot decide which files to touch.
4. Ask mode first: Ask mode is read-only, so you can scope the problem and understand unfamiliar code without changing anything on disk. Starting in Ask lets you catch wrong directions cheaply before switching to Agent to execute, which also keeps your premium-request budget intact.