Full curriculum reference. For persona-based navigation and shortcut paths, see LEARNING_PATH.md.
This curriculum teaches GitHub Copilot Pro+ from first use to full professional mastery. It is structured as a strict linear progression: each level builds on the previous one. It is written for an experienced developer who has never used Copilot. Complete the modules in order, run the guided prompt examples, and check off each module summary's Self-Check before advancing. The hands-on project is the capstone, after Module 11.
| Level | Modules | Hands-on | Est. time | Graduates can… |
|---|---|---|---|---|
| 1 — Beginner | 01–03 | Guided examples in-module | ~5 hrs | Use all modes correctly, configure a project, make cost-aware decisions |
| 2 — Intermediate | 04–05 | Guided examples in-module | ~3.5 hrs | Write structured prompts for any scenario, maintain persistent custom instructions |
| 3 — Advanced | 06–07 | Guided examples in-module | ~4.5 hrs | Operate role-specialized agents, run coordinated multi-agent workflows |
| 4 — Expert | 08–11 + Capstone | Guided examples + Capstone (8 deliverables) | ~9 hrs (+ ~2 hrs capstone) | Apply all features, govern AI output, integrate platform/github.com surfaces, produce 8 committed deliverables spanning the full course |
Entry gate: A GitHub account with an active Copilot subscription. VS Code installed. No prior Copilot experience required.
Exit outcomes: Copilot is installed, configured, and working. You can select the right mode for any task, write a project-level instruction file, and evaluate AI-generated code critically before committing it.
Estimated time: ~5 hours
Goal: Install and verify GitHub Copilot Pro+, understand all five interaction modes, and build the habit of critical AI output evaluation.
Prerequisite: Active Copilot subscription. VS Code installed.
| Topic | Key skills |
|---|---|
| Installation and authentication | Activate Copilot Pro+ in VS Code, verify status bar |
| Copilot modes overview | Inline completion, Ask, Plan, Agent, Inline Chat — what each does |
| When to use each mode | Decision criteria based on task type and complexity |
| Evaluating AI output critically | Four-question review gate; never commit unreviewed AI code |
| Key VS Code settings | Essential Copilot settings to configure immediately |
Outcome: Working Copilot setup verified across all major modes through six guided examples
Goal: Configure VS Code and the project for maximum Copilot effectiveness.
Prerequisite: Module 01 complete.
| Topic | Key skills |
|---|---|
| VS Code workspace settings | .vscode/settings.json for Copilot and editor quality |
| Project-level Copilot instructions | Write .github/copilot-instructions.md with specific, verifiable rules |
| Project structure for AI context | File organization, naming, and documentation that strengthen Copilot signals |
| Linting and formatting | Configure tools that give Copilot clean code to learn from |
| Task automation | VS Code tasks for build, test, and lint; agent-accessible via terminal |
Outcome: .vscode/ config files, .github/copilot-instructions.md, linter, and task runner on your own project — built through the guided config examples
Goal: Make cost-aware decisions about modes, models, and context from the start.
Prerequisite: Modules 01 and 02 complete.
| Topic | Key skills |
|---|---|
| Credit-free vs. credit-consuming usage | Which actions consume AI Credits and which never do |
| Model selection framework | When to pin a frontier model — and when auto model selection is enough |
| Context window discipline | Keep context minimal, scoped, and unambiguous |
| Compact prompt construction | Goal + constraints + output format in a single turn |
| Mode/model decision framework | Reference table by task type |
Outcome: Personal mode/model quick reference, adopted from the module summary and the worked token-audit example
Entry gate: Level 1 complete. Copilot is running in a configured project. You have a mode/model cheat sheet.
Exit outcomes: You write structured, reliable prompts for any coding scenario without follow-ups. You maintain persistent custom instructions at global, project, and path scope. You know the
prompts/library and can extend it — your own entries are committed during the capstone.Estimated time: ~3.5 hours
Goal: Write structured, reliable prompts for every common coding scenario.
Prerequisite: Level 1 complete. Module 03 teaches compact prompts — this module builds on that foundation with full scenario coverage.
| Topic | Key skills |
|---|---|
| Prompt architecture | Goal, constraints, output format — the three required components |
| Prompting for code generation | Role, task, format, constraints pattern |
| Prompting for refactoring | Specify what changes; specify what must not change |
| Prompting for debugging | Describe symptoms and context, not just the error message |
| Prompting for tests | Coverage intent, edge cases, framework, assertion style |
| Prompting for documentation | Audience, format, depth, tone |
| Prompting for security review | OWASP scope, threat model, language and framework context |
| Prompt anti-patterns | What causes hallucinations, scope creep, and repetition |
Outcome: The 4-component structure applied across all 8 scenarios; own prompt entries committed during the capstone (Deliverable 4)
Goal: Encode project conventions into stable, reusable Copilot guidance that applies automatically.
Prerequisite: Module 04 complete. Writing effective instructions requires the same structural thinking as prompt engineering.
| Topic | Key skills |
|---|---|
| Global instructions | User-level configuration that applies across all projects |
| Repository-wide instructions | .github/copilot-instructions.md at project scope |
| Path-specific instructions | .github/instructions/[name].instructions.md with applyTo frontmatter |
Cross-tool AGENTS.md standard |
Root + nested files, coexistence with Copilot instructions |
| Instruction design principles | Specific, bounded, imperative, non-contradictory |
| Testing instructions | Verify Copilot reads and applies them; fix when they are ignored |
| Maintenance | Version, audit, and update instructions as the codebase evolves |
Outcome: Instruction design mastered through worked examples (the instructions/ folder holds ready references); your own .github/copilot-instructions.md + path-specific file committed during the capstone (Deliverable 1)
Entry gate: Level 2 complete. Structured prompting is a consistent habit. Custom instructions are in place on at least one real project.
Exit outcomes: You can define a role-specialized agent persona with tool permissions and handoff protocol. You can decompose a complex multi-step task into a bounded agent workflow, execute it, and know when to stop. You have studied the 10-role reference library in agents/.
Estimated time: ~4.5 hours
Goal: Understand and operate 10 specialized agent personas with clear responsibilities, tool permissions, and handoff protocols — shipped as a ready reference library in agents/.
Prerequisite: Level 2 complete. Agents are persistent custom instructions combined with tool access — both concepts must be solid before agent work.
10 agent personas:
| Agent | Core responsibility |
|---|---|
| Planner / Analyst | Decompose work, identify risks, define tasks |
| Solution Architect | Design system structure, define component boundaries |
| Implementer / Developer | Write and integrate code to spec |
| Refactoring Specialist | Improve internal structure without changing behavior |
| Code Reviewer | Enforce standards, catch issues before merge |
| Security Reviewer | Identify vulnerabilities, apply OWASP patterns |
| Test Engineer | Design and write tests for correctness and coverage |
| Documentation Writer | Produce clear, accurate, audience-aware documentation |
| Performance Optimizer | Profile and improve speed and resource usage |
| DevOps / Release Assistant | CI/CD, deployment, and infrastructure tasks |
Topics covered:
| Topic | Key skills |
|---|---|
| Agent anatomy | Role, scope, tool permissions, exit conditions, handoff protocol |
| Tool permission model | Allow / conditional / deny — and why each boundary exists |
| Running a single-agent session | Set scope, execute, evaluate output, know when to stop |
| Agent session prompts | How to open and close an agent session cleanly |
| Roles catalogue | 10 specialized roles — scope, core responsibility, and mutual exclusions |
| Handoff protocol | 3-part structure; close one role cleanly; open the next without context leakage |
Outcome: The 10-role reference library in agents/ studied and understood; ≥3 project-scoped definitions authored during the capstone (Deliverable 3)
Goal: Orchestrate multiple agents on complex tasks without context pollution, duplicate work, or runaway sessions.
Prerequisite: Module 06 complete. The 10-role reference library must be understood before workflows can be designed.
| Topic | Key skills |
|---|---|
| Task decomposition | Break problems into bounded, handoff-ready chunks |
| Workflow 1 — Feature delivery | Planner → Architect → Implementer → Code Reviewer |
| Workflow 2 — Bug investigation | Analyst → Implementer → Test Engineer → Code Reviewer |
| Workflow 3 — Refactor and validate | Refactoring Specialist → Test Engineer → Code Reviewer |
| Handoff protocols | What to pass between agents, how to summarize, when to stop |
| Context hygiene | Prevent context pollution and duplicate work across sessions |
Outcome: The complete Feature Delivery workflow example internalized; your own workflow file committed during the capstone (Deliverable 5)
Level 3 completion: → checklists/advanced-completion.md
Entry gate: Level 3 complete. You have run at least one multi-agent workflow end-to-end.
Exit outcomes: You apply all Copilot features with deliberate intent. You can audit a repository for AI-friendliness and fix what you find. You have a written, actionable 90-day personal or team adoption plan. The capstone is complete.
Estimated time: ~9 hours
Goal: Leverage Plan mode, AI-assisted review, terminal integration, and CI/CD connections professionally.
Prerequisite: Level 3 complete.
| Topic | Key skills |
|---|---|
| Plan mode | Use Copilot to design a solution before writing a single line |
| Agent mode autonomy | Autopilot defaults, custom agents (*.agent.md), bounded-session discipline |
| AI-assisted code review | Systematic review workflow with Copilot in the loop |
| Terminal and CLI integration | Copilot in the terminal; command explanations and suggestions |
| Test runner integration | Copilot with pytest, Jest, xUnit, and equivalent frameworks |
| CI/CD integration | Copilot in pipelines, PR guidance, automated code scanning |
| MCP integration | Model Context Protocol servers, registries, and allowlist governance |
| Large codebase strategies | Scope context effectively in repositories with hundreds of files |
| Secure usage patterns | Secrets hygiene, sensitive code handling, confidentiality boundaries |
Outcome: Plan mode, AI review, terminal gates, MCP, and secure usage mastered through eight guided examples — the longest module in the course (~3.5 hrs)
Goal: Keep repositories AI-friendly, clearly structured, and governed for the long term.
Prerequisite: Module 08 complete.
| Topic | Key skills |
|---|---|
| AI-friendly repository design | Eliminate noise, ambiguity, and mixed-concern files |
| Documentation quality | READMEs and inline docs that serve both humans and AI context |
| Governance of AI-generated code | Review protocols, ownership, and traceability standards |
| Naming and structure conventions | Patterns that maximize AI context signal across the codebase |
| Pre-merge validation | The minimum human check before every AI-assisted commit |
Outcome: The 6-property audit and 5-gate pre-merge protocol mastered through worked examples; your own CONVENTIONS.md and validation report produced during the capstone (Deliverables 2, 6)
Goal: Plan and execute a personal or team Copilot adoption across 7, 30, 60, and 90 days.
Prerequisite: Modules 08 and 09 complete. This is a synthesis module — it is only meaningful with the full skill set.
| Timeframe | Focus | Gate deliverable |
|---|---|---|
| 7 days | Setup, verification, first real usage | Level 1 complete; cheat sheet in use |
| 30 days | Prompt discipline, custom instructions live | Personal prompt library + instructions/ folder |
| 60 days | Agent workflows, advanced features in production | Reference library adapted + first multi-agent run |
| 90 days | Full mastery, governance, team rollout ready | Capstone complete; adoption plan written and shared |
Outcome: A written 7/30/60/90-day adoption roadmap — committed as capstone/roadmap.md (Deliverable 7)
Goal: Use Copilot beyond VS Code — coding agent (issue → PR), Copilot in github.com (PR summaries, review, issue triage), and the gh copilot CLI. Choose the right surface per task.
Prerequisite: Module 10 complete.
| Topic | Key skills |
|---|---|
| Copilot coding agent | Scope an issue for delegation; review the resulting PR like an external contribution |
| Agent HQ and agents panel | Mission Control on github.com; Claude/Codex as agent providers |
| Copilot in github.com | PR summaries with all 4 properties; agentic Copilot code review triage; issue summarization |
| Copilot in the terminal | Copilot CLI (agentic, GA 2026) plus gh copilot suggest/explain; the M08 4-question gate |
| Copilot desktop app | Standalone app on all plans; BYOK (bring-your-own-key) |
| Surface decision matrix | VS Code / github.com / CLI / desktop app / coding agent — pick the right one |
copilot-setup-steps.yml |
Configuring the coding-agent sandbox |
Outcome: The four platform surfaces understood through guided walkthroughs; the hands-on platform artifact is Capstone Deliverable 8 — capstone/platform-artifact.md
01-foundations
│
02-configuration
│
03-token-optimization
│
04-prompt-engineering
│
05-custom-instructions
│
06-agents
│
07-multi-agent-workflows
│
08-advanced-features
│
09-repository-quality
│
10-adoption-roadmap
│
11-platform-integration
│
Capstone
Dependencies are strict and linear. No module can be skipped. Each module's guided examples build on the skills from all previous modules.
For persona-based navigation and shortcut paths, see LEARNING_PATH.md.