Everything GitHub Copilot — Hands-On Lab

A comprehensive, hands-on lab teaching the full GitHub Copilot agentic development experience — agents, skills, instructions, prompts, hooks, MCP servers, orchestration, and GitHub Agentic Workflows — all while working on a real .NET application.

⏱️ Pre-work — complete setup before the session begins.

---

🚨 Pre-Workshop Setup Checklist

Facilitators: share this section with attendees before the session. Setup takes 15–30 minutes on a good network and can fail on restricted laptops. Attendees arriving with a failing preflight may need to switch to Codespaces to keep up.

Attendees — run this checklist end-to-end and arrive with a green preflight:

1. Read the Prerequisites section below and install anything you are missing.
2. Authenticate the CLIs once so the session does not start on a login prompt:
   • gh auth login — GitHub CLI
   • copilot (launch it once and complete the sign-in flow)
3. Clone the repo to a fast local filesystem. On Windows/WSL2 this means a path under your Linux home directory (e.g. ~/repos/day-in-the-life-copilot-lab), not /mnt/c/…. See the Lab 14 compatibility matrix for why.
4. Run the preflight script and resolve any FAIL items. WARN items are acceptable but review them:

   # macOS, Linux, WSL2
   scripts/preflight.sh --lab14
   
   # Windows PowerShell (non-Lab-14 paths only; see matrix)
   pwsh scripts/preflight.ps1 -Lab14
   

   Expected green result:

   Summary: 0 FAIL, 0 WARN
   Result: READY ✅
   

   --lab14 / -Lab14 enables the strict Lab 14 checks (tmux required, WSL1 and Windows-PS-only become FAIL). Drop that flag if you are certain you will skip Lab 14.
5. Optional but recommended: open the devcontainer once (Codespaces or local Docker/Podman) so its image is pre-pulled. See Choose Your Path.

If preflight FAILs:

Warnings to review:

---

Prerequisites

Must-Have Now

Additional Tools by Path or Lab

Permissions & Licensing

Most labs (01–07, 10) work with any Copilot license. A few labs require specific plans or permissions:

Note: If your organization restricts Copilot features via policy, check with your admin that agent mode, MCP servers, and Copilot CLI are enabled.

---

Choose Your Path

Maintainer-only packaging work: the prepared-core Phase 1 recipe is staged separately. It is not a published or exercised browser entry point; the attendee setup paths below are unchanged.

Pick a stack: .NET track or Node track

The lab ships with two parallel implementations of Contoso University so you can practice the Copilot agentic surface against the stack you actually work in:

Dev-container / Codespaces users can skip the install step — the post-create.sh script runs pnpm -C node install automatically. Manual-setup users on the Node track must install pnpm first (npm i -g pnpm) because the Node workspace ships a pnpm-lock.yaml and is only supported via pnpm; use pnpm -C node install, not npm install, inside node/.

Both tracks share the same domain (Student / Course / Instructor / Enrollment), the same lab narrative, and the same .github/ Copilot configuration. Lab bodies are language-agnostic; each lab links a per-track appendix under labs/appendices/dotnet/ and labs/appendices/node/ for stack-specific commands.

Run both tracks with a single command:

make test-all

---

Option A — GitHub Codespaces

5–10 min | Zero local install

1. Fork this repository (see Fork & Clone below)
2. On your fork: click Code → Codespaces → Create codespace on main
3. Wait for the codespace to build (first time takes a few minutes — the post-create script installs all tools and builds the solution)
4. Once the terminal is ready, authenticate:

   copilot login
   gh auth login
   

5. ➜ Jump to Verify Copilot CLI

Tip: If “Codespaces” does not appear under the Code button, your organization may not have Codespaces enabled. Ask your admin, or use Option B or C below.

---

Option B — VS Code + Docker Desktop

~15 min | Has Docker

1. Install the Dev Containers VS Code extension
2. Ensure Docker Desktop is running
3. Fork and clone this repository (see Fork & Clone below)
4. Open the repo folder in VS Code
5. When prompted “Reopen in Container”, click Yes — or run Dev Containers: Reopen in Container from the Command Palette (Ctrl+Shift+P / Cmd+Shift+P)
6. Wait for the container to build (first time takes a few minutes)
7. Once the terminal is ready, authenticate:

   copilot login
   gh auth login
   

