Module 10 — Meet GitHub Copilot

Goal: Understand what GitHub Copilot is, its three modes (completions, chat, agent), where it runs, and the mental model you need before we dive into its internals (skills, context, memory) in the next modules.

Freshness note: Copilot evolves quickly. Everything in Part C reflects how Copilot works as of mid-2026. The official docs at docs.github.com/copilot are the source of truth. Source links are at the bottom of each Copilot module.

10.1 What Copilot is

GitHub Copilot is an AI pair programmer. Under the hood it’s a large language model (LLM) — a system trained to predict and generate text — wired into your coding tools and fed relevant pieces of your code as context. You describe what you want (in code or plain English) and Copilot suggests code, explains things, fixes bugs, writes tests, reviews PRs, and increasingly performs multi-step tasks on its own.

The crucial thing to internalize early: Copilot is only as good as the context it’s given. It cannot see your whole project at once (Module 13 explains why), so most of “mastering Copilot” is really about controlling what it sees — which is exactly what instructions (Module 11), skills (Module 12), and memory (Module 13) are for.

10.2 The three modes

Copilot shows up in three distinct ways. Knowing which mode you’re in matters because each uses context differently.

1. Code completions (the original)

As you type, Copilot suggests the rest of the line or whole blocks in grey “ghost text.” Press Tab to accept. It draws context from the file you’re in and other open/related files. Best for: writing code fast, boilerplate, repetitive patterns.

2. Chat

A conversational panel (in your IDE, on github.com, in the terminal CLI, in mobile). You ask questions — “explain this function,” “why is this test failing?”, “write unit tests for this file.” You can point it at specific context (a file, a selection, the whole repo). Best for: understanding, debugging, and generating code with a back-and-forth.

3. Agent mode

This is the big one. In agent mode, Copilot doesn’t just answer — it acts. Give it a goal (“add pagination to the users endpoint and update the tests”), and it plans, edits multiple files, runs commands, checks the results, and iterates until done. Agent mode is where skills, custom instructions, context management, and memory all come together — which is why the next three modules focus on it.

There’s also the Copilot coding agent (cloud-based): you assign it a GitHub issue and it works autonomously in the background, opening a pull request you then review — like delegating a task to a junior teammate.

10.3 Where Copilot runs

Copilot is available across many surfaces, and customization files (Modules 11–12) are designed to apply across them:

VS Code / Visual Studio / JetBrains / Xcode / Eclipse — IDE extensions for completions, chat, and agent mode.
github.com — chat about your repos right in the browser.
Copilot CLI — a terminal agent (copilot) for command-line workflows.
GitHub Mobile — chat on the go.
Pull request integration — automatic PR summaries and AI code review.

10.4 Plans (very brief)

Copilot comes in tiers (Free, Pro, Pro+, Business, Enterprise) that differ in usage limits, available models, and admin/security features. The free tier gives a limited monthly amount of completions and chat. Specifics and pricing change often — check the current Copilot plans page rather than trusting any number you read in a tutorial.

10.5 The mental model for Part C

Hold these four ideas; the next modules expand each one:

Context window (Module 13): Copilot has a limited “working memory” measured in tokens. Everything it considers — your prompt, code, instructions, skills — competes for that finite space.
Custom instructions (Module 11): persistent text that’s automatically prepended to your requests so you don’t repeat yourself (“use TypeScript,” “we use tabs,” “always write tests”).
Skills (Module 12): packaged, on-demand expertise that Copilot pulls in only when relevant, so it doesn’t waste context. This is where “how does Copilot decide which skill to load” gets answered.
Memory (Module 13): notes Copilot keeps between sessions so it remembers project-specific facts it learned earlier.

Together these are the levers you pull to make Copilot reliably excellent instead of randomly hit-or-miss.

10.6 A quick safety note

Copilot generates plausible code, not guaranteed-correct code. Always review its output, run your tests, and never blindly accept changes — especially in agent mode where it edits many files at once. The Git skills from Part A (diffs, branches, reverting, the reflog) are exactly what make it safe to let Copilot work boldly: you can always inspect and undo.

Try it yourself

Open a file in your IDE with Copilot enabled and start typing a function signature — watch the ghost-text completion appear, and press Tab to accept.
Open Copilot Chat and ask it to explain a file you don’t understand.
If you have agent mode, give it a tiny, well-scoped task (like “add a docstring to every function in this file”) and watch it work — then review the diff before accepting.

Key takeaways

Copilot is an LLM wired into your tools; its quality depends entirely on the context it’s given.
Three modes: completions (ghost text), chat (Q&A), agent (autonomous multi-step actions).
It runs in IDEs, on github.com, in the CLI, on mobile, and in PRs.
The four levers you’ll master next: context window, custom instructions, skills, and memory.

Sources

Next: Module 11 — Customizing Copilot: Instructions & Prompt Files