Microsoft GitHub Copilot

Plausible code is not correct code. You build the habit of checking what Copilot writes, using tests, review and static analysis, and you learn the warning signs of a suggestion that looks right but is not.

• Reading generated code critically
• Checking behavior with tests
• Static analysis and linters as a second opinion
• Spotting insecure or deprecated patterns
• Reviewing AI-written pull requests

You build A checklist and a set of tests that catch faults in three flawed Copilot suggestions.

Knowing the path of a prompt explains both its power and its limits. You trace how context is gathered, filtered and sent to a model, how the answer returns, and why context size and model limits shape the result.

• Gathering context from the editor
• Prompt construction and the proxy
• Filters on the way in and on the way out
• The suggestion lifecycle from request to acceptance
• Context windows and other model limits
• What is and is not retained

You build A labeled diagram of a suggestion’s journey, with the filters and limits marked.

Better input gives better output. You write zero-shot and few-shot prompts, control what context Copilot sees, and learn why the same request works in one file and fails in another.

• Zero-shot and few-shot prompts
• How Copilot decides what context to use
• Open files, selections and explicit references
• Writing prompts that state intent and constraints
• Iterating on a prompt that misses
• Comments and names as implicit prompts

You build A prompt set for five coding tasks, with notes on the context each one needs.

The editor is where most of the work happens. You use inline completions, chat, slash commands and multi-file edits, and learn when to type, when to ask and when to turn the assistant off.

• Inline completions and how to steer them
• Chat in the side panel and inline chat
• Slash commands and chat participants
• Edits across several files
• Choosing a model for a task
• When not to use Copilot

You build A small feature built in an editor with Copilot, with a log of which help worked and which did not.

Copilot can now take steps for you, not only suggest. You use agent mode on multi-step tasks, connect tools through MCP servers, work from the command line, and learn how far to trust each.

• What agent mode does that chat does not
• Approving and reviewing an agent’s actions
• Connecting an MCP server
• Copilot in the command line
• Limits and risks of acting assistants

You build A multi-step change made with agent mode and an MCP tool, with every action reviewed.

Review is where quality is decided. You use Copilot to summarize pull requests, review code, and suggest fixes, and learn how to weigh its comments against those of a person.

• Pull request summaries
• Copilot code review and its suggestions
• Accepting, editing and rejecting comments
• Where AI review misses what people catch
• Setting review expectations for a team

You build A review of a pull request with Copilot, with a note on what it caught and what it missed.

Much of a developer’s week is changing existing code. You use Copilot to explain legacy code, refactor it safely, write documentation, and debug faults, keeping behavior unchanged while the shape improves.

• Explaining unfamiliar and legacy code
• Refactoring with tests as a safety net
• Generating documentation and comments
• Debugging with Copilot
• Translating code between languages and frameworks

You build A legacy function refactored and documented with Copilot, with tests proving behavior is unchanged.

Copilot can raise quality as well as speed. You generate unit and edge-case tests, ask for security improvements, and check each suggestion rather than trusting that a test or fix is right.

• Generating unit tests
• Finding edge cases to test
• Asking for security reviews of code
• Fixing vulnerabilities with suggestions
• Verifying that generated tests test something

You build A test suite and a security fix for a small module, each checked by hand.

Some code and data must never leave your boundary. You set privacy options, exclude sensitive content, apply public code matching filters, and troubleshoot suggestions that go wrong.

• Privacy and data-handling settings
• Content exclusions for files and repositories
• Public code matching filters
• Editor and organization settings
• Troubleshooting missing or unwanted suggestions

You build A privacy configuration for a team repository, with exclusions tested to prove they work.

Rolling Copilot out to a team means decisions about people and policy. You compare plans, assign seats, set organization-wide policies, and watch usage to see whether the investment is used.

• Plans and what each includes
• Assigning and removing seats
• Organization and enterprise policies
• Audit and usage information
• Training developers and setting norms

You build A rollout plan for a development team, with plan choice, policies and review points.

One feature joins the course. You plan it, build and refactor it with Copilot, test it, review it, set the safeguards the repository needs, and report honestly on where the assistant helped and where it did not.

• Planning the feature and its context
• Building it with chat, completions and agent mode
• Testing, security checks and review
• Applying privacy and policy settings
• Reporting what Copilot did well and badly

You build A finished feature in a sample repository, with its tests, review and an honest report on Copilot’s part.