Training Plan

Table of Contents

• Goal
• Target Audience
• Schedule Shape
• Mentor Time Budget
• Daily Mentor Rhythm
• Copilot Feature Progression
• Phase Goals & Verification Questions
  • Day 0 — Pre-work
  • Day 1 — Foundations
  • Day 2 — Planning & Agent Mode
  • Day 3 — Capstone Project
  • Day 4 — Assessment
• Day-by-Day Breakdown
  • Day 0 — Pre-work
  • Day 1 — Foundations: Completions, Chat, Edit Mode, Custom Instructions
  • Day 2 — Planning & Agent Mode: Multi-Step Autonomous Development
  • Day 3 — Capstone Project
  • Day 4 — Assessment
• Key Resources Summary
• Mentor Prep: What to Create

Goal

Engineer can use VS Code Copilot effectively as an AI-assisted development tool — choosing the right mode for the task, writing specific prompts, setting up custom instructions, using Agent mode for autonomous development, and critically reviewing AI-generated code. The engineer demonstrates they understand every line of code Copilot produces and can articulate when and how to use each AI feature.

This training is about AI workflow, not programming. Engineers already know their language and stack. The goal is to make them productive with AI tools.

Target Audience

Schedule Shape

[Day 0]  [Day 1]       [Day 2]         [Day 3]       [Day 4]
 prep     foundations    planning &      capstone      assessment
 1-2h     full day      agent mode      project       half day
                        full day        full day       (morning)

Total: 3.5 working days + 1-2 hours pre-work.

Mentor Time Budget

Daily Mentor Rhythm

Copilot Feature Progression

The AI-only rule starts Day 1: All code comes through Copilot. Engineers already know their language — there’s no “hand-write first” phase. From the first exercise, every line of code is AI-generated. Small hand-edits (typo, variable rename) are allowed. New functions, new files, new logic — all through Copilot.

Day 4 is NO AI: The assessment proves the Engineer learned to think, not just to prompt.

Phase Goals & Verification Questions

Day 0 — Pre-work

AI Goal: Copilot is installed, subscription is active, inline completions and Chat panel both work. Engineer has bookmarked the cheat sheet.

Verification Questions

• Show me an inline completion — does it appear when you type?
• Open the Chat panel. Ask it a question about your code. Does it respond?
• Can you switch between Ask, Edit, and Agent modes? Show me the dropdown.
• Where is the model picker? What models are available?

Day 1 — Foundations

AI Goal: Engineer can use inline completions, NES, Chat (Ask mode), inline chat, and Edit mode. Understands the Chat participants and variables. Has set up custom instructions. Can write specific prompts and distinguish bad prompts from good ones.

Verification Questions

• Show me your inline completion workflow — write a comment and let Copilot generate code from it.
• What’s the difference between Ask mode and Edit mode? When do you use each?
• Use @workspace to find something in your project. What did it do?
• Use #file to reference a specific file in Chat. Show me.
• Open your copilot-instructions.md. What does it say? Why does it matter?
• Show me a bad prompt and a good prompt for the same task. What’s the difference?
• Where are your .instructions.md files? What do they do that copilot-instructions.md doesn’t?

Day 2 — Planning & Agent Mode

AI Goal: Engineer can use Agent mode for autonomous multi-step development. Understands planning mode. Can configure MCP servers. Has practiced prompt engineering across models. Can scope tasks appropriately for Agent mode and recover when it goes off track.

Verification Questions

• Show me how you use /plan before building a feature. Walk me through a plan.
• What’s the difference between Edit mode and Agent mode? When is Agent mode overkill?
• Show me your AGENTS.md. What rules did you add? Why?
• What happened when you gave Agent mode a too-broad prompt? How did you fix it?
• Show me your MCP configuration. What server did you add? What does it do?
• Show me your prompt log. What patterns did you notice about good vs bad prompts?
• Compare two models you tried. What was different about their output?
• Show me your .prompt.md file. When would you use it?

Day 3 — Capstone Project

