
How the sections build on each other, from Copilot Chat basics to agents, a hands-on project and the GH-300 exam, and which optional lectures you can skip.
Where to find each lecture's resources, how to ask a good question in the Q&A section, and Udemy features that make technical videos easier to follow.
Copilot's main features, from code completion and chat to agent mode and the cloud agent, and how it combines your prompt with project context before sending it to a large language model.
Sign in to GitHub Copilot in VS Code with your GitHub account, choose a plan and confirm that the chat responds, with a quick look at the JetBrains plugin.
GitHub Copilot privacy settings covering data usage for AI model training on Free, Pro, and Pro+ plans, and how to opt out through the Copilot account settings.
What to check when Copilot stops responding: the Output logs, the Reload Window command, Chat Diagnostics for service status and your Copilot settings on GitHub.
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.
Here we will migrate code from a language of framework to different ones. Use GitHub Copilot for code refactorization, modernization or simple mugrations.
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.
Updated November 2026: the whole course is re-recorded for the current GitHub Copilot in Visual Studio Code. It adds new sections on the cloud agent, CI/CD with GitHub Actions and the GH-300 certification, and a hands-on project you can follow in JavaScript/TypeScript, Python, Java or .NET.
GitHub Copilot is no longer just code completion. In agent mode it plans a task, edits several files, runs commands, calls tools through MCP servers and can open a pull request on its own. This course shows you how to use these features on real code, how to customize them for your project, and how to stay in control of what the agent does.
What you will learn
Copilot in VS Code
Copilot Chat with the agent, ask and plan modes, inline chat and inline code suggestions
Choosing a model and thinking effort, giving Copilot the right context, slash commands and # tools
Prompt engineering tips, and what Copilot really sends to the model (Chat Debug view)
Sharing your running web app with Copilot through the VS Code integrated browser
Customizing Copilot
Custom instruction files (copilot-instructions md and targeted .instructions md files) and AGENTS md
Sharing customizations through the .github folder, or using them in every project from your user .copilot folder
Commit message instructions and agent hooks
Agentic AI with Copilot
Custom agents with their own model, tools and instructions
Agent skills: SKILL md files with scripts that Copilot loads only when the task needs them
MCP (Model Context Protocol) servers: the GitHub MCP server and servers you configure yourself in mcp.json
When to use instructions, skills, custom agents or MCP, the Awesome Copilot collection, and saving tokens under usage-based billing
Hands-on project A small online pizza shop with a website and a REST API. The backend comes in JavaScript/TypeScript, Python, Java and .NET (C#), so you can follow along in the language you use at work. With Copilot you will:
explore the codebase;
add instruction files and new API endpoints;
connect a MySQL database using plan mode (PostgreSQL or MongoDB work too);
review the code with a second model;
query the data through an MCP server;
turn a conversation into a skill;
generate unit and integration tests.
Copilot on GitHub and in CI/CD
The GitHub Copilot cloud agent (coding agent): start sessions, assign GitHub issues and review the pull requests it opens
Copilot code review on your own pull requests
GitHub Actions: generate a workflow, debug failing Playwright tests from the CI logs, run the tests in Docker and generate Terraform for AWS
Models and the terminal
Bring your own key (BYOK), for example Claude models with an Anthropic API key
Free, private local models with Ollama inside Copilot
GitHub Copilot CLI: installation, sessions, models and MCP
GH-300 certification guide A section about the GH-300 GitHub Copilot certification exam: Responsible AI, Copilot plans and enterprise features, and an overview of the exam. The course doesn't include practice tests. What it gives you for the exam is hands-on experience with the Copilot features the exam asks about.
How the course is made
Fast paced: the typing is cut out and the focus stays on explanations
Big font and dark theme in full HD, readable even on a tablet
A quiz at the end of each section
The prompts and the project code as downloadable resources
I answer your questions in the Q&A
Course updates
November 2026: the whole course re-recorded. New: a hands-on project with four backend languages, the cloud agent and Copilot code review, CI/CD with GitHub Actions, and a GH-300 certification guide.
June 2026: new chat interface, agentic AI, Chat Debug view, prompt files, hooks, skills, custom agents, external and local models.