Testing Software Using GitHub Copilot

Module 1: Introduction

• Welcome, instructor introduction, and logistics.
• Learning Objectives:
  • Understand the workshop's goal: To move from basic Copilot use to expert-level collaboration.
  • Review the agenda and structure for the next 4 hours.
  • Confirm environment setup (IDE with Copilot extension installed and active).

Module 2: Fundamentals Recap

• What is GitHub Copilot? A brief overview of the AI pair programmer concept.
• How it Works (High-Level): Understanding the LLM (Large Language Model) context window.
• Terminology Review:
  • Prompt (Context)
  • Suggestion (Ghost Text)
  • Copilot Chat (In-line vs. Side Panel)
  • Workspace Context (@workspace)
• IDE Feature Matrix: The Core Tools
  • In-line Suggestions: Accepting (Tab), rejecting, cycling (Ctrl+Alt+[]).
  • Copilot Chat Panel ("Agent" Mode): The "big picture" AI. Asking broad, project-wide questions using @workspace (e.g., "how is user authentication handled?").
  • Quick Actions: Using /explain, /fix, /doc, /test, /terminal.

Module 3: Prompt Engineering

• The Art of Communicating with AI: "Garbage In, Garbage Out."
• Principle 1: Provide Context. The importance of open tabs, selected code, and using @workspace.
• Principle 2: Be Specific and Clear. (Good vs. bad prompts for chat, /edit, and comments).
• Principle 3: Iterate. How to refine a prompt to get the desired output.

Module 4: Best Practices & Hands-on Exercises

• Best Practice 1: "Comment-Driven Development." (Write comments, let Copilot generate code).
  • Exercise: Participants write a few comments for a function and have Copilot generate it.
• Best Practice 2: You Are the Driver, Copilot is the Navigator.
  • Why you must review all code (security, bugs, and style).
• Best Practice 3: Refactoring with "Edit" Mode.
  • Exercise: Use /fix on a deliberately buggy piece of code.
  • Exercise: Use the /edit command to refactor a function for better readability (e.g., "extract this for loop into a new method named calculateTotal").
• Best Practice 4: Using "Ask" Mode Understanding.
  • Exercise: Use /explain on a provided complex code block.
  • Exercise: Use /doc to generate full docstrings/JSDoc.

Module 5: GitHub Models

• Understanding the Model Landscape:
  • What's the difference? (e.g., GPT-3.5 vs. GPT-4).
  • When to use which model for speed vs. accuracy?
• Copilot Tiers:
  • Copilot Business: Org-level policies, data privacy, and IP protection.
  • Copilot Enterprise: Indexed private repositories for "your code" context, customized chat, and advanced agent capabilities.
• Discussion: Data privacy, security, and how Copilot uses your code.

Module 6: Advanced Techniques: Agent & Tools

• Technique 1: Plan and Agent Modes
  • Using Ask Mode and @workspace to find where functionality is implemented (e.g., "where in this project do we validate API keys?").
  • Take what you found from the response and feed it into Plan mode
  • Have Agent mode implement the plan you just created
• Technique 2: Accessing Tools using Copilot
  • MCP servers
  • Accessing a MCP server from Copilot
  • Hands-on Mini-Workshop:
    • Exercise: Add a new MCP server to Copilot
    • Access the new MCP server from Copilot
• Technique 3: Leveraging Copilot Spaces
  • Understand what GitHub Copilot Spaces are
    • Benefits of using Spaces
    • Create and configure multiple Copilot Spaces for different purposes
  • Set up Spaces with specific goals, instructions, and context
  • Access and use Spaces from within your IDE via GitHub MCP

Module 7: Custom Agents

• Create custom agents for autonomous task execution
• Apply best practices for creating and using custom agents

Module 8: Coding Agent

• Understand GitHub Copilot's Coding Agent and its autonomous capabilities
  • Learn to create and assign GitHub issues to Copilot for autonomous implementation
  • Monitor and interact with Copilot's development process through session logs
• Review and iterate on AI-generated code using pull request workflows
• Understand best practices and limitations for coding agents
  • What coding agents can do
  • What coding agents cannot do

Module 9: Workshop: Hands-on Lab

• Goal: Build a complete (but small) application from scratch using Copilot at every step.
• Project Brief: (e.g., "Build a 'To-Do List' REST API," or "Build a 'Weather App' web front-end").
  • Define 1-2 key requirements to build
• Phase 1: Project Scaffolding (15 min).
  • Use Copilot Chat ("Agent Mode") to plan the file structure.
  • Generate package.json, requirements.txt, etc.
• Phase 2: Core Logic (45 min).
  • Use comment-driven development to build core functions/API endpoints.
  • Use /edit ("Edit Mode") to refactor and modify logic as you go (e.g., "add input validation to this function").
  • Experiment with creating a custom agent that is specialized in building your application
  • Use Plan mode to plan out larger features and then delegate the work to Agent mode
  • Set up the GitHub MCP to enable you to work with your repository in GitHub.com
• Phase 3: Developer Testing (15 min).
  • Use /test and @workspace to find related code for unit test generation.
• Phase 4: Documentation (15 min).
  • Use chat to generate a README.md for the new project.
  • Use /doc to document all new functions.
• Phase 5: Leveraging Coding Agents
  • Use Copilot Coding Agent to plan, build, test, and document a new feature
• Instructor circulates to help, debug, and provide tips.

Module 10: Conclusion

• Recap of Key Learning Objectives and Best Practices.
• Sharing & Showcase: (Optional) 1-2 volunteers share their screen.
• Final Tips: Building a "Copilot-first" habit.
• Open Q&A.
• Further Learning & Resources.