AI Goal: Engineer can independently build a complete project using Copilot Agent mode as the primary tool, with custom instructions shaping the output. Code is on GitHub with meaningful commits, tests, and a workflow journal.

Verification Questions

(These are asked during the Day 4 assessment. See ASSESSMENT.md.)

Day 4 — Assessment

AI Goal: Engineer proves they can drive Copilot effectively under observation, understand every line of their generated code, and articulate AI workflow principles.

Verification

The assessment IS the verification. See ASSESSMENT.md.

Day-by-Day Breakdown

Day 0 — Pre-work (self-paced, 1-2 hrs)

Goal: Engineer arrives on Day 1 with Copilot working and the cheat sheet bookmarked.

What to do

1. Install GitHub Copilot extension in VS Code

   • Install “GitHub Copilot” extension (includes inline completions)
   • Install “GitHub Copilot Chat” extension (includes Chat panel with Ask/Edit/Agent modes)
   • Sign in with GitHub account that has an active Copilot subscription

2. Verify everything works

   • Open a code file → inline completions should appear as you type
   • Open Chat panel (Cmd+Shift+I / Ctrl+Shift+I) → Ask a question → it responds
   • Check mode dropdown: Ask, Edit, and Agent modes are all available
   • Check model picker: can see available models (GPT-4o, Claude Sonnet, Gemini, etc.)
   • Check NES is enabled: Settings → search “next edit suggestions” → ensure it’s on

3. Read the overview

   • GitHub Copilot in VS Code — official overview (~20 min)
   • Skim, don’t study — Day 1 will teach everything hands-on

4. Bookmark the cheat sheet

   • Open COPILOT-CHEATSHEET.md and bookmark it
   • You’ll reference this constantly during Days 1-3

Materials

• GitHub Copilot in VS Code — Overview
• GitHub Copilot Setup Guide
• COPILOT-CHEATSHEET.md — your daily reference

Verification

Mentor checks async via Slack: “Send me a screenshot of Copilot responding to a question in Chat.”

Day 1 — Foundations: Completions, Chat, Edit Mode, Custom Instructions

Goal: Engineer can use every Copilot feature except Agent mode. Has set up custom instructions. Knows the difference between a bad prompt and a good prompt.

AI-only rule is active from today. All code comes through Copilot. See feature progression table.

Morning: Inline Completions + Next Edit Suggestions (NES)

What to learn:

• Inline completions: Tab/Esc/Alt+] cycle, partial accept (Cmd+→), comment-driven development
• How to write a comment that guides Copilot to generate the code you want
• Next Edit Suggestions: how NES suggests follow-up edits after a change
• When to accept, when to dismiss, when to iterate

Materials:

• Code completions in VS Code (~15 min)
• Next Edit Suggestions (~10 min)

Exercise — Completion Speed Drill (45 min): Build a data validation module using ONLY inline completions. No Chat, no inline chat.

1. Write a comment: // Validate email format using regex
2. Let Copilot generate the function. Accept or iterate.
3. Write another comment: // Validate password: min 8 chars, 1 uppercase, 1 number
4. Continue for 5-6 validation functions.
5. Goal: get comfortable with Tab/Esc/Alt+] and partial accept (Cmd+→).

Exercise — NES Exploration (30 min):

1. Rename a variable in one place.
2. Watch NES suggest the same rename in related locations. Accept with Tab.
3. Change a function signature (add a parameter).
4. Watch NES suggest updates to call sites. Follow the chain.
5. Note: NES works best for cascading edits — rename, type changes, pattern updates.

Afternoon: Chat Participants, Variables, and Slash Commands

What to learn:

• Chat panel: Ask mode (read-only exploration)
• Participants: @workspace, @terminal, @vscode, @github
• Variables: #file, #selection, #codebase, #editor, #terminalLastCommand, #problems, #changes
• Slash commands: /explain, /fix, /tests, /doc

Materials:

• Chat in VS Code (~15 min)
• Chat Participants and Variables reference (~10 min)
• COPILOT-CHEATSHEET.md — Participants & Variables section (reference)

