Transform the way you build software with AI-powered development! This comprehensive workshop teaches developers how to leverage GitHub Copilot and modern AI coding assistants to accelerate application development while maintaining high code quality standards.
This workshop is split into two parts:
Learn AI assistance across the entire development lifecycle—from requirements gathering to code generation, testing, and documentation. Using .NET 9, Visual Studio Code, and GitHub Copilot, you'll experience firsthand how AI can amplify developer productivity while following industry best practices like Clean Architecture, Domain-Driven Design, and Test-Driven Development.
Master advanced Copilot features including interaction models (Ask/Edit/Agent), custom agents, and workflow automation. Learn to design, build, and govern production-ready agents that encode team knowledge and standardize AI-assisted development workflows.
Full workshop duration: 6 hours (can be delivered as separate sessions or combined)
What makes this workshop unique:
- Practical, hands-on labs with real-world scenarios, not just demos
- Enterprise-grade patterns including Clean Architecture and DDD
- TDD-first approach with AI generating tests before implementation
- Pre-configured dev environment via VS Code Dev Containers—no setup hassles
- Repository-level Copilot instructions demonstrating team-wide AI consistency
- Modern .NET 9 with Minimal APIs and OpenTelemetry observability
Whether you're new to AI-assisted development or looking to level up your Copilot skills, this workshop provides the practical experience and best practices you need to integrate AI into your daily workflow effectively.
This repository contains all workshop materials including lab guides, starter code, reference implementations, and facilitator resources.
For the best experience, use the provided Devcontainer and recommended VS Code settings:
- Devcontainer: Ensures a consistent .NET 9, Node, and extension environment for all participants. No local setup required—just open in VS Code and "Reopen in Container" when prompted.
- Copilot Custom Instructions: This repo auto-applies Copilot instructions for Clean Architecture, DDD, and .NET 9. For best results, review or copy the full instructions from
.github/copilot-instructions.mdinto your Copilot Chat settings.
For a fully pre-configured .NET 9 development environment, you can use the included Dev Container. This is the fastest way to get started and ensures all required tools and extensions are installed.
How to use:
- Open this repository in VS Code.
- Open the Command Palette (
Cmd+Shift+PorCtrl+Shift+P). - Select:
Dev Containers: Reopen in Container - VS Code will build and open the project in a container with .NET 9, GitHub CLI, Copilot, C# Dev Kit, and all required extensions.
This is optional but highly recommended, especially if you want to avoid manual environment setup or ensure consistency across all participants.
Before attending this workshop, participants should have:
- GitHub Copilot: Active subscription and extension installed in VS Code
- .NET 9 SDK: Installed and verified with
dotnet --version - Visual Studio Code: Latest version with C# Dev Kit extension
- Git: Basic familiarity with git commands
- C# Experience: Comfortable with basic C# syntax and concepts
- GitHub Account: For cloning repositories and accessing Copilot
Run these commands to verify your setup:
dotnet --version # Should show 9.x.x
git --version # Any recent version
code --version # VS Code versionParticipants: Please complete the Pre-Workshop Environment Checklist before attending the workshop to ensure your environment is fully configured. This will allow us to maximize hands-on learning time.
By the end of Part 1, participants will be able to:
- Leverage repository-level Copilot Instructions (
.github/copilot-instructions.md) for team-wide consistent code generation - Transform requirements into backlog items, acceptance criteria, and working code using AI assistance
- Generate and refactor .NET code following Clean Architecture and DDD principles
- Create comprehensive tests and documentation with AI support
- Apply conventional commits and generate professional PR descriptions
- Identify anti-patterns and best practices when working with AI coding assistants
By the end of Part 2, participants will be able to:
- Understand and use Ask, Edit, and Agent interaction models appropriately
- Apply custom Copilot agents to specialized workflows (architecture review, backlog generation, test strategy)
- Design production-ready agents with clear roles, constraints, and structured outputs
- Iterate on agent instructions to improve reliability and consistency
- Establish governance for team-wide agent reuse and maintenance
- Goals and environment check
- Clone the repository and create your own branch from
mainbefore starting the labs - Copilot instructions automatically configured via
.github/copilot-instructions.md
- Inline completions, Chat panel, and Inline Chat
- Slash commands:
/explain,/fix,/tests,/doc,/refactor - Chat participants:
@workspace,@vscode,@terminal - Context variables:
#file,#selection,#editor - Quick hands-on practice with each feature
- Understand repository-level Copilot Instructions (
.github/copilot-instructions.md) - Emphasis on TDD workflow: Write tests before implementation
- Lab 1: Create NotificationService following Red-Green-Refactor cycle (interface → tests → implementation)
- Turn requirements into backlog items, tests, and code
- Lab 2: Backlog items → acceptance criteria → TaskService.AddTask
See Part 2 Facilitator's Guide for detailed schedule.
- Part 1 recap and Part 2 introduction
- Ask, Edit, and Agent modes
- Lab 5: Compare interaction models
- What are custom agents?
- Lab 6: Explore Architecture Reviewer, Backlog Generator, Test Strategist
- Lab 7: Apply agents to backlog, architecture review, and test strategy workflows
- AgePart 1 Facilitator's Guide](docs/FACILITATOR_GUIDE.md)**: Detailed timing and talking points for Part 1
- Part 2 Facilitator's Guide: Module-by-module guidance for Part 2 (Advanced GitHub Copilot)
- Lab Walkthroughs: Step-by-step guides for all nine labs with expected outputs and troubleshooting
- Custom Agent Catalog: Reference guide for workshop agents
- Agent Design Guide: Templates and patterns for building production-ready agents
- Lab 9: Design, build, test, and document a production-ready agent
-
Key takeaways, governance, and next steps
-
Scaffold APIs, refactor legacy methods with slash commands
-
Lab 3: Minimal API with
@workspace, refactor with/refactor, generate tests with/tests
- Generate tests, docs, commit/PR messages using Copilot features
- Lab 4:
/testsfor unit tests,/docfor documentation, conventional commits
- Lessons learned
- Anti-patterns to avoid
- Next steps and Q&A
- Copilot Instructions: Repository-level Copilot configuration (automatically applied)
- Facilitator's Guide: Detailed timing and talking points for instructors
- Lab Walkthroughs: Step-by-step guides for all four labs with expected outputs and troubleshooting
- Workshop Presentation Deck (PPTX): Slides used for workshop facilitation and participant reference
- Lab 1: TDD with GitHub Copilot (30 min) - Red-Green-Refactor cycle with NotificationService
- Lab 2: Requirements to Code (45 min) - Transform user stories into working features
- Lab 3: Code Generation & Refactoring (45 min) - Generate CRUD APIs and modernize legacy code
- Lab 4: Testing, Documentation & Workflow (15 min) - Complete the development lifecycle
- Lab 5: Interaction Models (20 min) - Compare Ask, Edit, and Agent modes
- Lab 6: Custom Agents Intro (15 min) - Explore pre-built custom agents
- Lab 7: Workflow Agents (35 min) - Apply agents to real workflows
- Lab 8: Agent Design (15 min) - Analyze and iterate on agent instructions
- Lab 9: Capstone - Build Your Own Agent (30 min) - Create a production-ready custom agent
- Lab 2: Requirements to Code (45 min) - Transform user stories into working features
- Lab 3: Code Generation & Refactoring (45 min) - Generate CRUD APIs and modernize legacy code
- Lab 4: Testing, Documentation & Workflow (15 min) - Complete the development lifecycle
Each lab includes:
- Clear learning objectives and prerequisites
- Step-by-step instructions with prompts
- Expected code outputs and examples
- Troubleshooting guidance
- Extension exercises for advanced participants
- Success criteria checklist
The main branch contains:
- Complete Solution: Clean Architecture with Domain/Application/Infrastructure/API layers
- Console Application: .NET 9 console app with DI and logging for initial exercises
- Web API: Minimal API with extension methods and OpenTelemetry integration
- Legacy Code Sample:
LegacyTaskProcessorfor refactoring exercises - Test Infrastructure: xUnit test stubs with FakeItEasy ready for implementation
Stuck or need examples? A complete reference implementation with all labs solved is available in the test-lab-walkthrough branch:
git checkout test-lab-walkthroughThis branch contains:
- All 4 labs fully implemented
- NotificationService with complete test suite (Lab 1)
- CreateTaskCommandHandler with CQRS pattern (Lab 2)
- Full CRUD API endpoints and refactored legacy code (Lab 3)
- Comprehensive unit and integration tests (Lab 4)
Use this branch to:
- Compare your solution with a working implementation
- Get unstuck if you encounter issues
- See best practices in action
- Review after the workshop for continued learning
-
Clone this repository:
git clone https://github.com/centricconsulting/ai-coding-workshop.git cd ai-coding-workshop -
Create your own branch from
main:git checkout main git pull git checkout -b my-workshop-branch
Replace
my-workshop-branchwith your name or a unique identifier. -
Open in VS Code:
code .That's it! Copilot instructions are automatically configured via
.github/copilot-instructions.md- no manual setup needed. -
Verify your environment:
dotnet --version # Should show 9.x.x or later dotnet build # Verify solution builds dotnet test # Verify tests run
-
Ready to start! Follow along with your facilitator or work through the labs independently
To get the most out of Copilot and AI agents in this workshop:
- Always ask for a plan first: Use Copilot or Agent Mode to propose a step-by-step plan before making large or multi-file changes.
- Use the Check agent for code review: Select the Check Copilot agent from the agents dropdown in Copilot Chat to get improvement suggestions before submitting a PR.
- Leverage chat participants: Use
@workspacefor codebase questions,@terminalfor CLI help, and@vscodefor editor tips. - Try custom Copilot agents: Select agents like Plan, Architect, or Check from the agents dropdown for specialized assistance.
- Be explicit in prompts: Reference files, selections, or context variables (e.g.,
#file,#selection) for targeted results. - Review and iterate: Treat Copilot suggestions as a starting point—review, refactor, and test as you would with any code.
See the Facilitator Guide and .github/agents/Check.agent.md for more workflow tips.