GitHub Copilot Skills · Agents · Copilot App · Local Models · MCP · CLI

GitHub Copilot has evolved from an autocomplete tool into a fully agentic development environment. It now combines AI code completion, multi-turn chat, multi-file editing, autonomous coding agents, and deep integrations with your development tools — all powered by a choice of leading AI models.

Interfaces

Plans & AI Credits

On June 1, 2026 GitHub retired premium-request quotas in favor of GitHub AI Credits — usage-based billing where every chat, agent, CLI, and code-review interaction is metered by input/output/cached tokens. 1 AI Credit = $0.01. Code completions and Next Edit Suggestions stay unlimited and credit-free on every paid plan.

Model Lineup

Custom instructions let you provide Copilot with persistent context — coding standards, architecture patterns, tech stack, naming conventions — so you never have to repeat them in every chat prompt. Instructions are injected invisibly into each request.

copilot-instructions.md

The primary instruction file. Placed at .github/copilot-instructions.md. Applied to every Copilot request in the repository across VS Code, JetBrains, Copilot CLI, and the cloud agent.

# Project: E-Commerce Platform

## Stack
- Backend: ASP.NET Core 8, C# 12, EF Core 8
- Frontend: React 18, TypeScript 5, Tailwind CSS 3
- Database: PostgreSQL 16, Redis 7
- Cloud: Azure (App Service, Blob Storage, Service Bus)