Exercise — Ask Mode Conversation Practice (45 min): Using a project you’re familiar with (or a small open-source project), practice these conversations in Ask mode:

1. @workspace where is authentication handled? — explore the project
2. #file:src/main.ts explain this file — understand a specific file
3. Select a function → /explain — explain the selection
4. Run a failing test → @terminal explain this error → #terminalLastCommand
5. Check Problems panel → #problems list all current issues
6. Use #codebase to find all API endpoints
7. Goal: practice using ALL participants and variables, not just typing questions.

Afternoon: Edit Mode + Inline Chat

What to learn:

• Edit mode: coordinated multi-file edits with diff review
• Inline chat (Cmd+I): targeted in-place edits without leaving the editor
• When to use Edit mode vs inline chat vs Ask mode
• How to review and accept/reject diffs

Materials:

• Copilot Edit mode (~15 min)
• Inline Chat (~10 min)

Exercise — Multi-File Edit (30 min):

1. Switch to Edit mode in the Chat panel.
2. Ask: “Add input validation to all route handlers in this project. Each handler should validate required fields and return 400 with an error message for missing fields.”
3. Review every diff Copilot proposes. For each file:
   • Does the validation logic make sense?
   • Is it consistent across handlers?
   • Did it change anything outside of validation?
4. Accept good changes. Reject bad ones. Re-prompt for the rejected ones with more specific instructions.

Exercise — Inline Chat Flow (30 min): Pick a function in your codebase and use inline chat (Cmd+I) for these tasks:

1. Select the function → Cmd+I → “Refactor this to use early returns instead of nested if-else”
2. Select the same function → Cmd+I → “Add JSDoc/docstring with parameter descriptions”
3. Select the function → Cmd+I → “Write a unit test for this function”
4. Review each change before accepting.
5. Goal: get comfortable with the inline chat workflow (select → Cmd+I → describe → review → accept/reject).

End of Day: Custom Instructions Setup

What to learn:

• .github/copilot-instructions.md — project-wide conventions
• .instructions.md with applyTo — scoped rules for specific files/folders
• The instruction hierarchy and how it affects Copilot output
• Bad prompt vs good prompt comparison

Materials:

• Custom Instructions for Copilot (~15 min)
• COPILOT-CHEATSHEET.md — Custom Instructions section (reference)

Exercise — Custom Instructions Setup (30 min):

1. In your project, run Copilot’s @workspace /init slash command. It generates a starter copilot-instructions.md.
2. Review what it generated. Edit it to accurately reflect your project:
   • What’s your architecture? What patterns do you follow?
   • What’s your tech stack? What libraries do you use?
   • What are your conventions? (naming, error handling, testing style)
3. Create one .instructions.md file with an applyTo glob. Examples:
   • For test files: applyTo: "**/*.test.*" → “Use vitest. Mock external dependencies. Use factory functions for test data.”
   • For API routes: applyTo: "src/api/**" → “Follow REST conventions. Return proper status codes. Validate input in the service layer.”
4. Ask Copilot to generate something in the scoped directory. Does the output match your instructions?

Exercise — Bad Prompt vs Good Prompt (20 min): Try these 4 prompts for the same task (adding a new feature to your project). Do them in order:

Compare all 4 outputs. Which is most useful? Show the comparison to your Mentor.

Mentor Time (~1.5 hrs)

• 15 min: morning — Mentor briefs: “today is foundations, here are the exercises, here’s what I expect”
• 10 min: midday check — “show me your completions, show me a Chat conversation”
• 30 min: end of day — Mentor reviews custom instructions + 4-prompt comparison. Asks verification questions.
• Async: answer questions as they come up

Self-Assessment Checkpoint

Before moving to Day 2, the Engineer should be able to answer “yes” to all:

• I can get inline completions and navigate them (Tab, Esc, Alt+], Cmd+→)
• I can use NES to follow a chain of related edits
• I can use Chat with @workspace, @terminal, #file, #selection, #codebase
• I can use inline chat (Cmd+I) for targeted edits
• I can use Edit mode for multi-file changes and review diffs
• I have a copilot-instructions.md that reflects my project
• I have at least one .instructions.md with applyTo
• I can explain the difference between a bad prompt and a good prompt

