GitHub Copilot Beginner to Pro - AI for Coding & Development

This lecture introduces the first course project — a simple income and expenses tracker called Bucks2Bar — built entirely with GitHub Copilot. It covers what the app does (tracking monthly income/expenses and plotting them as a downloadable chart) and previews the planning process ahead, including choosing a UI and chart library with Copilot's help. The next lecture will walk through GitHub Copilot Chat's settings before diving into code generation.

This lecture covers the GitHub Copilot Chat interface in VS Code, walking through its three modes (agent, ask, and plan), how to select and configure AI models, and how to attach files or other resources as context to a prompt. By the end, you'll understand how to choose the right mode and model settings — including thinking effort — before generating code in a project.

This lecture walks through using GitHub Copilot's plan and agent modes to build a static income/expense tracker called Bucks2Bar, covering how to prompt Copilot for library suggestions, review and accept generated code, and debug issues like a broken Bootstrap CDN link. By the end, you'll have a working two-tab app with a data entry table and a Chart.js bar chart, all scaffolded with minimal manual coding.

This lecture covers two key GitHub Copilot best practices — using separate chat windows for each task to avoid context pollution, and staying within context window limits — then walks through implementing a "Download Chart as PNG" button in a web project. By the end, you'll know how to structure your Copilot workflow for cleaner results and how to add image-export functionality to a Chart.js bar chart using agent mode.

This lecture covers two GitHub Copilot Chat features: updating a UI by attaching design screenshots (or Figma files) as prompt context, and restoring code to earlier checkpoints within a chat session. By the end, you'll know how to feed reference designs directly into Copilot to reshape your interface, iterate with follow-up prompts, and roll back or redo generated changes when a previous state was preferable.

This lecture covers Agent Instructions in GitHub Copilot Chat — markdown files that define coding standards and rules, which Copilot automatically attaches as context to every chat. By the end, you'll know how to create and customize a copilot-instructions.md file so that Copilot consistently follows your project's conventions without you having to repeat them in every prompt.

The context window in GitHub Copilot Chat is a finite space shared by your instructions file, prompts, and responses — once it fills up, earlier messages get dropped. You'll learn why starting a fresh chat for each task prevents context pollution and overflow, and how to use Copilot's built-in context usage indicator (the pie chart icon) to monitor how much of the window you're consuming.

This lecture covers prompt injection attacks in the context of GitHub Copilot Chat, explaining how malicious instructions embedded in web pages can trick an AI into executing harmful actions like reading .env secrets or deleting files. You'll learn why the "bypass approvals" mode is risky, how "default approvals" lets you manually review fetched web content before it influences Copilot's behavior, and what steps to take to protect yourself from this class of attack.

This lecture covers setting up username form validation in a web app using GitHub Copilot Chat, including refactoring the input to use a <form> tag and adding JavaScript logic to test the username against a regular expression. By the end, you'll see how Copilot generates a submit handler that gives users real-time feedback on whether their username meets the required rules — laying the groundwork for unit testing that validation logic in the next lecture.

This lecture covers GitHub Copilot Chat's slash commands, focusing on /setupTests to configure a Jest testing environment in a browser-based JavaScript project. You'll learn how to use plan mode to choose a testing framework, switch to agent mode to let Copilot install dependencies and generate unit tests automatically, and control which terminal commands Copilot can run on your behalf.

This lecture covers GitHub Copilot Chat's /tests and /explain slash commands, showing how to generate unit tests for existing functions and get plain-language explanations of unfamiliar code. You'll also learn how to configure the terminal auto-approve list in settings.json to control which commands Copilot can run automatically on your behalf.

This lecture introduces the full-stack link shortener project students will build using Next.js, covering authentication, a Postgres database, and full CRUD functionality. You'll also get a preview of the advanced GitHub Copilot techniques used throughout — including MCP for direct database interaction, and local, cloud, background, and custom coding agents.