## Code Style
- Use async/await throughout; never block threads
- Prefer records over classes for DTOs
- Use primary constructors (C# 12) for simple classes
- All public APIs must have XML doc comments
- No magic strings — use constants or enums

## Testing
- Use xUnit for unit tests, Playwright for E2E
- Test file mirrors source: `src/Foo.cs` → `tests/FooTests.cs`
- Mock external dependencies; never hit real APIs in unit tests

## Git
- Branch names: `feat/`, `fix/`, `chore/`, `docs/`
- Commit format: Conventional Commits (feat: add X)
- PRs require passing CI and one human approval

Path-Specific Instructions (.instructions.md)

Files named *.instructions.md in .github/instructions/ apply only when Copilot works on files matching the applyTo glob in the YAML frontmatter. Supported in VS Code, JetBrains, and the cloud agent.

---
applyTo: "src/ui/**/*.{tsx,jsx}"
---

## React Component Standards
- Use functional components only; no class components
- Props interface must be named `{ComponentName}Props`
- Use `React.memo` for expensive pure components
- Prefer `useCallback` for event handlers passed to children
- All components must be exported as named exports
- Use Tailwind utility classes; no inline styles

AGENTS.md — Open Standard

AGENTS.md is an open standard (Linux Foundation / Agentic AI Foundation) for guiding any AI coding agent — Copilot, Claude Code, Gemini CLI, etc. Copilot treats it as additional instructions alongside copilot-instructions.md.

# AGENTS.md — Guidance for AI Coding Agents

## Build & Test
- Build: `dotnet build ./src`
- Run tests: `dotnet test ./tests`
- Lint: `dotnet format --verify-no-changes`
- E2E: `npx playwright test` (requires running server on :5000)

## Important Rules
- Never commit secrets or connection strings
- Do not modify `*.lock` files manually
- Run `dotnet format` before creating any PR
- PRs must not decrease test coverage below 80%

## Architecture
- Domain logic lives in `src/Domain/`
- Never import Domain → Infrastructure (dependency rule)
- Use the MediatR pattern for all commands/queries

Personal Instructions

Across all projects, create ~/.copilot/copilot-instructions.md for personal preferences (preferred language, verbosity, explanation style). Also set via COPILOT_CUSTOM_INSTRUCTIONS_DIRS env var to point to a folder of instruction files.

Organisation-Level Instructions

Copilot Enterprise supports instructions at the GitHub Organisation level — automatically applied to all repos in the org. Set by org owners; synced to VS Code via github.copilot.chat.organizationInstructions.enabled.

Prompt Files

Reusable prompts stored in .github/prompts/ as *.prompt.md — invoke them from chat with /prompt-name or attach them manually. Great for repetitive workflows like "explain this code" or "write tests".

---
mode: 'agent'
description: 'Generate comprehensive xUnit tests for the selected code'
---

Analyze the selected code and generate comprehensive xUnit tests:

1. Cover all public methods and their edge cases
2. Use `[Theory]` + `[InlineData]` for parameterized tests
3. Mock all external dependencies using Moq
4. Follow Arrange-Act-Assert pattern
5. Test file should be placed in `tests/` mirroring `src/`
6. Include at least one test for the unhappy path (exceptions)

Reference our testing conventions from `.github/instructions/tests.instructions.md`.

Custom Chat Modes

Define a persona or specialized workflow mode in .github/chatmodes/*.chatmode.md. Users switch to it in the chat dropdown. A mode sets a system persona + tools available.

---
description: 'Senior DBA: database design, query optimization, index strategy'
tools:
  - pgsql_connect
  - pgsql_query
  - github
---

You are a Senior Database Administrator specializing in PostgreSQL 16.
When reviewing queries: always check for missing indexes, N+1 problems,
and missing pagination. Use EXPLAIN ANALYZE when you have database access.
Prefer CTEs over subqueries for readability. Always consider connection
pooling and transaction scope.

Agent Skills (announced December 2025) are self-contained folders of instructions, scripts, and resources that Copilot loads when relevant to your task. Unlike custom instructions (which always apply), skills are loaded on-demand — keeping your context window efficient.

Skill Directory Locations

Creating a Skill

.github/skills/github-actions-debugging/
├── SKILL.md               # Required — frontmatter + instructions
├── checklist.md           # Referenced by SKILL.md
└── examples/
    ├── passing-run.log    # Example for context
    └── failing-run.log    # Example of common failure

---
name: github-actions-debugging
description: |
  Guide for debugging failing GitHub Actions workflows.
  Use this when asked to debug failing GitHub Actions workflows,
  CI failures, or pipeline errors in pull requests.
---

## Debugging Failing GitHub Actions Workflows

Use the GitHub MCP Server tools to investigate:

1. Use `list_workflow_runs` to find recent runs for the PR and their status
2. Use `get_workflow_run` to get details of the specific failing run
3. Use `list_workflow_run_logs` to retrieve the full job logs
4. Look for the first `Error:` or `FAILED` line — that's the root cause
5. Check `checklist.md` for common failure patterns

## Common Fixes
- Missing secret → check repo Settings > Secrets
- Cache invalidation → update cache key or clear manually  
- Outdated action version → pin to latest SHA
- Flaky test → check test for async timing issues

See `examples/` for reference logs.

SKILL.md Frontmatter Reference

Installing Community Skills

# Via GitHub CLI (gh v2.90.0+)
gh skill install github/awesome-copilot <skill-name>

# Via Copilot CLI
copilot plugin install <plugin-name>@awesome-copilot

# Register marketplace first (older Copilot CLI versions)
copilot plugin marketplace add github/awesome-copilot
copilot plugin install <plugin-name>@awesome-copilot

# Or copy manually into your skills directory
# cp -r path/to/skill ~/.copilot/skills/skill-name/

Popular Skills from awesome-copilot

Custom agents are specialized versions of Copilot for specific tasks. Each agent has its own persona, tools, MCP servers, and system instructions. Switch between agents in the chat interface or invoke via CLI.

Creating Custom Agents

---
name: accessibility-reviewer
description: |
  Runtime accessibility specialist. Use for keyboard flows,
  focus management, dialog behavior, form errors, and
  evidence-backed WCAG 2.1 validation in the browser.
tools:
  - playwright       # browser automation for testing
  - github           # create issues for violations
mcp_servers:
  - playwright-mcp
---

You are an expert accessibility engineer specializing in WCAG 2.1 AA.

When reviewing code changes:
1. Use Playwright to navigate the page and test keyboard flows
2. Check: focus indicators visible, tab order logical, dialogs trap focus
3. Verify form errors are announced to screen readers (aria-live)
4. Validate color contrast meets 4.5:1 for normal text
5. Create GitHub issues for each WCAG violation found

Report violations with: WCAG criterion, evidence (screenshot/code), fix.

---
name: dotnet-architect
description: |
  Senior .NET architect for complex delivery: designs .NET 6+ systems,
  decides between parallel subagents and orchestrated team execution,
  documents lessons learned, and captures durable project memory.
tools:
  - github
  - terminal
  - workspace
---

You are a Senior .NET Architect with 15+ years experience.
Specialise in: Clean Architecture, CQRS + MediatR, EF Core, 
Azure deployment, performance tuning, and distributed systems.

When given a complex task:
- Break into sub-tasks, identify which can run in parallel
- Document architectural decisions with rationale
- Capture lessons learned in `docs/adr/` as ADR files
- Prefer boring technology over clever solutions

Custom Agent Frontmatter

Copilot Cloud Agent (Coding Agent)

The cloud agent works asynchronously in the background — you assign a GitHub Issue to Copilot, and it researches, plans, writes code, pushes commits to a draft PR, and pings you for review. Available in GitHub.com, VS Code, CLI, and Mobile.

Sub-Agents & Orchestration

Sub-agents are short-lived, narrowly-scoped agents that a parent session delegates work to — each running its own context window so the main conversation doesn't get cluttered with exploration noise or tool-call transcripts. Copilot CLI ships three built-in sub-agents out of the box:

Custom Orchestrator Pattern

---
name: pure-orchestrator
description: |
  Pure orchestration agent. Decomposes requests, delegates ALL work
  to sub-agents, validates outcomes, and repeats until complete.
---

You ONLY orchestrate. You NEVER write code yourself.

For every request:
1. Analyze and decompose into discrete tasks
2. Identify which tasks can run in parallel
3. Delegate each to the appropriate specialist sub-agent:
   - `explore` → codebase reconnaissance, read-only questions
   - `code-review` → independent review pass before reporting done
   - `accessibility-reviewer` → a11y concerns
   - `dotnet-architect` → backend design
   - `test-agent` → test generation
4. Collect outputs and validate against acceptance criteria
5. If validation fails, delegate corrective tasks
6. Report summary when all tasks pass validation, including
   total credits consumed across parent + all sub-agent sessions

The GitHub Copilot app is a standalone desktop client — separate from any IDE, separate from github.com — for macOS, Windows, and Linux. It expanded technical preview at Microsoft Build 2026 (June 2) and reached General Availability on June 17, 2026. Where VS Code excels at inline completion and quick edits, the Copilot app is a control plane for supervising multiple parallel agent sessions tied directly to your GitHub issues, PRs, branches, and repositories.

Canvases

Canvases are bidirectional, structured work surfaces — dashboards, trackers, decision logs, document previews — that both the agent and you can read from and write to at the same time. The agent updates a canvas as it works; you edit, reorder, approve, or redirect work directly on the same surface, rather than typing a correction back into chat.

Agent Merge & Sandboxes

Agent Merge handles the PR-through-merge pipeline end to end: an agent's changes land in a worktree, run through cloud sandboxes for validation, open as a PR, and — once you approve — merge, without you manually shepherding each step. Choose the model behind each session, connect MCP servers, and package recurring work as reusable skills or scheduled automations, all from the app.

Copilot SDK

The Copilot SDK reached General Availability alongside the app, in seven languages, letting teams embed the same agent runtime that powers the Copilot app — sessions, worktrees, canvases, MCP — into their own internal tools rather than only consuming it through GitHub's own surfaces.

The Model Context Protocol (MCP) is an open standard that lets Copilot connect to external tools, APIs, and data sources. In agent mode, Copilot uses MCP tools to complete agentic loops without switching context.

GitHub MCP Server

The GitHub local MCP server is open source and natively supported in VS Code. It enables Copilot to interact with your GitHub repositories, issues, PRs, workflows, and more — directly from your conversation.

MCP Configuration

Configure MCP servers in mcp.json (workspace or user level). VS Code, JetBrains, Eclipse, and Xcode each have an MCP settings UI.

{
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"  // OAuth — no token needed
    },
    "playwright": {
      "type": "stdio",
      "command": "npx",
      "args": ["@playwright/mcp-server"]
    },
    "postgres": {
      "type": "stdio",
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "${env:DATABASE_URL}"
      }
    }
  }
}

Copilot no longer requires GitHub-hosted model routing. Since April 7, 2026, Copilot CLI supports Bring Your Own Key (BYOK) and fully local models — connect Azure OpenAI, Anthropic, any OpenAI-compatible endpoint, or a model running entirely on your own machine via Ollama, LM Studio, vLLM, or Foundry Local. VS Code and JetBrains ship the same idea through a Language Models / BYOK settings surface.

VS Code & JetBrains: BYOK / Model Providers

Copilot CLI: Ollama, LM Studio & vLLM

Copilot CLI's BYOK path uses environment variables read at startup — no config file required. Models must support tool calling and streaming; GitHub recommends at least a 128K-token context window for usable agentic behavior.

# 1. Install Ollama and pull a coding-capable model
ollama pull qwen3-coder:30b

# 2. Point Copilot CLI at your local Ollama server
export COPILOT_PROVIDER_BASE_URL=http://localhost:11434
export COPILOT_MODEL=qwen3-coder:30b

# 3. Fully air-gapped: disable telemetry and any GitHub calls
export COPILOT_OFFLINE=true

# 4. Launch — no GitHub sign-in required in offline mode
copilot

# In LM Studio: Developer tab → toggle server on → load a model

export COPILOT_PROVIDER_BASE_URL=http://localhost:1234/v1
export COPILOT_MODEL=google/gemma-3-1b
export COPILOT_OFFLINE=true

copilot  # run from inside your project directory

export COPILOT_PROVIDER_BASE_URL=https://your-endpoint.example.com/v1
export COPILOT_PROVIDER_API_KEY=sk-your-key-here
export COPILOT_MODEL=your-model-name

# See all provider examples built into the CLI:
copilot help providers

Hooks

Hooks execute custom shell commands at key points during an agent session. Use them for validation, logging, security scanning, or enforcing policy without modifying the agent itself.

{
  "hooks": [
    {
      "event": "preToolUse",
      "tool": "write_file",
      "command": "scripts/validate-no-secrets.sh",
      "description": "Scan for secrets before writing files"
    },
    {
      "event": "postToolUse",
      "tool": "run_terminal_command",
      "command": "scripts/log-command.sh",
      "description": "Audit log all terminal commands executed by agent"
    },
    {
      "event": "preToolUse",
      "tool": "create_pull_request",
      "command": "scripts/enforce-pr-template.sh",
      "description": "Verify PR has required sections before creation"
    }
  ]
}

Agentic Workflows

Agentic Workflows bring Copilot's coding agent directly into GitHub Actions. They run on repository events (push, PR, schedule) and can autonomously perform multi-step development tasks in CI.

---
name: dependency-update-agent
description: |
  Automatically review dependency update PRs, run tests,
  and approve safe updates. Triggered on Dependabot PRs.
on:
  pull_request:
    types: [opened]
    branches: [main]
permissions:
  contents: read
  pull-requests: write
safe-outputs: true
---

When a Dependabot PR is opened:
1. Read the dependency diff to understand what changed
2. Check if the package has known CVEs (use GitHub Security Advisory)
3. Review the CHANGELOG for breaking changes
4. If patch/minor version with no CVEs: approve the PR
5. If major version or CVE found: add a review comment explaining

Plugins

Plugins bundle related agents, skills, commands, and hooks into a single installable package. They are the unit of distribution for the awesome-copilot marketplace.

{
  "name": "azure-devops-plugin",
  "version": "1.2.0",
  "description": "Complete Azure DevOps toolset for Copilot",
  "agents": ["agents/azure-iac-agent.agent.md"],
  "skills": ["skills/azure-iac-export/", "skills/bicep-review/"],
  "mcp_servers": [
    {
      "name": "azure-mcp",
      "source": { "npm": "@azure/mcp-server" }
    }
  ]
}

# Install from awesome-copilot marketplace (registered by default)
copilot plugin install azure-devops@awesome-copilot

# Install from any GitHub repo
copilot plugin install owner/repo

# List installed plugins
copilot plugin list

# Validate a plugin during development
npm run plugin:validate

GitHub Copilot CLI (GA February 2026) brings a full agentic development environment to the terminal. It plans, builds, reviews, and remembers across sessions — with skills, agents, hooks, and plugins — all without leaving the terminal.

# Install via npm
npm install -g @github/copilot-cli

# Or via homebrew
brew install gh-copilot

# Authenticate
copilot auth login

# Initialize project (generates instructions + AGENTS.md)
copilot /init

# Start a session
copilot

CLI Commands & Flags

Built-in CLI Agents

# Start and describe a task
copilot
> Add input validation to all API endpoints in src/api/

# Copilot plans, writes code, runs tests automatically
# Review what changed
> /diff

# Delegate a related task to cloud agent while you continue
> /delegate Write E2E Playwright tests for the new validation endpoints

# Check for related open issues via GitHub MCP
> Are there any open issues related to input validation?

# Switch to plan mode before a big change (Shift+Tab)
# Copilot asks clarifying questions, shows plan, waits for approval

# Use in CI pipeline (non-interactive)
copilot -p "Review the diff and check for security issues" \
  --allow-tools workspace,github \
  --deny-tools terminal

The quality of Copilot's output scales directly with the quality of your prompts. These principles apply across chat, agent mode, and instructions files.

Prompt Anatomy

Prompting Principles

Instructions File Writing Tips

Power-User Tips

Slash Commands Reference

The github/awesome-copilot repository is a community-driven collection of instructions, agents, skills, hooks, workflows, and plugins — maintained by GitHub and the developer community.

Contributing to awesome-copilot

# Fork the repo and clone
git clone https://github.com/YOUR_USERNAME/awesome-copilot
cd awesome-copilot

# Create your content (skill, agent, instruction, etc.)
# File names: lower-case-with-hyphens.md

# Run validation
npm run skill:validate      # validate SKILL.md frontmatter
npm run plugin:validate     # validate plugin.json

# Build (required — updates README automatically)
npm run build

# Fix line endings (required — CI will fail otherwise)
bash eng/fix-line-endings.sh

# PRs now target 'main' directly (changed from 'staged' in 2026)
git checkout -b feat/my-awesome-skill
git push origin feat/my-awesome-skill
# Open PR → base: main

Required Frontmatter Checklist

Recommended Repository Structure

Quick-Start: First 30 Minutes