Day 2 — Planning & Agent Mode: Multi-Step Autonomous Development

Goal: Engineer can use Agent mode and planning mode for autonomous, multi-step development. Understands model selection, prompt engineering, and MCP configuration.

AI-only rule continues. All code through Copilot. Agent mode is introduced today but NOT yet the primary mode — practice all modes.

Morning: Model Selection + Prompt Engineering

What to learn:

• Model picker: how to switch between GPT-4o, Claude Sonnet, Gemini, and other available models
• Different models have different strengths (speed vs quality, code vs explanation)
• Prompt engineering: the 4-level specificity spectrum
• .prompt.md files: reusable prompt templates

Materials:

• AI Model Selection in Copilot (~10 min)
• Prompt crafting for Copilot (~15 min)
• COPILOT-CHEATSHEET.md — Prompt Engineering section (reference)

Exercise — Model Comparison (30 min):

1. Pick a non-trivial task: “Write a rate limiter middleware using the sliding window algorithm.”
2. Ask the same prompt in Chat with 3 different models (e.g., GPT-4o, Claude Sonnet, Gemini).
3. Compare:
   • Which explained the approach best?
   • Which produced the cleanest code?
   • Which was fastest?
   • Did any get the algorithm wrong?
4. Write 2-3 sentences about what you learned. There’s no “best” model — they have tradeoffs.

Exercise — Prompt Engineering Ladder (30 min):

1. Pick a feature to add to your project.
2. Write 4 prompts at increasing specificity (see the 4-level spectrum from Day 1).
3. For each, note:
   • How many follow-up prompts did you need?
   • How much of the output could you use directly?
   • How much time did you spend reviewing vs re-prompting?
4. Conclusion: more specific prompts = less total time, even though the prompt itself takes longer to write.

Exercise — Create a .prompt.md File (20 min):

1. Identify a recurring task in your project (e.g., “add a new CRUD endpoint”, “create a new component”, “add tests for a service”).
2. Create a .prompt.md file that templates this task.
3. Example:

   ---
   mode: agent
   description: Generate a new CRUD endpoint
   ---
   Create a new CRUD endpoint for the {{resource}} resource.
   
   Follow the patterns in the existing {{example_file}}.
   Include: model, repository interface, service with validation, handler with proper status codes.
   Add unit tests for the service layer following the pattern in {{test_file}}.

4. Use it: reference the prompt file in Chat with #prompt:your-file-name.

Midday: Planning Mode

What to learn:

• The /plan command in Agent mode
• How to review, critique, and adjust a plan before execution
• When planning adds value vs when it’s overhead

Materials:

• COPILOT-CHEATSHEET.md — Planning Mode section (reference)

Exercise — Plan and Build (45 min):

1. Switch to Agent mode.
2. Run: /plan I need to add [a feature] to my project. Design the data model, the implementation approach, and the file changes needed.
3. Review the plan:
   • Does it match your architecture?
   • Is the order logical?
   • Is anything missing? (tests, error handling, validation)
   • Is it trying to do too much?
4. Give feedback: “Move validation to the service layer. Add a step for tests. Remove the database migration — I’ll handle that separately.”
5. Tell it to proceed. Watch it execute.
6. Review the result. Did it follow the plan?

Exercise — With vs Without Planning (30 min):

1. Build one small feature WITHOUT planning — just describe it and let Agent mode go.
2. Build another similar feature WITH /plan first.
3. Compare:
   • Which produced better-structured code?
   • Which required fewer corrections?
   • Which was faster overall (including re-work time)?
4. Write 2-3 sentences about when planning is worth the overhead.

Afternoon: Agent Mode

What to learn:

• Agent mode: what it can do (create files, run commands, iterate on errors, self-correct)
• How to scope tasks for Agent mode
• How to review Agent mode diffs
• The autonomy trap: what happens when you give too-broad prompts
• Using Git as a safety net

