MMCPMarkets
MF

microsoft/frontier-ghcp-rvas

Deployment & DevOps
5 stars Quality 38 Trend 21
Repository Install

GitHub Copilot Adoption Real Value Acceleration Service (RVAS)

Overview

Use GitHub Copilot to deliver work your team needs. Choose from with starter code and track guides. Use the session to find practices your team can keep using. Sessions use repository instructions, custom agents, and custom skills tailored to the work. Challenge 30 adopts Spec Kit's supplied workflow; authoring custom agents and skills is optional there. In the other tracks, participants author and refine them throughout the session. Ordinary chat prompts remain useful for one-off requests. Challenges also use Impeccable for a focused UI review tied to the existing user journey. Participants install the skill with npx; no Impeccable extension is required. The shared setup includes discovery and launcher checks. Each selected track keeps optional features outside its 4-6-hour core. The Backlog Generator's first stage is now Spec-to-Backlog Skill; links to its former stage-1-prompt page need updating. Choose a challenge below.

README

GitHub Copilot Adoption

Use GitHub Copilot to deliver work your team needs. Choose from 31 challenges with starter code and track guides. Use the session to find practices your team can keep using.

Sessions use repository instructions, custom agents, and custom skills tailored to the work. Challenge 30 adopts Spec Kit’s supplied workflow; authoring custom agents and skills is optional there.

In the other tracks, participants author custom skills for reusable workflows and refine them throughout the session. Ordinary chat prompts remain useful for one-off requests. Challenges 4, 8, 9, 10, 18, 27, 29, and 30 also use Impeccable for a focused UI review tied to the existing user journey. Participants install the skill with npx; no Impeccable extension is required. The shared setup includes discovery and launcher checks. Each selected track keeps optional features outside its 4-6-hour core. The Backlog Generator’s first stage is now Spec-to-Backlog Skill; links to its former stage-1-prompt page need updating.

Choose a challenge

Choose a challenge below. Each has a defined outcome, starter code, a devcontainer, and stages that guide the work.

Overview

The repository includes 31 challenge tracks organized by the outcomes they help you deliver:

Challenges by outcome

Choose by the work you need to deliver. At the end, show what changed and how Copilot helped.

View All Tracks & Choose Yours

Coaches can use the site’s Challenge Set Builder and Learning Paths pages to select challenges for a focused session and share one student URL.

Each track explains its stages and verification criteria.

The documentation site also groups challenges into 13 enterprise Role Collections. Use the Roles page to find relevant work for product, engineering, data, security, database, documentation, mobile, platform, operations, QA, and architecture roles.

Duration

Duration varies by track. Challenge 29 takes 4-6 hours, with a five-hour core. Check the selected track for its time budget.

Documentation site

The static documentation site lives in web/. It uses HTML, CSS, and JavaScript with no build dependencies.

The homepage starts with role selection, then explains how to open a track, prepare the environment, and work through its stages. The catalog, learning paths, and Challenge Set Builder pages remain available through navigation. The site also includes setup, troubleshooting, and facilitator instructions.

To build the site data locally:

node web/build.js

