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.

In this lecture you'll learn how to navigate the core controls within GitHub Copilot Chat, including Agent, Ask, and Plan modes, model selection, Thinking Effort, Context Size, tools, and usage. By the end, you'll understand how each of these settings affects GitHub Copilot's behaviour and be ready to configure Chat appropriately for different coding tasks.

In this lecture you'll learn how to provide GitHub Copilot with relevant context by attaching files and other resources to your prompts. By the end, you'll understand why context matters, how to add it efficiently, and how to avoid overwhelming GitHub Copilot with unnecessary information so you can get more accurate and useful responses.

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 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.