8. ➜ Jump to Verify Copilot CLI

The container includes: .NET 8 + 9 SDKs, Node.js, GitHub CLI, Copilot CLI, gh-aw, jq, and all recommended VS Code extensions.

---

Option C — VS Code + Podman

~15 min | Enterprise/Docker restricted

1. Install Podman and the Dev Containers VS Code extension

2. Configure VS Code to use Podman as the container engine. Open Settings (Ctrl+, / Cmd+,) and set:

   "dev.containers.dockerPath": "podman"
   

3. Start the Podman machine (if not already running):

   macOS / Windows:

   podman machine init
   podman machine start
   

   Linux: Podman runs natively — no machine needed. Ensure the Podman socket is active:

   systemctl --user enable --now podman.socket
   

4. Fork and clone this repository (see Fork & Clone below)

5. Open the repo folder in VS Code

6. Run Dev Containers: Reopen in Container from the Command Palette (Ctrl+Shift+P / Cmd+Shift+P)

7. Wait for the container to build (first time takes a few minutes)

8. Once the terminal is ready, authenticate:

   copilot login
   gh auth login
   

9. ➜ Jump to Verify Copilot CLI

Podman troubleshooting: If the container fails to start, verify the Podman socket path matches what VS Code expects. On Linux, set "dev.containers.dockerSocketPath": "/run/user/1000/podman/podman.sock" (adjust the UID if yours differs). On macOS/Windows, podman machine start handles this automatically. Your organization may require you to download a CA certificate into the Podman Virtual Machine, please visit: https://github.com/containers/podman/blob/main/docs/tutorials/podman-install-certificate-authority.md

---

Option D — Manual Setup

~20 min | Prefer direct install

Before starting, ensure you have all prerequisites installed.

1. Fork and clone this repository (see Fork & Clone below)
2. Build the solution:

   dotnet build dotnet/ContosoUniversity.sln
   

3. (Optional) Run the application:

   dotnet run --project dotnet/ContosoUniversity.Web
   

   The app starts at https://localhost:52379 (or http://localhost:52380). Press Ctrl+C to stop.
4. Open in VS Code:

   code .
   

5. ➜ Jump to Verify Copilot CLI

---

Fork & Clone

GitHub EMU users: If your organization uses GitHub Enterprise Managed Users (EMU) and cannot fork external repositories, skip to Clone into Your Own Namespace below.

🌐 On GitHub:

1. Fork this repository: click Fork at the top of this page
2. Go to your fork’s Settings → Actions → General and ensure Actions are enabled
3. Go to the Actions tab and click “I understand my workflows, go ahead and enable them” if prompted

🖥️ On your machine:

4. Clone your fork:

WSL/Bash:

git clone https://github.com/YOUR-USERNAME/day-in-the-life-copilot-lab.git
cd day-in-the-life-copilot-lab
git checkout feature/modernize

PowerShell:

git clone https://github.com/YOUR-USERNAME/day-in-the-life-copilot-lab.git
Set-Location day-in-the-life-copilot-lab
git checkout feature/modernize

5. Verify the .NET project builds:

dotnet build dotnet/ContosoUniversity.sln

You should see Build succeeded. with 0 Error(s). A handful of nullable-reference warnings may appear in some Razor views; they do not block the labs. If you see any Error(s), re-run scripts/preflight.sh and consult TROUBLESHOOTING.md.

6. (Optional) Run the application:

dotnet run --project dotnet/ContosoUniversity.Web

The app starts at https://localhost:52379 (or http://localhost:52380). On first run, the database is automatically created and seeded with sample data.

Note: The Development configuration uses SQLite, which works on all platforms (Windows, macOS, Linux). The database file (ContosoUniversity.db) is created automatically. Production uses SQL Server.

Press Ctrl+C to stop.

---

Clone into Your Own Namespace (GitHub EMU Users)

Who is this for? If your organization uses GitHub Enterprise Managed Users (EMU), you cannot fork repositories that live outside your enterprise. Follow these steps to create a copy in your own GitHub namespace.

🌐 On GitHub:

1. Navigate to github.com/new to create a new repository
2. Set the Owner to your EMU account (e.g., YOUR-USERNAME_ENTERPRISE)
3. Name the repository day-in-the-life-copilot-lab
4. Set visibility to Private (or Internal, per your organization’s policy)
5. Do not initialize the repository with a README, .gitignore, or license
6. Click Create repository
7. After pushing the lab content (see steps below), go to Settings → Actions → General and ensure Actions are enabled

🖥️ On your machine:

1. Clone the source repository:

WSL/Bash:

git clone https://github.com/ms-mfg-community/day-in-the-life-copilot-lab.git
cd day-in-the-life-copilot-lab
git checkout feature/modernize

PowerShell:

git clone https://github.com/ms-mfg-community/day-in-the-life-copilot-lab.git
Set-Location day-in-the-life-copilot-lab
git checkout feature/modernize

2. Change the remote origin to point to your new repository:

WSL/Bash:

git remote set-url origin https://github.com/YOUR-USERNAME_ENTERPRISE/day-in-the-life-copilot-lab.git

PowerShell:

git remote set-url origin https://github.com/YOUR-USERNAME_ENTERPRISE/day-in-the-life-copilot-lab.git

3. Push all branches and tags to your new repository:

git push --all origin
git push --tags origin

4. Verify the .NET project builds:

dotnet build dotnet/ContosoUniversity.sln

5. (Optional) Run the application:

dotnet run --project dotnet/ContosoUniversity.Web

Tip: To keep your copy in sync with the source, add it as an upstream remote:

git remote add upstream https://github.com/ms-mfg-community/day-in-the-life-copilot-lab.git
git fetch upstream
git merge upstream/main

Once complete, continue with Verify Copilot CLI below.

---

Verify Copilot CLI

🖥️ On your machine:

1. Verify Copilot CLI is installed:

copilot --version

2. Authenticate the Copilot CLI:

copilot login

Note: The Copilot CLI has its own authentication — it does not use gh auth. Running copilot login opens a browser-based device code flow. Alternatively, set a GH_TOKEN environment variable with a fine-grained PAT that has the Copilot Requests permission.

3. Verify Copilot CLI is authenticated by sending a test prompt:

copilot -p "hello"

If authenticated, you’ll receive a response. If not, the CLI will prompt you to log in.

4. Verify the Agentic Workflows CLI is installed:

gh aw version

Note: The gh aw extension relies on gh auth for GitHub API access. Run gh auth status to verify your GitHub CLI authentication separately.

---

Explore the Repository

🖥️ On your machine:

1. Open the repository in VS Code:

code .

2. Explore the key directories:

3. Read the repository context document:

WSL/Bash:

cat AGENTS.md

PowerShell:

Get-Content AGENTS.md

4. (Optional) Create a tracking issue in your fork:

🌐 On GitHub — create an issue with:

• Title: Lab Progress — Everything GitHub Copilot
• Body:

### Lab Progress

- [x] Setup
- [ ] Lab 01: Exploring Copilot Configuration
- [ ] Lab 02: Custom Instructions & AGENTS.md
- [ ] Lab 03: Creating a .NET Agent
- [ ] Lab 04: Skills & Prompts
- [ ] Lab 05: MCP Server Configuration
- [ ] Lab 06: Hooks
- [ ] Lab 07: Multi-Agent Orchestration
- [ ] Lab 08: gh-aw: PRD Generation
- [ ] Lab 09: Copilot Coding Agent & Code Review
- [ ] Lab 10: Agent memory — personalities, lessons, and consolidation

---

✅ Setup Complete

You now have:

• A forked repository with all Copilot configurations
• A building .NET project (ContosoUniversity) — optionally verified running at https://localhost:52379
• Copilot CLI authenticated and gh-aw CLI installed
• An understanding of the repository structure

Next: Lab 01 — Exploring Copilot Configuration

---

The Application

ContosoUniversity is a brownfield .NET 8 web application with clean architecture. You’ll use it throughout every lab to build, test, and orchestrate AI-powered development workflows.

ASP.NET MVC (Web)  →  EF Core (Infrastructure)  →  SQL Server / SQLite