Materials:

• Copilot Agent mode (~15 min)
• COPILOT-CHEATSHEET.md — Agent Mode section (reference)

Exercise — Build from Scratch (60 min):

1. Start a new small project (or a new module in your existing project).
2. In Agent mode, describe what you want to build: “Create a [specific feature] with [specific requirements]. Use [your framework]. Include tests.”
3. Watch the autonomous loop: planning → file creation → code generation → error fixing → test running.
4. Observe:
   • Did it create the right files?
   • Did it follow your custom instructions?
   • Did it run tests? Did they pass?
   • Did it self-correct when something failed?
5. Review the final diff carefully before accepting.

Exercise — Add a Feature (45 min):

1. Using the project from the previous exercise (or your own project).
2. Ask Agent mode to add a feature that touches existing code: “Add [feature] to the existing [module]. It should integrate with the existing [component].”
3. Observe:
   • Does it understand the existing code?
   • Does it modify the right files?
   • Does it break anything existing?
   • Does it add tests?

Exercise — The Autonomy Trap (30 min):

1. Give Agent mode a deliberately too-complex prompt: “Build a complete user management system with authentication, authorization, password reset, email verification, and admin panel.”
2. Watch what happens:
   • Does it create a coherent plan or scatter?
   • Does it create files you didn’t expect?
   • Does it modify things outside the scope?
   • Does it run in circles (fix one error, create another)?
3. Stop it. Review the mess. Undo with Git.
4. Re-prompt with a tightly scoped version: “Add user registration. POST /users that validates email and password, stores in the database, and returns the created user. Include a test.”
5. Compare the results. Write 2-3 sentences about scoping.

Afternoon: MCP Servers + Advanced Features

What to learn:

• MCP (Model Context Protocol): extending Copilot with external tools
• .vscode/mcp.json configuration
• Source control integration: Copilot commit messages, PR descriptions
• AGENTS.md: rules specifically for Agent mode
• Vision: using images/screenshots in Chat

Materials:

• MCP Servers in VS Code (~15 min)
• COPILOT-CHEATSHEET.md — MCP section (reference)

Exercise — Configure an MCP Server (20 min):

1. Create .vscode/mcp.json in your project.
2. Add at least one MCP server. Options:
   • Filesystem server (access files outside workspace)
   • Fetch server (fetch URLs and documentation)
   • Database server (if you have a database)
3. Verify: in Agent mode, ask Copilot to use the MCP tool. Does it work?

Exercise — Source Control Integration (15 min):

1. Make a meaningful code change.
2. In the Source Control panel, click the sparkle icon to generate a commit message.
3. Review the message. Is it accurate? Edit if needed, then commit.
4. If you have a PR open, try generating a PR description with Copilot.

Exercise — AGENTS.md Setup (15 min):

1. Create AGENTS.md in your project root.
2. Add rules that guide Agent mode behavior:

   # Agent Mode Rules
   
   ## After Code Changes
   - Always run tests after modifying code
   - Run linter before committing
   
   ## Git
   - Use conventional commit format: type(scope): description
   - Commit after each logical change, not in bulk
   
   ## Architecture
   - Business logic goes in the service layer, never in handlers/controllers
   - All external API calls go through a dedicated client module

3. Test: ask Agent mode to add a feature. Does it follow your AGENTS.md rules?

Throughout the Day: Prompt Debugging Log

Keep a running log today. This is reviewed by the Mentor and becomes practice for the Day 3 journal.

Aim for 5-8 entries by end of day. Focus on moments where Copilot surprised you (good or bad).

Optional: Cloud Coding Agent Demo

If your organization has GitHub Copilot Business/Enterprise:

1. Open a GitHub issue in a test repository.
2. Assign it to Copilot (or use the “Copilot” label, depending on your setup).
3. Watch Copilot create a PR autonomously from the issue description.
4. Review the PR. This is “fire and forget” AI — useful for simple tasks, dangerous for complex ones.

