The GitHub Copilot course

This is a hands-on course, not a reference. You spend it inside VS Code with GitHub Copilot, following one real piece of work across the chapters: an approval workflow for an order-management service - a feature that turns out to need a change to a shared library a dozen other services depend on before you can build it at all. The course teaches the moves around that work rather than a line-by-line build: the library change is planned, reviewed, and audited across the modes, custom agents, and permissions chapters, and the service side is handed to Agent in Agent - hand off the whole task. Every lesson takes a problem you will really hit (the agent writes code in a style your team rejects, a “small” change ripples across twelve consumers, you need work to keep moving while you are in a meeting) and shows the exact Copilot move that fixes it.

The course is IDE-first. The first-class surface is VS Code + GitHub Copilot. JetBrains gets a parity chapter near the end; the Copilot CLI is a footnote, not the spine. If your shop has standardized on Copilot in VS Code, this course fits.

If you want the spec-level “what is this primitive” view, that is Foundations. This course is the other half: the muscle memory. And if you have done the Claude Code or Codex course, a bridge is waiting in the Rules chapter - the AGENTS.md you wrote there is read natively here.

The framework: capability, context, control, cost

Four principles run through every chapter, and they are worth naming up front because they explain every feature this course covers:

• Capability - what the agent can figure out and accomplish with its model and tools. Model choice and delegation live here.
• Context - what information is available when the agent decides, and how fresh and trustworthy it is. Rules files and skills are context moves, and trusting or scoping an MCP connection is control.
• Control - what guides execution, enforces boundaries, or lets you intervene. Roles, permission levels, and the review habit live here.
• Cost - what completing the task consumes: money and credits, elapsed time, attention, and rework.

Context is the organizing theme: most of what you will build in this course is ways to get what your team knows into the agent’s context, and ways to check what came back. The other three frame the decisions around it - how much the agent can do, what stops it, and what it spends. No lesson needs all four principles; the framework is a lens, not a template.

Before you start

• VS Code installed (latest stable)
• A GitHub Copilot plan (Free, Pro, Pro+, or Max for individuals; Business or Enterprise for organizations - plan names as of October 2026)
• A GitHub account with permission to clone and create branches in two repositories, or one repository with two services or packages you can use as substitutes
• Basic TypeScript/JavaScript familiarity
• Git fundamentals (clone, branch, commit, diff)

Verification scope

Product facts in this course - settings, fields, menus, and plan names - were checked against the GitHub and VS Code documentation during the September 2026 rewrite: a primary-source audit on 2026-09-19 and a re-verification of the linked pages on 2026-09-20. The permissions, prompt files, custom agents, custom instructions, and plan-name facts were re-checked in October 2026. Volatile facts carry an “as of September 2026” date or link the vendor page they were checked against. No live Copilot runs were captured for this edition, so every shown response is illustrative, and the runnable steps are yours to execute.

All chapters live

The full curriculum is written start to finish. Read it in order to build up from zero, or jump straight to the chapter you need. Lessons may still get sharpened over time.

Lab setup and substitutions

The course uses shared-lib, orders-service, and twelve downstream consumers as a running scenario; those repositories are not bundled with this site. Use equivalent repositories from your team, or follow the substitutions below if you are learning without an inherited codebase:

• Use any small TypeScript/JavaScript service as orders-service.
• Use a local package or second repository as shared-lib; a monorepo with two packages works too.
• For the consumer exercise, use however many packages or services you have and report the actual count when you check for breakage. A single repository can serve as a dry run.
• For the MCP chapter, use a server you are authorized to access. If you do not have one, skip the live connection and use a checked-in consumers.json file as the registry response; the trust and scoping decisions still apply.

The examples are intentionally small enough to adapt. Do not paste internal URLs, credentials, or proprietary source into a public issue or MCP configuration.

The curriculum

Twelve chapters, in reading order. Each carries the same two-repo scenario one stretch further - start at the top, or pick the problem in front of you.

1 · Getting started Install Copilot in VS Code, sign in, learn the two ways in - ghost-text completions and the Chat view - and ship a first small reviewed change to a service you have just inherited.

2 · The modes Copilot's signature shape: Ask, Plan, and Agent in the agents dropdown. Understand inherited code, scope an edit to named files, hand off a whole task, and review a plan before a line is written - picking the role to match what is at stake.

3 · Rules Stop hand-feeding Copilot your conventions. copilot-instructions.md, path-specific applyTo rules, the hierarchy - and the bridge: the AGENTS.md / CLAUDE.md you wrote for another tool is read natively here.

4 · Prompt files Codify a repeated multi-step task as a .prompt.md you invoke with a slash command - and learn where the invoked-vs-always-on line falls. Deprecated in favor of Agent Skills as of September 2026; covered as both mechanism and migration source.

5 · Custom agents & subagents The careful work begins. Build a reusable reviewer agent for the shared library, fan subagents out to check the consumers for breakage, and chain stages with handoffs.

6 · Skills Package a team procedure as a portable SKILL.md the agent invokes on its own when the task matches - a shared format whose support spans tools and surfaces.

7 · Extending: MCP Wire an MCP server so Copilot can reach an internal system - a registry or issue tracker - instead of you pasting the answer. Connect, trust, and scope it to the agent that needs it.

8 · Permissions & autonomy The dial on the latitude judgment: Manual permissions, Assisted permissions, and Allow all. Tight on the shared library, loose on your own app - same engineer, opposite settings.

9 · Models & credits The other dial - how much the agent thinks. The per-request picker, Auto selection, and using current AI-credit or legacy request budgets deliberately.

10 · Automation: the cloud agent Copilot leaves the editor. Assign follow-up issues to the async cloud coding agent, review the pull requests it opens, and customize the environment it runs in.

11 · Beyond VS Code The same two-repo work in a JetBrains IDE, support called out feature by feature - plus the Copilot CLI's terminal surface. Your rules and skills come along.

12 · Daily workflow A day moving between careful-library mode and fast-app mode - then a look back across the whole arc, and where to go next.

How to read it

Each chapter carries one running scenario - two repos, shared-lib and orders-service, that you have just inherited on a new team - and the lessons build on each other: each one picks up a problem, adds a move to your repertoire, and hands off to the next.

 shared-lib (threshold check + audit helpers live here)
      │  consumed by
      ▼
 12 consumers ◀────────── orders-service, one of them,
                          building the approval workflow

The shape of the scenario is the shape of the course: a change that looks local to orders-service turns out to need a change in shared-lib first - and a shared library change is a different kind of careful than an app change.

So you get the most out of a chapter by reading it in order. But each lesson also stands on its own if you drop in from a search with one specific problem in front of you - every page restates the scenario facts it needs.

What you will not find is a fixed template stamped onto every lesson. Some need a long worked example, some a single setting and a warning, some a digression into why Copilot behaves the way it does. The shape follows the content, the way a good book varies its chapters.