This lecture introduces the full technology stack for a Link Shortener project: Next.js as the full-stack framework, Shadcn UI with Tailwind CSS for the interface, a Neon-hosted Postgres database with Drizzle ORM, Clerk for authentication, and Zod for validation. The real goal isn't just to build a link shortener — it's to demonstrate how to get the most out of GitHub Copilot in a multi-layered, real-world architecture, with lessons transferable to other stacks like Python, Java, or Angular/Node.js.

This lecture walks through the full project setup for a Next.js link shortener app, covering installation of Shadcn UI, Clerk (authentication), Neon (hosted Postgres), and Drizzle ORM. By the end, you'll have a working dev environment with authentication, a connected database, and the foundational file structure needed before building out any features.

This lecture covers how to create custom agents and custom slash commands (prompt files) in GitHub Copilot Chat, using a concrete example of an instructions generator agent paired with a /create-instructions prompt. By the end, you'll be able to build a reusable workflow that automatically generates modular .md instruction files for the /docs directory and keeps your agents.md file updated — without manually writing each file from scratch.

This lecture walks through creating individual instruction files for a GitHub Copilot-powered project using a custom "create instructions" prompt and an instructions generator agent. Two files are built — authentication.md (covering Clerk-based auth, protected routes, and modal sign-in/sign-up) and ui-components.md (enforcing exclusive use of shadcn/ui) — with each automatically registered in an AGENTS.md index so Copilot knows when to reference them. By the end, you'll understand how to scaffold reusable instruction files that guide AI code generation for specific layers of your app.

This lecture covers building a basic dashboard page in a Next.js app using GitHub Copilot Chat, including protecting the route with auth checks, enforcing dark mode, and targeting UI elements via the VS Code Simple Browser to update shared components. You'll also see how to improve your AGENTS.md file to ensure Copilot always reads relevant documentation before generating code, and get a preview of background and cloud agents for running tasks in parallel.

This lecture covers how to delegate tasks to GitHub Copilot cloud agents — background processes that create a new branch, implement code in the cloud, and test it in a browser using Playwright, all without interrupting your local workflow. You'll learn the difference between local, background, and cloud agents, how to launch a cloud agent from VS Code or GitHub directly, and why reviewing the generated code afterward is still essential regardless of how the task was run.

This lecture covers how to use GitHub Copilot's cloud agent — via both the GitHub mobile app and GitHub.com — to request code fixes through pull request review comments, specifically to restore Geist and Geist Mono fonts that were accidentally removed. You'll also see how to approve and merge a pull request into the main branch once the agent has applied the requested changes.

This lecture covers GitHub Copilot's cloud agents and background agents, showing how to assign tasks to cloud agents via GitHub Issues and run background agents locally in isolated work trees — all without touching your main codebase. By the end, you'll know how to orchestrate multiple agent types in parallel to tackle different tasks simultaneously within a project.

This lecture walks through using GitHub Copilot Chat to plan and generate a Drizzle ORM table schema for storing shortened links in a Postgres database, covering the full workflow from planning in chat to pushing the schema to a Neon-hosted database. By the end, you'll know how to use Copilot's plan and agent modes together, choose the right Postgres ID strategy (GENERATED ALWAYS AS IDENTITY), and apply generated code and terminal commands directly from the chat window.

This lecture covers how to install and use the Neon MCP server inside GitHub Copilot Chat (VS Code), enabling natural language interaction with a Neon PostgreSQL database. You'll learn how to authenticate the MCP server, generate dummy SQL data using Copilot's ask mode, and insert that data directly into a database using the run SQL transaction tool in agent mode.

This lecture covers a bug fix for Clerk authentication in a Next.js app where signing in didn't automatically redirect users to the dashboard. The solution — using Clerk's built-in signInFallbackRedirectUrl and signUpFallbackRedirectUrl props in the layout — is cleaner than touching middleware or proxy files. You'll also see how to update a GitHub Copilot agents file to prevent it from suggesting deprecated Next.js patterns.