erDiagram
    Department ||--o{ Course : offers
    Department ||--o| Instructor : "administered by"
    Course ||--o{ Enrollment : has
    Student ||--o{ Enrollment : "enrolled in"
    Instructor }o--o{ Course : teaches
    Instructor ||--o| OfficeAssignment : has
    Enrollment }o--o| Grade : receives

---

What You’ll Learn

---

Lab Modules

💡 Multi-Platform Support: All lab command lines provide both PowerShell and WSL/Bash alternatives. Choose the commands that work best for your environment.

Total: ~7 hours (20 labs — self-paced or presenter-led)

🧭 Learning path. Labs 01-10 form the core sequence. Lab 11 is standalone (plugin distribution). Lab 12 is standalone (Fabric MCP). Labs 13 → 14 are sequential — Lab 13 introduces A2A concepts and Lab 14 operationalises them with tmux. Labs 15-20 are the 2026 modernization track: Lab 15 (LSP) and Lab 17 (admin controls) are standalone; Lab 16 → Lab 11 are companions (marketplace governance); Lab 18 builds on Labs 08-09 (spec-driven PRD + stacked-PR code review); Lab 19 builds on Lab 08’s gh-aw fundamentals; Lab 20 extends docs/token-and-model-guide.md to enterprise scale and should be read after Lab 17.

---

Pre-Configured Copilot Features

This repo ships with a rich set of configurations for you to explore and extend:

Current Copilot CLI surface (2026 refresh)

Version floors, model tiers, and MCP pins live in docs/_meta/registry.yaml so labs stay in sync.

---

Useful Commands

---

Repository Structure

day-in-the-life-copilot-lab/
├── .github/
│   ├── agents/                    # Agent profiles (more created during labs)
│   ├── skills/                    # Agent skills (SKILL.md), incl. /cost-check and the other /name commands
│   ├── hooks/                     # Hook configuration (default.json)
│   ├── instructions/              # Path-specific instructions (.instructions.md)
│   ├── copilot-instructions.md    # Repository-wide instructions
│   └── workflows/                 # GitHub Agentic Workflows (.md + .lock.yml)
├── .copilot/
│   └── mcp-config.json            # MCP server configuration (4 servers; root .mcp.json mirrors it)
├── dotnet/                        # .NET track — ContosoUniversity solution
│   ├── ContosoUniversity.sln
│   ├── ContosoUniversity.Core/        # Domain models and interfaces
│   ├── ContosoUniversity.Infrastructure/  # Data access and services
│   ├── ContosoUniversity.Web/         # ASP.NET MVC web application
│   ├── ContosoUniversity.Tests/       # xUnit unit and integration tests
│   └── ContosoUniversity.PlaywrightTests/ # Playwright E2E tests
├── node/                          # Node track — Fastify + Drizzle + Vitest
│   ├── core/                          # Domain entities + repo interfaces
│   ├── infra/                         # Drizzle schema, repos, in-memory db, seed
│   ├── web/                           # Fastify app, routes, SSR views
│   └── tests/                         # Unit + integration tests (Vitest)
├── plugin-template/               # Lab 11 — private Copilot plugin scaffold
├── modernization-bundle/          # Lab 19 — packaged self-improving-agents plugin
├── labs/                          # 20 hands-on lab modules + per-track appendices
├── solutions/                     # Reference solutions
├── docs/                          # Reference docs + token & model guide
│   ├── _meta/                         # registry.yaml — single source of truth for versions
│   └── token-and-model-guide.md       # Phase 7 cost / model-selection mental model
├── scripts/
│   ├── hooks/                         # Hook shell scripts (Bash + PowerShell)
│   └── orchestrator/                  # Lab 14 — tmux-start, handoff, clear-context
├── mcp-configs/                   # MCP server reference configurations
├── tests/                         # Root vitest suite (lab structure, build, meta)
├── Makefile                       # `make test-all` orchestrates both tracks
├── AGENTS.md                      # Repository-level agent context
├── CHANGELOG.md                   # Keep-a-Changelog release notes
└── TROUBLESHOOTING.md             # Common issues and fixes

---

GitHub Agentic Workflows

This lab uses GitHub Agentic Workflows (gh-aw) — author GitHub Actions using Markdown with YAML frontmatter. Three workflows are included:

---

Workshop Content

---

Troubleshooting

For the full troubleshooting guide, see TROUBLESHOOTING.md.

---

Contributing

See CONTRIBUTING.md for guidelines on adding agents, skills, prompts, and other configurations.

License

MIT

---

Built with GitHub Copilot.