Note: This is a demo only. The training focuses on VS Code Copilot, not the cloud agent.

Mentor Time (~1.5 hrs)

• 15 min: morning — Mentor briefs: “today is Agent mode day, here are the exercises, be ready for the autonomy trap”
• 10 min: midday check — “show me your planning mode output, show me your prompt file”
• 45 min: end of day — Mentor reviews prompt log + AGENTS.md + MCP setup. Asks verification questions.
• Async: answer questions as they come up

Self-Assessment Checkpoint

Before moving to Day 3, the Engineer should be able to answer “yes” to all:

• I can switch between models and articulate their tradeoffs
• I can write prompts at the “expert” level (specific, contextual, pattern-referencing)
• I have a .prompt.md file that I’ve actually used
• I can use /plan to plan before building, and I know when planning is worth it
• I can use Agent mode to build features autonomously
• I know what happens when Agent mode scope is too broad, and how to fix it
• I have a working MCP server configured
• I have an AGENTS.md with meaningful rules
• I can generate commit messages with Copilot
• I have a prompt debugging log with 5+ entries

Day 3 — Capstone Project (full day, AI-only)

Goal: Engineer independently builds a complete project using Copilot Agent mode as the primary tool. Proves they can drive AI for a real deliverable.

The Assignment

See CAPSTONE-PROJECT.md for full details.

Summary:

• Engineer picks one of 3 project options (backend API / frontend dashboard / full-stack app)
• All code comes through Copilot — Agent mode is the primary tool
• Required deliverables:
  • Working project pushed to GitHub
  • Custom instructions (.github/copilot-instructions.md + .instructions.md + AGENTS.md)
  • At least one .prompt.md file
  • Unit tests
  • Git commits with Copilot-generated messages
  • README written by the Engineer (not generated)
  • Workflow journal (5-10 entries)

Engineer’s Day

Rules

1. Agent mode is primary. Use it for all feature building. Other modes (inline, edit, chat) are support tools.
2. All code through Copilot. No hand-writing implementation code.
3. README is written by the Engineer. This is the one exception — it forces you to articulate decisions in your own words.
4. Keep the workflow journal. 5-10 entries covering prompt failures, mode choices, instruction impact, agent autonomy, and recovery moments. See CAPSTONE-PROJECT.md for format.
5. Commit after each feature. Use Copilot-generated commit messages.
6. If you’re stuck for more than 20 minutes, ask the Mentor. But frame it as: “I’m trying to do X and getting Y. What am I misunderstanding?” — not “fix it for me.”

Mentor Time

• ~0 hrs structured
• Available async on Slack/chat for blocking issues only (~30 min total max)
• Mentor does NOT review code today — that happens during the Day 4 assessment

Day 4 — Assessment (half day, morning only)

Goal: Engineer proves they can drive Copilot effectively, understand their code, and articulate AI workflow principles.

See ASSESSMENT.md for full details.

Schedule

Scoring Summary

Verdict:

• 3 Strong = ready for real project work
• Mixed = revisit weak areas with specific practice
• Any Concern = needs more practice before using AI on real projects

Key Resources Summary

Core Curriculum

Training Materials (This Repo)

Mentor Prep: What to Create

1. Feature request for assessment (Day 4): Prepare a feature request appropriate to each capstone project option. It should require adding logic to existing code, not just a new standalone module. See ASSESSMENT.md — Section 1 for examples.

2. Copilot subscription access: Ensure all engineers have active GitHub Copilot subscriptions before Day 0. Chat with Agent mode requires Copilot Individual, Business, or Enterprise.

3. Test project (optional): If engineers don’t have a project to use on Day 1, prepare a small starter project in a common language (e.g., a simple Express/FastAPI/Spring Boot app with 2-3 endpoints) so they have code to practice with.

4. Slack/chat channel: Set up an async communication channel for questions. Most mentor time is async — quick answers to unblocking questions.

5. Assessment scoring sheet: Print or prepare a digital copy of the score sheet from ASSESSMENT.md for each engineer.