GitHub Copilot - The Complete Guide - 2026

A preview of the section, opening with a detail about Copilot's file edits: they are saved to disk before you choose to keep or undo them.

Open and arrange the chat view, manage multiple sessions, switch between agent, ask and plan modes, and use the model picker, tools and voice dictation.

How Auto model selection, thinking effort, context size and credit costs work, and how to pick a model that fits the task without wasting credits.

Point Copilot at exactly the right code by adding the open file, selected lines, several files or a whole folder, and see how it handles large workspaces.

Use inline chat inside a file, then preview Copilot's edits across one or more files and keep or undo each change.

Run reusable prompts with slash commands, call tools such as fetch with # and @, and run terminal commands with ! so Copilot can read and fix the errors.

Guide Copilot's ghost text suggestions with comments and function names, accept them in full or word by word, and turn them off or snooze them when needed.

A preview of the section, opening with how much of your context window system instructions and tool definitions take, and where you can see it.

Four habits for better results: be clear and specific with examples, attach the right context, iterate and save what works, and break big tasks into a plan.

Use Copilot as a tutor: quiz yourself on a topic such as Python strings, and get explanations of regular expressions and complex shell scripts.

Open your web app in the VS Code integrated browser and share the page, console logs or a selected element with Copilot, without taking screenshots.

What the model receives with each prompt, from context and chat history to system instructions and tools, and how to inspect it in the Chat Debug view.

How the section's lectures fit together, from where Copilot customizations are stored to agent hooks, a preview feature at the time of recording.

Store customizations in the project's .github folder to share them through source control, or in your user .copilot folder to use them in every project.

Set project-wide rules in copilot-instructions.md, split them into targeted .instructions.md files with applyTo patterns, and make sure Copilot actually loads them.

Tell Copilot how to write commit messages with a setting in .vscode/settings.json, shown here by adding emojis that match the changes.

Run your own shell commands at key points of an agent session, with a hello world hook and a session start hook that adds your Node.js version to the context.

The first of four sections on agentic AI, from the brain-and-hands idea behind AI agents to a custom agent that answers from up-to-date documentation.

How an AI agent differs from a chat assistant: a model with tools that gathers information, acts and checks its work in a loop until it reaches a goal.

The agent options in VS Code, from local sessions to delegating a task to the Copilot cloud agent, which creates a branch and a pull request on GitHub.

Build a custom agent with its own model, tools and instructions that answers Playwright questions from the official documentation instead of training data.

Guide AI agents with AGENTS.md files that apply to the whole project or to a single folder, and that also work in other AI assistants.

A practical introduction to MCP that previews each lecture and points ahead to the hands-on section, where an MCP server connects Copilot to a database.

Why AI applications need a standard way to reach external systems, how Copilot picks tools from an MCP server by itself, and why every enabled tool costs tokens.

Install the GitHub MCP server from the VS Code Extensions view, then create a branch, a commit and a pull request in natural language.

Add an MCP server that VS Code doesn't list by configuring it in mcp.json, shown with an Airbnb server that searches listings from the chat.

Why skills remove the need to explain the same workflow to AI again and again, with a preview of each lecture and of the skill built in the hands-on section.

How skills work: a SKILL.md file, optionally with scripts, that the model loads only when the skill's name and description match the task.

Create a hello world skill step by step, with a SKILL.md file, a response template and a JavaScript script that the skill runs.

Build a skill that runs a Node.js script to count the project's tests, so the model doesn't spend tokens reading every file.

A short look ahead at using Copilot's agentic features well, including why saving tokens matters more with usage-based billing.

Use instructions for rules on every prompt, skills for repeated workflows, custom agents for specialized roles and MCP for external systems, and combine them.

The Awesome Copilot community resource for pre-built custom agents, instruction files, skills, and hooks, installable directly into VS Code with one click.

Token-saving tips for GitHub Copilot's usage-based billing: clearing chats, using cheaper models, keeping MCP servers and instructions local to a project, and the Caveman tool.

Choose the backend language and database to follow along with, then preview each step, from exploring the code to MCP, skills and tests.

Ask Copilot to explain a new codebase, from the small course project to the VS Code source code, and see why the model you choose matters.

Generate a copilot-instructions.md file from the project, then add an instruction file that Copilot loads only when it works on the model types.

Ask Copilot which endpoints the API is missing, implement them, and test the new routes from the terminal.

Create a MySQL database for the project, or use the database you prefer, and connect to it from VS Code with the SQLTools extension.

Review Copilot's plan before it connects the project to MySQL, then watch it implement the plan and test its own work.

Check the database integration with a real order from the website, then have a different model review the code than the one that wrote it.

Install a MySQL MCP server for the project, keep the password out of source control, and ask Copilot about your data in plain language.

Turn a conversation into a skill that checks whether the README, OpenAPI file and instructions still match the code, then test it on a missing endpoint.

Ask Copilot which tests fit the project, add a test framework, generate unit tests and build database integration tests that run against a real MySQL database.

A preview of the section and what you need first: a project on GitHub and basic Git knowledge of commits, branches, pull requests and issues.

How the agent runs on a virtual machine powered by GitHub Actions, turns an issue into a draft pull request, and which tasks suit it.

Set up a GitHub repository with a small React and Vite project to use with the cloud agent in the rest of the section.

Start a session from github.com, follow its progress, request changes through a pull request review, and send tasks to the cloud from VS Code.

Ask Copilot to review your own pull request and commit its suggested fixes directly from GitHub.