Software engineer learning path

For

Developers writing application code who want Copilot to be useful on a real codebase rather than a demo.

Lessons

20 existing Academy lessons

Reading time

about 5½ hours

Prerequisites

Comfortable with your editor and at least one language.

1. Stage 1Work the editor properly

   Agent mode and a coherent idea-to-pull-request loop are what separate occasional use from a workflow.

   • ✓GitHub Copilot for IDEs: Complete Guide— completed

     Every Copilot feature compared across VS Code, Visual Studio, JetBrains, Eclipse and Xcode, with the differences that should actually influence which editor you use.

   • ✓GitHub Copilot with Visual Studio Code— completed

     The reference implementation: chat participants and variables, edit mode, custom agents, prompt files, MCP and the features that exist only here.

   • ✓GitHub Copilot Agent Mode in VS Code— completed

     The in-editor agent loop in depth: planning, tool approval, checkpoints, custom agents and MCP — with a REST API built end to end.

   • ✓GitHub Copilot IDE Workflow: From Idea to Pull Request— completed

     The capstone: sixteen steps from a one-line requirement to a reviewed pull request, marking exactly which steps are Copilot's and which are yours.

2. Stage 2Know how it behaves in your language

   Copilot's usefulness varies less by language than by how much the language lets it check itself. Read the hub, then your own.

   • ✓GitHub Copilot for Programming: Language Guide— completed

     How Copilot behaves differently across twelve languages — what type systems, package ecosystems and test tooling change about the review you owe generated code.

   • ✓GitHub Copilot for TypeScript— completed

     What types change: better suggestions in, a compiler that rejects wrong output, and the assertions and `any` casts Copilot reaches for when it cannot satisfy them.

   • ✓GitHub Copilot for Python— completed

     Type hints as context, virtual environments, pytest generation, Ruff and mypy as the review layer — and the mutable-default and unsafe-subprocess patterns to watch for.

3. Stage 3Control the output

   Context and instructions are the levers that change results without changing your plan.

   • ✓How to Write Better GitHub Copilot Prompts— completed

     Goal, context, constraints, output, validation — plus the five anti-patterns that produce confidently wrong answers.

   • ✓GitHub Copilot Context: How to Give Copilot Better Information— completed

     Relevant context beats maximum context. What Copilot can see, what it cannot, and what should never go into a prompt.

   • ✓GitHub Copilot Custom Instructions Explained— completed

     Six instruction mechanisms, which of the nine Copilot surfaces support each, and why 'custom instructions work everywhere' is wrong in both directions.

   • ✓How to Create a copilot-instructions.md File— completed

     A step-by-step build of the one instruction file every Copilot surface reads, and the difference between a durable rule and today's task.

   • ✓GitHub Copilot Prompt Files Tutorial— completed

     Reusable invoked tasks at .github/prompts/*.prompt.md — the documented frontmatter, and the three IDEs where they actually work.

4. Stage 4Choose a model deliberately

   Model choice is a cost-and-latency decision bounded by how hard the output is to verify — not a race to the largest option.

   • ✓GitHub Copilot Models Explained— completed

     Why Copilot offers dozens of models, what actually differs between them, and how auto selection, plans and retirement interact.

   • ✓How to Choose the Best Model in GitHub Copilot— completed

     A decision framework based on the task in front of you, because the honest answer to 'which model is best' depends on what you are doing.

5. Stage 5Delegate whole changes

   This is where the time actually goes back. Agents first, then MCP for giving them tools.

   • ✓GitHub Copilot Agents: Complete Guide— completed

     Five agent surfaces with genuinely different capabilities, the autonomy scale that makes them comparable, and why an agent that can act needs a different trust model.

   • ✓GitHub Copilot Cloud Agent vs Agent Mode— completed

     Resolves the terminology confusion between agent mode, the cloud agent (formerly the coding agent) and third-party agents, with a decision table.

   • ✓GitHub Copilot Coding Agent Tutorial— completed

     Delegating a real task end to end: writing an issue an agent can act on, what it does with it, and reviewing the pull request that comes back.

   • ✓GitHub Copilot MCP: Complete Guide— completed

     Model Context Protocol as Copilot implements it: clients, servers, tools versus resources, transports, authentication, and the security model that matters most.

   • ✓Connect GitHub Copilot to MCP Servers— completed

     Configuration per client, and why a VS Code mcp.json copied into Copilot CLI fails silently rather than reporting an error.

6. Stage 6Have it reviewed

   Generated code raises the volume of review, so knowing what automated review is good at is now part of the job.

   • ✓GitHub Copilot Code Review: Complete Guide— completed

     Requesting a review, the effort levels and what they cost, every documented customization mechanism, and the four things GitHub says the review does not do.

Reading time is computed from the prose of the lessons listed above at 200 words per minute, excluding code blocks. It is an estimate of reading, not of the practice that makes any of it stick.