This reads challenges/*/meta.yml, learning-paths.json, role-collections.json, and track markdown files, then writes the site data to web/assets/data/.

Role Collections are curated challenge groups, not required sequences. role-collections.json is their source of truth. The build rejects unknown challenge IDs, duplicate role entries, empty collections, and challenges that are not assigned to any role.

Each challenge is published as a set of pages rather than one concatenated guide:

  • The track file becomes the main overview.
  • The committed stages.md file becomes the contents page.
  • Each stage has its own page.
  • Challenges with role-specific instructions include those pages beneath their parent stage.

The challenge page shows this structure in a right-side Challenge pages menu. Every page has a direct URL in the form challenge.html?id=&page=.

The generated platform.json catalog includes the page manifest for each challenge. Markdown payloads are written separately under web/assets/data/challenges//pages/.md.

To preview locally:

cd web
python3 -m http.server

Then open http://localhost:8000/index.html in your browser.

The GitHub Pages deployment workflow automatically builds and deploys the site from .github/workflows/deploy-site.yml on every push to main.

Getting started

  1. Choose a challenge from tracks/README.md.
  2. Set up your environment using the track’s prerequisites and devcontainer.
  3. Work through the stages and demonstrate the result.

Use a disposable clone for a predefined challenge. First-time setup keeps the selected starter and guides, removes the website and facilitator material, and replaces the root README with a single challenge entry point. It also removes .impeccable/, root PRODUCT.md and DESIGN.md, template skills and agents, and .github/hooks/impeccable.json. Rebuilding preserves participant files and Copilot customizations. The full template remains in this source repository.

Step 1: choose your track

Not sure which track? See the Track Selection Guide for help choosing.

Running a coached session? Use the site’s Challenge Set Builder or Learning Paths pages to prepare a curated challenge set and share one student URL with participants.

Step 2: set up environment

Prerequisites

  • GitHub account with Copilot access
  • GitHub Codespaces enabled (recommended) OR
  • Local development environment with VS Code and GitHub Copilot extension

Open the workspace

Option A: GitHub Codespaces (Recommended)

  1. Click the green “Code” button at the top of this repository.
  2. Select the “Codespaces” tab.
  3. Click “Create codespace on main”.
  4. Wait for the environment to set up (2-3 minutes).

Option B: Local Development

  1. Clone this repository:

    git clone https://github.com/microsoft/frontier-ghcp-rvas.git
cd frontier-ghcp-rvas

  2. Open the folder in VS Code.

  3. When prompted, click “Reopen in Container” (requires Docker and Dev Containers extension).

The environment is pre-configured with:

  • GitHub Copilot CLI (copilot) in every challenge configuration
  • Node.js (LTS)
  • Python 3.11
  • Docker
  • Terraform
  • kubectl
  • All necessary VS Code extensions

Step 3: prepare your challenge workspace

If you opened the selected challenge’s devcontainer, setup has already prepared the workspace. Follow the challenge link in the generated root README.

For manual setup, follow Getting Started. First-time setup resets the template’s Copilot customizations and creates a branch named challenge--, such as challenge-4-a1b2c3d4e5f6. It keeps all Git remotes and does not commit or push changes. Check git remote -v before pushing. Repeating setup for the same challenge preserves your current branch and work.

Do not run clean-start after you begin. It resets Copilot customizations, including installed skills.

Step 4: verify your setup

Before starting, make sure Copilot is working:

Check Copilot Status:

  • Look at the bottom-right of VS Code
  • Copilot icon should be visible and say “Ready”

Test Inline Suggestions:

  1. Create a new file (e.g., test.js)
  2. Type: // function to add two numbers
  3. Check that Copilot suggests code.

Test Chat:

  1. Press Ctrl+Shift+I (Windows/Linux) or Cmd+Shift+I (Mac)
  2. Type: “Hello, are you working?”
  3. Check that Copilot responds.

Step 5: start your track

Once your environment is ready:

  1. Open your chosen track guide (e.g., tracks/challenge-1-web-api-track.md)
  2. Follow the recommended challenge sequence
  3. Use the track-specific tips and guidance

Skills you’ll build while driving outcomes

The challenges give you practice with these Copilot capabilities:

1. Chat and agentic capabilities

  • /explain, /fix, /tests commands
  • Agentic Mode - Autonomous multi-step task execution
  • Planning Mode - High-level architectural reasoning
  • Workspace context chat

2. Repository Instructions

  • Stable project context and constraints
  • Coding, testing, and review conventions
  • Mid-session refinement based on what the team learns

3. Custom Agents and skills

  • MCP Servers - Connect external tools and data
  • Custom Agents - Build and use specialized assistants
  • Custom Skills - Capture repeatable workflows

4. Inline suggestions

  • Code completion
  • Multi-line suggestions
  • Ghost text navigation

Challenges

Use the track catalog to choose by role or outcome.

All 31 challenges are available, and each track has a dedicated challenge:

Challenge 0: Product Planning – TaskFlow v2.0 (Track)

Team: Product Owners, Business Analysts, Project Managers Skills: Markdown, GitHub Issues, GitHub Projects, Pull Requests Copilot Focus: Long-form writing, brainstorming, GitHub MCP server for issue/PR management

Plan the next release of a task management platform in five stages. Analyze competitors and define personas with measurable needs. Write and review user stories, then build feature specs aligned to real API endpoints. Resolve conflicting stakeholder requests within a fixed budget. Finish with a release plan that covers risk, rollback, and monitoring. No application code is required.

Challenge 1: Web Development - REST API Builder (Track)

Team: Backend/Web Developers Skills: Express.js/FastAPI, API design, error handling, testing Copilot Focus: Inline completion, /tests command, workspace chat

Build a task management REST API across 5 stages. Start with basic CRUD, add JWT authentication with role-based access, then add SQLite persistence with data relationships. Debug 3 intentional bugs in a broken v2 API module. Finish with load testing, caching, and structured logging to prepare for production.

Challenge 2: ML/AI - Data Analysis & Model Development (Track)

Team: Data Scientists, ML Engineers Skills: Python, pandas, scikit-learn, data visualization Copilot Focus: Jupyter notebooks integration, /explain for algorithms, code generation

Predict customer churn across 5 stages. Find 7+ hidden data quality issues and create visualizations with statistical hypothesis testing. Train models with cost-sensitive evaluation using sklearn Pipelines, then compare imbalance techniques with SHAP interpretability. Deploy a prediction API with drift detection and a model card.

Challenge 3: DevOps - Infrastructure as Code (Track)

Team: DevOps, Platform Engineers Skills: Terraform, Docker, Kubernetes, CI/CD Copilot Focus: Infrastructure patterns, documentation generation, best practices

Build infrastructure for a Node.js app across 5 stages. Start with a multi-stage Dockerfile and Docker Compose, then add Kubernetes with HPA and NetworkPolicy. Use Terraform for Azure (ACR, AKS) with variables and remote state. Debug a broken Key Vault module and add observability. Finish with a CI/CD pipeline, blue/green deployment, and a DR runbook.

Challenge 4: Frontend - Interactive UI Components (Track)

Team: Frontend Developers Skills: React, TypeScript, Component design, State management Copilot Focus: Component scaffolding, TypeScript types, CSS styling

Build an accessible task dashboard with validated CRUD and delete undo. Use Impeccable for a critique-and-fix cycle, then connect a mocked API and test the task flow. Drag-and-drop, offline support, and Storybook are optional.

Challenge 5: QA & Test Automation (Track)

Team: QA Engineers, Quality Assurance Specialists, Manual Testers Skills: Test planning, test case design, bug reporting (no coding experience required) Copilot Focus: AI-assisted test generation, Playwright MCP exploration, Copilot-driven debugging

Test the eShop application across 5 stages. Explore it with Copilot and Playwright MCP to build a test plan. Use Copilot to debug and generate your first automated tests, then expand coverage across browsers with Copilot-generated page objects. Compare AI-driven and human-guided testing approaches. Finish with reporting and a test strategy document.

Challenge 7: Copilot SDK – Release Notes Agent (Track)

Team: Experienced developers (any role) who finished a standard track Duration: 8-12 hours (Advanced) Skills: Node.js, TypeScript, Copilot SDK, GitHub API, custom tool definitions Copilot Focus: Build with the Copilot agent runtime using sessions, streaming, custom tools, and MCP integration

Build a Release Notes Agent with the GitHub Copilot SDK. It fetches merged PRs and categorizes changes. Refine the changelog through conversation, then publish a draft GitHub Release. Use custom tools, streaming responses, and multi-turn sessions.

⚠️ Challenge 7 is significantly harder and longer than the standard challenges.

Challenge 8: Full-Stack Flight Delay Predictor (Track)

Team: Full-Stack Developers, Advanced Participants Duration: 4-6 hours (five-hour core) Skills: Python, pandas, scikit-learn, Flask/FastAPI, TypeScript, frontend frameworks Copilot Focus: Data science in notebooks, API and frontend generation, debugging across the stack

Build one baseline flight-delay model, serve it through a REST API, and create a frontend where users select a day and airport. Use Impeccable to improve the prediction flow while keeping probability wording accurate. Extra models, charts, and Azure deployment are optional.

Challenge 9: Cross-Functional Team Sprint (CityPulse) (Track)

Team: Cross-functional team of 4-6 (Product Owner, Backend Dev, Frontend Dev, QA, DevOps, optional BA) Duration: 4-6 hours (five-hour team core) Skills: GitHub Spark, GitHub Issues/Projects, Express.js/FastAPI, React/Vue, Playwright, Docker, Azure, Terraform Copilot Focus: PO planning and user stories, developer code generation, QA test automation, DevOps infrastructure

Build CityPulse as a cross-functional team. The core covers reports and upcoming events, with an integrated API and tests. Use Impeccable for one QA-verified UI improvement and finish with a tested demo. Dashboard analytics and Azure deployment without a prepared environment are optional.

This challenge requires a team. It is not designed for solo participants.

Challenge 10: Technical Team Sprint (TrailMate) (Track)

Team: Technical team of 2-4, with Backend Dev, Frontend Dev, and DevOps responsibilities. QA is optional; no PO or BA is required. Duration: 4-6 hours (five-hour team core) Skills: Express.js/FastAPI, React/Vue, Playwright, Docker, Azure, Terraform, GitHub Issues/Projects Copilot Focus: Developer code generation, QA test automation, DevOps infrastructure

Build TrailMate from the provided specification. The core covers trail browsing and condition reporting, with API integration and tests. Use Impeccable to improve status and warning clarity. Finish with a tested demo; analytics and Azure deployment without a prepared environment are optional.

This challenge requires a team. It is not designed for solo participants.

Challenge 11: Legacy MUMPS Modernization (Track)

Team: Solo or pair (any developer role) Duration: 8-12 hours (Advanced) Skills: Any modern language (PSL, Java, Python, C#, TypeScript), reverse engineering, testing, financial domain knowledge Copilot Focus: Legacy code comprehension with /explain, cross-language translation, characterization test generation, architecture documentation

Reverse-engineer a MUMPS banking system with 12 routines and about 2,500 lines of code. It handles customers, deposit accounts, teller transactions, consumer loans, interest, and end-of-day batches. Test and extend the system, then translate it to a modern language while preserving its business rules.

Challenge 12: Legacy Code Modernization (Track)

Team: Solo or pair (Java developers) Duration: 6-8 hours Skills: Java 8/17, Spring Boot, Maven, REST APIs, SQL Copilot Focus: Legacy code comprehension with /explain, security auditing, characterization testing, framework migration

Modernize the Acme Bank Account Manager, an undocumented Java 8 / Spring Boot 1.5 application whose contractor left in 2018. It has SQL injection vulnerabilities and deprecated libraries, including Log4j 1.x and Apache HttpClient 4.x. Business logic lives in controllers, with no service layer or tests. Recover the business rules, audit security, and write characterization tests before migrating to Spring Boot 3.x / Java 17+.

Challenge 13: Living Documentation (Track)

Team: Solo or pair (Java developers, tech leads) Duration: 6-8 hours Skills: Java, Javadoc, Mermaid diagrams, Markdown Copilot Focus: Bulk javadoc generation, architecture diagrams, changelog workflow skills, custom agents for PR documentation review

Update the Widget Corp Inventory Manager’s stale javadoc and changelog, which stopped two versions ago. Add Mermaid diagrams for the architecture and data model. Build a repeatable changelog workflow and an agent that reviews PRs for missing documentation.

Challenge 14: Pipeline Factory (Track)

Team: Solo or pair (DevOps, platform engineers, developers) Duration: 6-8 hours Skills: GitHub Actions, Node.js, Shell scripting, CI/CD concepts Copilot Focus: Workflow generation, /fix for debugging broken deployments, reusable workflow design, incident runbook skills

Build CI/CD pipelines for TaskBoard, a kanban app that currently deploys via a shell script with commented-out scp commands. Create GitHub Actions workflows and debug 5 deliberate bugs in a broken staging deployment. Build reusable workflow templates, then generate deployment gates with rollback mechanisms and incident runbooks.

Challenge 15: Backlog Generator (Track)

Team: Solo or pair (product owners, tech leads, scrum masters) Duration: 6-8 hours (no code required) Skills: Agile concepts (Epics, Stories, Acceptance Criteria), Jira/Confluence (optional) Copilot Focus: Spec-to-backlog workflow skills, custom agents for refinement, Atlassian Rovo MCP server for Jira/Confluence integration

Convert three use case specifications of increasing complexity into structured backlogs: Password Reset, Notification Preferences, and Inventory Reorder. Build a reusable skill that produces Epics, Stories, Tasks, and Test Cases following INVEST criteria. Create a refinement agent that reviews generated backlogs for gaps. Optionally push items directly to Jira using the Atlassian MCP server.

Challenge 16: Ops Assistant (Track)

Team: Solo or pair (support engineers, SREs, ops teams) Duration: 6-8 hours Skills: Log analysis concepts, incident management, basic Node.js (optional) Copilot Focus: Custom agents for log analysis, incident routing and runbook workflow skills, error-to-plain-language translation

Build operations tooling for the Order Gateway e-commerce service. Analyze two days of logs containing payment timeouts, database deadlocks, connection pool exhaustion, and OutOfMemoryErrors. Create an agent that explains errors to non-technical support staff. Build an incident routing skill that maps errors to responsible teams, then generate runbooks from historical incident data.

Challenge 17: Spec-to-Ship Accelerator (Track)

Team: Solo or pair (tech leads, senior developers) Duration: 6-8 hours Skills: Full SDLC concepts, Node.js, GitHub Actions Copilot Focus: Workflow skills for specifications, backlogs, technical analysis, implementation, tests, and CI; custom agents for test specifications

Deliver a billing module for an existing multi-tenant SaaS platform. Start with its functional requirements and tenant management API. Build skills that convert the spec into work items and support each handoff. Analyze the existing code, implement the stories, and use a custom agent to create test specifications. Finish with a CI pipeline.

Challenge 18: COBOL Banking Modernization (Track)

Team: Solo or pair (any developer role) Duration: 4-6 hours (five-hour core) Skills: COBOL (no prior experience needed), Node.js/TypeScript or Java, React, reverse engineering, testing Copilot Focus: Legacy code comprehension with /explain, cross-language translation, characterization test generation, full-stack modernization

Trace and characterize one COBOL account-transfer workflow, then expose it through a local API and React UI. Use Impeccable to review the teller journey without changing characterized behavior. Full-system translation and new banking features are optional.

Challenge 19: WCF Banking Modernization (Track)

Team: Solo or pair (.NET developer) Duration: 6-10 hours (Intermediate to Advanced) Skills: C#, WCF/SOAP concepts, ASP.NET Core Web API, REST design, xUnit Copilot Focus: SOAP service contract comprehension, fault contract analysis, REST migration, characterization testing

Reverse-engineer the legacy Meridian Savings Bank WCF service, built circa 2010-2012 and now running on CoreWCF and .NET 8. Understand its service contracts, data contracts, and fault conditions, then port the business logic to a REST API using ASP.NET Core Web API. Find the bugs and decide whether to preserve or fix them during migration.

Challenge 20: PowerShell Automation (Track)

Team: Solo (sysadmin or IT Pro) Duration: 4-6 hours (Intermediate) Skills: PowerShell 7+, Pester 5, PSScriptAnalyzer, Az module, GitHub Actions Copilot Focus: Script comprehension, bug detection, error handling, test generation, module packaging, CI pipeline creation

Repair three inherited PowerShell scripts from the fictional Contoso IT team. They find stale accounts, clean disks, and tag Azure resources. Fix their bugs, add error handling and logging, and write Pester tests. Run static analysis and add a GitHub Actions CI pipeline.

Challenge 21: Azure Terraform Foundation (Track)

Team: Platform Engineers, DevOps Engineers, Cloud Engineers Skills: Terraform, Azure networking, managed identity, Key Vault, GitHub Actions Copilot Focus: Infrastructure review, plan explanation, module extraction, CI workflow generation

Build an Azure Terraform foundation across 5 stages. Bootstrap remote state and naming rules, then provision a small Azure platform around Container Apps. Connect managed identity and Key Vault. Refactor the configuration into reusable modules for multiple environments, then add CI guardrails and a drift response runbook.

Challenge 22: Secure Release Review (Track)

Team: Application security engineers, senior .NET developers, technical leads, platform engineers Duration: 4-6 hours Skills: .NET 8, threat modeling, authorization review, security testing, release evidence Copilot Focus: Code review, targeted remediation, regression tests, evidence-based release decisions

Review a .NET 8 payments API before release. Trace trust boundaries, prioritize security findings, prove targeted fixes with tests, review dependencies and secrets, and finish with a defensible release checklist.

Challenge 23: Merger Integration Architecture (Track)

Team: Solution architects, enterprise architects, integration leads, technical program leads Duration: 4-6 hours Skills: Azure architecture, system boundaries, API and event contracts, ADRs, transition planning Copilot Focus: Evidence analysis, architecture options, contract review, migration risk

Design an Azure integration foundation for two companies after a merger. Resolve conflicting system evidence, define capability ownership and contracts, record key decisions, and sequence a transition without a big-bang cutover.

Challenge 24: Peak-Load Database Rescue (Track)

Team: Database administrators, database reliability engineers, data platform engineers Duration: 4-6 hours Skills: SQL Server, Azure SQL, T-SQL, execution plans, safe schema migration Copilot Focus: Query evidence, tuning review, migration safety, operational runbooks

Diagnose a SQL Server workload under peak load, reduce measured query cost, and ship a backward-compatible schema change. The required checks run locally, with Azure SQL available as an optional target validation.

Challenge 25: Enterprise API Guardrails (Track)

Team: API platform engineers, Azure platform engineers, technical leads, developer experience engineers Duration: 4-6 hours Skills: OpenAPI, Azure API Management, Microsoft Entra ID, contract checks, observability Copilot Focus: Contract comparison, lifecycle review, policy validation, platform onboarding

Create a governed path for teams publishing APIs through Azure API Management. Compare inconsistent contracts, define standards and exceptions, test policies locally, and document the onboarding evidence required for platform review.

Challenge 26: Developer Onboarding Repair (Track)

Team: Technical writers, developer educators, developer experience practitioners, engineers Duration: 4-6 hours Skills: Markdown, information architecture, reader testing, Node.js documentation checks Copilot Focus: Documentation diagnosis, technical accuracy, example verification, editorial review

Repair fragmented onboarding for a working CLI and SDK. Test real reader journeys, settle terminology and page boundaries, correct examples against the software, and add lightweight checks that keep the guidance usable.

Challenge 27: Offline Field Service App (Track)

Team: Mobile developers, frontend engineers, test engineers, technical leads Duration: 4-6 hours Skills: React Native, Expo, TypeScript, offline persistence, synchronization testing Copilot Focus: State-flow tracing, failure analysis, mobile accessibility, release evidence

Make a React Native field-service workflow dependable when connectivity and device permissions fail. Preserve technician work across restarts, define conflict behavior, test degraded modes, and verify the mocked Azure Functions synchronization contract.

Challenge 28: Work IQ Workplace Assistant (Track)

Team: Delivery leads, technical leads, developers, information governance partners Duration: 4-6 hours Skills: Microsoft Work IQ, GitHub Copilot CLI, Microsoft Entra ID, Microsoft 365, evidence review Copilot Focus: Permission-aware retrieval, evidence mapping, handoff drafting, human approval gates

Build a reviewed project handoff from approved Microsoft 365 context. Retrieve a narrow set of meetings, messages, emails, or documents, create an evidence-backed action register, and keep all write actions behind human approval.

Challenge 29: Inherit and Evolve an Application (Track)

Team: C# developers, full-stack engineers, QA engineers, technical leads Duration: 4-6 hours Skills: ASP.NET Core, SQLite, code comprehension, regression testing Copilot Focus: Tracing unfamiliar code, investigating defects, adding features safely

Take over a working equipment-booking app. Verify how it behaves, fix a reported cancellation defect, then add a waitlist through the UI and backend. The starter includes seeded data and passing baseline tests, plus an application Dockerfile and a dedicated devcontainer. The Challenge 29 workflow runs the starter tests and checks application-container startup and restart when its code changes.

Challenge 30: Spec-Driven Feature Delivery with GitHub Spec Kit (Track)

Team: Developers, QA engineers, technical leads Duration: 4-6 hours Skills: TypeScript, HTTP APIs, acceptance testing, specification review Copilot Focus: Spec Kit’s supplied workflow in Copilot CLI, from clarification to verified code

Add approvals to a working service-request app, then introduce a second approval for high-cost requests. Keep the same feature specification current through the change. The starter includes a browser UI and baseline tests; participants implement the approval rules. No deployment or external issue tracker is needed.

Learning resources

Examples and templates

Use the shared examples guidance to find current examples. Search for terms that match the artifact you need, such as “repository instructions”, “custom agent”, or “workflow skill”.

Quick tips

Describe the expected behavior and reference existing code. Refine suggestions through conversation, and review generated code before accepting it. Use /explain, /fix, and /tests for focused requests.

Shortcut Action
Tab Accept suggestion
Esc Dismiss suggestion
Alt+] Next suggestion
Alt+[ Previous suggestion
Ctrl+Shift+I Open Copilot Chat

Tips for success

  1. Write Clear Comments

    // ❌ Bad: "do stuff"
// ✅ Good: "Validate email format and return true if valid, false otherwise"

  2. Ask Copilot to explain code you do not understand.

  3. Review generated code and test its behavior.

  4. Refine your request when a suggestion misses the requirements.

Common issues

Problem Solution
Copilot not suggesting Check status icon, ensure signed in, restart VS Code
Wrong suggestions Be more specific, provide more context, try chat instead
Environment issues Codespaces: rebuild container; Local: check tool versions

Session format

Track-based learning

Choose a track based on your role and follow the curated path:

  • Each track provides a recommended sequence of challenges
  • Track-specific tips and guidance
  • Clear learning objectives
  • Estimated time for completion

See Tracks Overview to choose your path.

Alternative: individual challenges

Choose challenges based on your interests. Each includes starter code and objectives, with optional tasks for further work.

Team demos (1-2 hours)

  • Present your solutions
  • Share interesting Copilot interactions
  • Discuss productivity gains and lessons learned
  • Compare experiences across different tracks

Best practices session (1 hour)

  • Review common patterns
  • Share tips and tricks discovered
  • Q&A with Copilot experts

Success metrics

Each team should demonstrate its result and explain the impact, such as time saved or risk reduced. Record how Copilot helped and which practices the team will use in daily work.

Copilot usage and chat counts can support that evidence. Judge success by the work delivered, not tool activity.

Collaboration

  • Use GitHub Issues to ask questions
  • Share discoveries in Discussions
  • Help teammates learn new Copilot features
  • Document your journey in your challenge folders

Feedback

After completing the session, please share:

  • What worked well
  • What could be improved
  • Productivity improvements you experienced
  • Features you found most valuable

Next steps

After the session:

  1. Apply Copilot to your daily work
  2. Explore advanced features and settings
  3. Refine your team’s repository instructions, custom agents, and custom skills
  4. Share knowledge with your organization
  5. Measure and track productivity improvements

Support and resources

  • Choose Your Track - Outcome-driven learning paths organized by role and outcome
  • Challenge Set Builder - Available on the published site; coaches can curate challenge sets and generate student URLs
  • Troubleshooting Guide - Common issues and solutions
  • Facilitator Guide - For GitHub Copilot Adoption delivery session organizers
  • Contributing Guide - Help improve this content

Help

Use the Track Selection Guide to choose a challenge and the Troubleshooting Guide for setup problems. Report bugs through this repository’s issues.

View the full README on GitHub

Recommended Tools

Try a different keyword or remove a filter.

Install

npx skillfish add microsoft/frontier-ghcp-rvas
New to MCP? Start with the mcpskill.org guide →