This lecture covers how to use GitHub Copilot's "official" method for agent instructions — creating .instructions.md files inside a .github/instructions/ directory with frontmatter descriptions — and contrasts it with the generic docs-based approach used earlier in the course. You'll see how a data-fetching.instructions.md file steers Copilot to generate a proper data access layer (helper functions in a /data directory) instead of writing raw Drizzle queries inline in server components.

This lecture covers how to migrate GitHub Copilot instruction files to the official .github/instructions directory format, update the custom instructions generator agent, and create a new slash command (/create-copilot-instructions) for generating properly structured instruction files. You'll also learn how to build a server-actions.instructions.md file with detailed coding standards for Next.js data mutations — including Zod validation, authentication checks, co-located action files, and returning error objects instead of throwing errors.

This lecture walks through implementing Create, Edit, and Delete link functionality in a Next.js dashboard app using GitHub Copilot Chat in agent mode. It demonstrates how well-configured instructions files guide Copilot to generate full-stack code — including server actions with Zod validation, Drizzle ORM queries, and shadcn/ui dialog components — with minimal prompting. By the end, you'll see how a short, generic prompt like "implement the create link functionality" can produce production-ready, standards-compliant code across every layer of the app when your instructions files carry the context.

This lecture covers how to implement edit and delete functionality for link list items in a Next.js app using GitHub Copilot Chat in agent mode. You'll see how Copilot generates modal dialogs, server actions, and database helper functions for both operations — and why well-crafted agent instructions make the whole process fast and consistent.

This lecture covers the implementation of redirect functionality for a URL shortener app built with Next.js, using GitHub Copilot in agent mode to generate a route handler at /l/[shortcode] that looks up the shortcode in the database and redirects the user to the full URL. You'll see how the absence of agent instructions for route handlers leads Copilot to write inline database queries rather than using a helper function — a practical lesson in why thorough instruction files matter.

This lecture covers the GitHub Copilot CLI tool — a terminal-based alternative to GitHub Copilot Chat — including how to install it, switch AI models, tag files using the @ symbol, toggle between agent and plan modes, and manage context windows. By the end, you'll know how to run Copilot prompts directly from the terminal, review a generated plan before applying code changes, and use slash commands like /model, /agent, /context, and /clear to control your session.

This lecture covers GitHub Copilot CLI hooks — what they are, how they work, and how to set up a PostToolUse hook that automatically runs Prettier on your codebase after every Copilot response. By the end, you'll know how to create a .github/hooks/ directory, configure a JSON hook file with a bash command, and define Prettier formatting rules via a .prettierrc config.

This lecture covers how to use GitHub Copilot Chat to run a security audit on a codebase using a custom prompt, and introduces the concept of sub-agents as a solution to context window limitations when fixing multiple issues. You'll learn how to create a project-level prompt file that scans for vulnerabilities and outputs findings as a structured table, and understand why spawning separate sub-agents — rather than fixing everything in one chat — keeps each fix clean and context-free.

This lecture covers subagents in GitHub Copilot Chat — what they are, why they're useful (isolating tasks to avoid polluting the main context window), and how to instruct Copilot to spawn them via the runSubAgent tool. By the end, you'll know how to write a prompt that triggers separate subagents for individual fixes, and how to verify they actually ran by exporting the chat as JSON and searching for the runSubAgent tool call.

This lecture covers Agent Skills in GitHub Copilot — what they are, how they differ from MCP, and how to create one using the skill creator skill from skills.sh. By the end, you'll understand how Agent Skills use progressive disclosure to keep context windows lean, and you'll see the full workflow for building a custom skill that queries a database and exports a bar chart as a PNG image.

This lecture compares four GitHub Copilot features — Custom Agents, Custom Prompts, Agent Skills, and Custom Instructions — and explains when to use each one. By the end, you'll be able to choose the right feature for your situation: Custom Agents for limiting tools, Custom Prompts for reusable inputs, Agent Skills for guaranteed outputs, and Instructions for influencing (but not dictating) the shape of generated code.