GitHub Copilot Workflow Cheatsheet

1

Copilot Architecture & Flow

What: How your prompt flows through Copilot — context is gathered, routed via a proxy to the AI model, filtered for safety, and returned as a response.

Key Stages

Context gathering — workspace files, open tabs, selections, instructions
Pre-model filters — responsible AI, content exclusion
Proxy service — routes to chosen model, applies policies
AI model — user picks model or auto-select (10% discount)
Post-model filters — duplicate code detection, safety checks

Installation

ext install GitHub.copilot
ext install GitHub.copilot-chat

💡 Your code is never stored or used for training (Business/Enterprise). Prompts are not retained after the response is delivered.

Use Cases

Debug unexpected output — understand why Copilot gave a wrong answer (check if context was gathered correctly)

Explain to stakeholders — describe how code never leaves the proxy pipeline (security/compliance reviews)

📚 Sources: GitHub Docs — Copilot Features

2

Chat Experience

What: The conversational AI panel in VS Code. Use slash commands, context variables (#), and participants (@) to give Copilot precise context for better answers.

Slash Commands

Command	Action	Command	Action
`/explain`	Explain selected code	`/fix`	Fix problems in code
`/tests`	Generate unit tests	`/new`	Scaffold new project
`/clear`	New chat session	`/help`	Copilot quick reference
`/delegate`	Send to coding agent	`/search`	Workspace search
`/init`	Generate instructions	`/compact`	Compress context

Context Variables (#)

#fileInclude file content

#selectionSelected text

#codebaseFull workspace context

#problemsError/warning diagnostics

#changesGit changes (diff)

#fetchFetch a web page

#terminalLastCommandLast terminal output

#block #class #functionCode scope

Chat Participants (@)

@workspaceProject structure & code

@vscodeVS Code commands & features

@terminalTerminal shell context

@githubGitHub-specific skills

@azureAzure services help

Voice Chat

Install ms-vscode.vscode-speech
Dictate prompts hands-free

Use Cases

/explain + #file — "Explain the auth flow in #file:auth.ts" (onboard to unfamiliar code)

/fix + #problems — "Fix all errors in #problems" (resolve build failures in one prompt)

📚 Sources: VS Code Docs — Copilot Chat

3

Code Completions

What: Real-time ghost text suggestions as you type. Copilot predicts your next lines of code based on context — accept with Tab, dismiss with Esc.

Keyboard Shortcuts

TabAccept full suggestion

EscDismiss suggestion

Alt+] / Alt+[Cycle alternatives

Ctrl+→Accept word by word

Enable / Disable

Toggle from Copilot icon in status bar
Disable for specific languages in settings
Snooze — temporarily pause suggestions

Completions Model

Change model in settings for inline suggestions
Premium models consume premium requests
Free plan: 2,000 completions/month

💡 Write a descriptive comment first — Copilot uses it as a prompt to generate the function body below.

Use Cases

Write a function from a comment — type // fetch user by email, Copilot generates the implementation

Auto-complete test cases — write one it("should...") block and Tab through the rest

📚 Sources: VS Code Docs — AI Suggestions

4

Next Edit Suggestions (NES)

What: Predicts your next edit based on recent changes, not just cursor position. Jumps you to the right location and suggests the change — great for repetitive multi-location refactors.

How It Works

Monitors your editing patterns across files
Suggests edits at locations you haven't navigated to yet
Shows arrow indicator → jump to suggested edit
Tab to accept, Tab again to jump to next

Why Use It

Rename variables across multiple locations
Apply consistent pattern changes
Add missing imports after using a new API

Use Cases

Rename userId → accountId — change one occurrence, NES finds and fixes the rest across files

Add error handling — wrap one function in try/catch, NES suggests the same for similar functions

📚 Sources: VS Code Docs — Next Edit Suggestions

5

Inline Chat

What: Chat with Copilot directly inside your editor or terminal without switching to the sidebar. Get targeted code edits, command generation, and image-to-code conversion in context.

In Editor

⌘I (Mac) / Ctrl+I (Win) — open inline chat
Select code first for targeted edits
Supports context vars & model selection
Preview diff before accepting

In Terminal

⌘I in terminal — generate commands
Copilot understands shell context
Generates and explains terminal commands

Vision Input

Attach images to chat prompts
UI mockups → code generation

Use Cases

Refactor selected code — select a function, ⌘I → "Extract this into a custom hook" (targeted in-place edit)

Generate shell commands — ⌘I in terminal → "Find all .log files larger than 100MB and delete them"

📚 Sources: VS Code Docs — Inline Chat

6

Model Selection & Premium Requests

What: Choose from 20+ AI models. Each model has a premium request multiplier — included models (GPT-4.1, GPT-4o, GPT-5 mini) cost 0×, while advanced models cost 1×–30×. Manage your monthly budget accordingly.

Model Multipliers (Paid Plans)

Model	Rate
GPT-4.1 / GPT-4o / GPT-5 mini	0× included
Raptor mini	0× included
Grok Code Fast 1	0.25×
Claude Haiku 4.5 / Gemini 3 Flash	0.33×
GPT-5.1-Codex-Mini / GPT-5.4 mini	0.33×
Sonnet 4 / 4.5 / 4.6	1×
Gemini 2.5 Pro / 3 Pro / 3.1 Pro	1×
GPT-5.1 / 5.2 / 5.4 + Codex variants	1×
Claude Opus 4.5 / 4.6	3×
Opus 4.6 fast mode (preview)	30×

Plans & Allowances

Plan	Included
Free	2K completions + 50 premium/mo
Pro / Student	Unlimited + premium allowance
Pro+	Unlimited + higher premium
Business	Unlimited + org premium pool
Enterprise	Unlimited + enterprise premium

💡 Auto model selection gives 10% multiplier discount on paid plans.

⚠️ Unused requests don't carry over. Counters reset on 1st of each month (UTC).

📌 Models are frequently added and deprecated. Multipliers may change. Check official docs for the latest model list.

Use Cases

Save budget on simple tasks — use GPT-4.1 (0×) for boilerplate, switch to Sonnet 4.6 (1×) for complex refactors

Architecture decisions — use Opus 4.6 (3×) for design reviews where quality matters more than cost

📚 Sources: GitHub Docs — Plans & Models · Model Availability by Plan

7

Custom Instructions

What: Markdown files that automatically inject your coding standards, conventions, and project context into every Copilot request — no need to repeat yourself in prompts.

Always-On Files

copilot-instructions.md.github/ folder

AGENTS.mdRoot or subfolders

CLAUDE.mdRoot, .claude/, ~/

For Specific Tasks

Code reviewreviewSelection.instructions

CommitscommitMessageGeneration

PR descriptionspullRequestDescription

Priority (High → Low)

1. Personal (user-level)
2. Repository (.github/ or AGENTS.md)
3. Organization

Generate Instructions

/init — auto-generate for workspace
/create-instruction — AI-assisted
Chat debug view → verify loaded files

Use Cases

Enforce coding style — add "Always use single quotes and 2-space indentation" to copilot-instructions.md

Standardize commit messages — set commitMessageGeneration instructions to follow Conventional Commits format

📚 Sources: VS Code Docs — Custom Instructions

8

Instructions.md Files

What: Targeted instruction files (.instructions.md) that apply conditionally based on file glob patterns or semantic matching — e.g., Python rules only for *.py files.

Format

---
name: 'Python Standards'
description: 'Python conventions'
applyTo: '**/*.py'
---
# Python coding standards
- Follow PEP 8 style guide
- Use type hints for all functions

Locations

Workspace.github/instructions/

Claude fmt.claude/rules/

User~/.copilot/instructions/

💡 Type /instructions in chat to open Configure menu.

Use Cases

Python-only rules — create python.instructions.md with applyTo: '**/*.py' for PEP 8, type hints, docstrings

React testing patterns — create react-tests.instructions.md with applyTo: '**/*.test.tsx' for RTL best practices

📚 Sources: VS Code Docs — Instructions Files

9

Reusable Prompt Files

What: Saved prompt templates (.prompt.md) you invoke as slash commands. Encode frequent tasks like scaffolding components or running reviews — type /prompt-name instead of re-writing the prompt.

Encode common tasks as .prompt.md files
Invoke via /prompt-name in chat
Workspace: .github/prompts/
User: profile prompts/ folder

Format

---
description: 'Create React form'
agent: agent
tools: ['editFiles', 'search']
model: GPT-5.2
---
Generate a React form component
with validation for ${input:fields}

Quick Commands

/create-promptAI-generate a prompt file

/promptsConfigure prompt files

💡 Reference instructions via Markdown links. Use ${selection} for flexibility.

Use Cases

One-command API scaffold — /create-api generates REST endpoint with controller, service, tests, and OpenAPI spec

Standardized code review — /review-pr checks for security, performance, and accessibility issues every time

📚 Sources: VS Code Docs — Prompt Files

10

Chat Modes & Custom Agents

What: Agents are specialized AI personas with their own tools, instructions, and model. Create a security reviewer, planner, or any role — each with restricted tool access and handoffs to other agents.

Built-in Modes

Mode	Purpose
Ask	Read-only Q&A, no code changes
Edit	Direct code edits
Agent	Autonomous tool use + edits
Plan	Create plan before implementation

Custom Agent File (.agent.md)

---
description: 'Security reviewer'
tools: ['search', 'readFile']
model: Claude Sonnet 4.6
handoffs:
  - label: Fix issues
    agent: implementation
---
Review code for OWASP Top 10...

Agent Frontmatter Fields

descriptionShown as placeholder text

toolsList of available tools

agentsAllowed subagents (* = all)

modelAI model (string or priority list)

handoffsSequential workflow transitions

targetvscode or github-copilot

mcp-serversMCP server configs

hooksAgent-scoped hooks (Preview)

Locations

Workspace.github/agents/

Claude fmt.claude/agents/

User~/.copilot/agents/

💡 Type /agents or /create-agent in chat to manage agents.

Use Cases

Security review agent — read-only tools (search, readFile), scans for OWASP Top 10, hands off to "fix" agent

Plan → Implement workflow — Plan agent creates a spec, handoff button sends it to Agent mode for coding

📚 Sources: VS Code Docs — Custom Agents

11

Skills (Agent Superpowers)

What: Portable folders of instructions, scripts & resources that Copilot auto-loads when relevant. Unlike instructions (guidelines), skills teach capabilities — testing workflows, deployment recipes, etc. Open standard across VS Code, CLI & coding agent.

SKILL.md Format

---
name: webapp-testing
description: 'Run and debug
  web app integration tests'
---
# Testing Workflow
Use describe + it + AAA pattern
Use factory mocks for fixtures

Locations

Project.github/skills/<name>/

Personal~/.copilot/skills/<name>/

Key Features

Invoke via /skill-name in chat
/create-skill — AI-generate a skill
Works across VS Code, CLI & coding agent
Open standard: agentskills.io

Use Cases

Testing skill — SKILL.md + test templates + fixture scripts → Copilot auto-loads when you ask "help me test"

Deployment skill — SKILL.md + deploy scripts + Dockerfile → /deploy runs the full pipeline

📚 Sources: VS Code Docs — Skills · agentskills.io

12

MCP — Model Context Protocol

What: An open standard that connects Copilot to external tools & services (databases, APIs, browsers). MCP servers expose tools, data resources, and prompt templates that the AI can use during conversations.

mcp.json (.vscode/mcp.json)

{
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp"
    },
    "playwright": {
      "command": "npx",
      "args": ["-y",
        "@microsoft/mcp-server-playwright"]
    }
  }
}

MCP Capabilities

Capability	Description
Tools	Execute operations (file, DB, API)
Resources	Read-only context (Add Context → MCP Resources)
Prompts	Templates via `/server.prompt`
MCP Apps	Interactive UI in chat
Sampling	Server-initiated model calls
Elicitation	Server asks user for input

Key Servers

github-mcp-serverGitHub APIs

PlaywrightBrowser automation

SandboxmacOS/Linux: sandboxEnabled

⚠️ Only use MCP servers from trusted sources. Review configs before starting.

Use Cases

Query a database — add a Postgres MCP server → ask Copilot "show me users who signed up this week"

Browser testing — add Playwright MCP server → "go to our staging site and screenshot the login page"

📚 Sources: VS Code Docs — MCP Servers · modelcontextprotocol.io

13

Hooks — Lifecycle Automation

What: Deterministic shell commands that run at specific agent lifecycle points. Unlike instructions (suggestions), hooks guarantee execution — block dangerous commands, auto-format after edits, log tool usage, enforce security policies.

Hook Events

Event	When
`SessionStart`	First prompt of new session
`UserPromptSubmit`	User submits a prompt
`PreToolUse`	Before tool invocation
`PostToolUse`	After tool completes
`PreCompact`	Before context compaction
`SubagentStart/Stop`	Subagent lifecycle
`Stop`	Agent session ends

Hook Config (.github/hooks/*.json)

{
  "hooks": {
    "PostToolUse": [{
      "type": "command",
      "command": "npx prettier --write \"$TOOL_INPUT_FILE_PATH\""
    }]
  }
}

Exit Codes

0Success → parse stdout JSON

2Block → stop & show error

OtherWarning → continue

PreToolUse Output

permissionDecision"allow" | "deny" | "ask"

💡 Use /hooks or /create-hook in chat to configure hooks.

Use Cases

Auto-format on save — PostToolUse hook runs prettier --write on every file the agent edits

Block destructive commands — PreToolUse hook denies rm -rf and DROP TABLE with exit code 2

📚 Sources: VS Code Docs — Agent Hooks

14

Copilot on GitHub.com

What: Copilot features on github.com — the cloud coding agent creates PRs autonomously, Copilot reviews code, generates PR summaries, helps with issues, and runs Autofix for security vulnerabilities.

Coding Agent

Delegate tasks from VS Code, CLI, or github.com
Use /delegate in chat or @cli in terminal
Creates PRs autonomously in cloud
Uses premium requests (1× per session × model)
Follow up with steering comments

PR & Issue Features

PR Summary — auto-generate descriptions
Code Review — assign Copilot as reviewer
Issue helper — create/update issues with Copilot
Autofix — code scanning security fixes

Customize Agent Environment

Custom Dockerfile, devcontainer
MCP servers for coding agent
Pre/post scripts, dependencies

Use Cases

Delegate a feature — /delegate + link to GitHub issue → agent creates a branch, implements, and opens a PR

Auto-review PRs — assign Copilot as reviewer on every PR → catches bugs, style issues, and security flaws

📚 Sources: GitHub Docs — Coding Agent · Code Review

15

Copilot CLI — Terminal AI Agent

What: A full AI coding agent in your terminal — interactive conversations, autonomous task execution, plan mode, custom agents, MCP, hooks, skills, and memory. Default model: Claude Sonnet 4.5.

Slash Commands

Command	Action
`/model`	Switch AI model
`/compact`	Compress conversation context
`/context`	View token usage breakdown
`/usage`	Session stats (premium reqs, duration, LOC)
`/agent`	Select a custom agent
`/mcp`	List MCP servers; `/mcp add` to add
`/resume`	Resume a previous session
`/add-dir`	Trust an additional directory
`/cwd` / `/cd`	Change working directory
`/login`	Authenticate with GitHub
`/feedback`	Submit feedback, bugs, features
`/allow-all`	Auto-approve all tools this session

Keyboard & Syntax

Key / Syntax	Action
Shift+Tab	Toggle Ask / Plan mode
Ctrl+T	Show/hide model reasoning
Esc	Stop current operation
`@path/to/file`	Include file as context
`!git status`	Run shell command directly

Command-Line Flags

-p "prompt"Programmatic single-prompt mode

--continueResume most recent session

--resumePick a session to resume

--agent=nameUse a specific custom agent

--allow-all-toolsAuto-approve all tools

--allow-tool='shell(git)'Allow specific tool

--deny-tool='shell(rm)'Block specific tool

--model nameSet model from CLI

Built-in Subagents

ExploreQuick codebase analysis

TaskRun tests/builds, brief summaries

Code-reviewReview changes, surface real issues

Use Cases

Headless automation — copilot -p "Run tests, fix failures, commit" --allow-all-tools in CI/CD

Resume cloud agent — /resume to pull a coding agent session from github.com into your terminal

📚 Sources: GitHub Docs — Copilot CLI

16

Spaces & Spark

What: Spaces — curated knowledge collections for project context. Spark — natural language to micro web apps.

Curate knowledge for project context
Attach docs, code, files to a space
Access at github.com/copilot/spaces
Uses premium requests (1× model rate)

Copilot Spark

Natural language → micro web apps
4 premium requests per prompt
Access at github.com/spark

Use Cases

CLI: bulk file ops — copilot -p "Rename all .jpeg files to .jpg recursively" with --allow-tool='shell'

Spark: quick prototype — "Build a dashboard showing my GitHub repo stats" → live web app in seconds

📚 Sources: GitHub Docs — Spaces · Copilot Spark

17

Toolsets

What: A collection of tools you reference as a single entity in prompts, prompt files, and custom agents. Organize related tools and enable/disable them as a group.

Define in .jsonc files via Chat: Configure Tool Sets
Reference in prompts: #toolset-name
Reference in agents: tools: ['my-toolset']
Built-in sets: #edit, #search

Tool Set File (.jsonc)

{
  "reader": {
    "tools": ["search/changes", "search/codebase",
              "read/problems", "search/usages"],
    "description": "Tools for reading context",
    "icon": "book"
  }
}

Properties

toolsArray of tool names (built-in, MCP, extension)

descriptionShown in tools picker

iconProduct icon (see Icon Reference)

Use Cases

Read-only toolset — group search, readFile, grep into a #reader set for safe auditing

Quick reference — type #reader in prompt to enable all read tools at once

📚 Sources: VS Code Docs — Tool Sets

18

Content Exclusion

What: Organization-level rules that prevent specific files, folders, or repositories from being sent to the AI model — enforcing compliance and protecting sensitive code.

Exclude files/repos from Copilot at org level
Prevents content from being sent to model
Configurable in GitHub org settings
Supports glob patterns for paths
Applies to completions, chat, and agents

Common Exclusions

.env / .env.*Environment variables & secrets

**/secrets/**Secret files & credentials

**/keys/**API keys & certificates

internal-repoEntire private repositories

Use Cases

Exclude secrets — content exclusion rule blocks .env, **/secrets/** from being sent to AI

Compliance — exclude regulated codebases (HIPAA, PCI) from AI processing at the org level

📚 Sources: GitHub Docs — Content Exclusion

19

Spec-Driven Development

What: Write a specification first, then let the AI agent implement it. Specs define requirements, acceptance criteria, and architecture — giving agents a clear blueprint instead of ad-hoc prompts.

Popular Frameworks

spec-kitGitHub's spec workflow for coding agent

OpenSpecFission AI spec framework

BMADBMAD methodology

GSDGet-shit-done framework

Workflow

Write Spec → Review & Refine → Agent Implements → Validate Output

Use Cases

Feature spec — write a spec with user stories + acceptance criteria → /delegate to coding agent for implementation

Migration spec — define the target state, constraints, and rollback plan → agent handles the migration systematically

📚 Sources: github/spec-kit · OpenSpec · BMAD Method · GSD

20

Customization File Structure

What: The recommended project layout for all Copilot customization files — instructions, prompts, agents, skills, hooks, toolsets, and MCP configs in one organized tree.

your-project/ ├── .github/ │ ├── copilot-instructions.md │ ├── instructions/ │ │ ├── python.instructions.md │ │ └── react.instructions.md │ ├── prompts/ │ │ └── create-api.prompt.md │ ├── agents/ │ │ ├── planner.agent.md │ │ └── reviewer.agent.md │ ├── skills/ │ │ └── testing/ │ │ └── SKILL.md │ ├── hooks/ │ │ └── format.json │ └── toolsets/ ├── .vscode/ │ └── mcp.json ├── AGENTS.md └── CLAUDE.md

Use Cases

Monorepo setup — separate instructions/ for frontend (React) and backend (Python) with different applyTo globs

Team shared configs — commit .github/ folder to Git so all team members get the same Copilot behavior

📚 Sources: VS Code Docs — Customization Overview

21

Third-Party Coding Agents

What: Use Anthropic Claude and OpenAI Codex as autonomous coding agents alongside Copilot's built-in agent. Assign GitHub issues or prompts — they create branches, implement changes, and open PRs for review.

Supported Agents

Agent	Provider	Status
Claude	Anthropic	Preview
Codex	OpenAI	Preview
Copilot	GitHub	GA

Where to Use

Agents tab — github.com/copilot/agents
Issues — assign the agent to an issue
PRs — mention @AGENT_NAME in a comment
VS Code — new session → select agent type
GitHub Mobile — start agent session from Home

How It Works

Assign Issue / Prompt → Agent Plans & Codes → Opens PR → You Review

Cost & Billing

Consumes GitHub Actions minutes + 1 premium request per session
Uses same security protections as Copilot coding agent
Same repo access permissions as built-in agent

Enable for Your Org

Org Settings → Copilot → Coding agent → Partner agents
Available on Pro, Pro+, Business, and Enterprise plans
Org admins toggle each agent independently

⚠️ Third-party agents are in public preview. Policies apply to cloud agents only — local agents in VS Code cannot be disabled.

Use Cases

Compare agent output — assign the same issue to Claude, Codex, and Copilot → compare the three PRs and merge the best one

Parallel workstreams — assign backend refactor to Codex while Claude handles frontend tests — both open PRs simultaneously

📚 Sources: GitHub Docs — Third-Party Agents · Anthropic Claude · OpenAI Codex

22

Browser Agent Tools

What: Agents can open, interact with, and screenshot web pages in VS Code's integrated browser — enabling autonomous build → test → debug → fix loops for web apps without leaving the editor.

Available Tools

Tool	Action
`openBrowserPage`	Open a URL in integrated browser
`navigatePage`	Navigate to a different URL
`readPage`	Read page content & structure
`screenshotPage`	Take a screenshot for visual review
`clickElement`	Click a page element
`hoverElement`	Hover over an element
`dragElement`	Drag and drop elements
`typeInPage`	Type text into inputs
`handleDialog`	Accept/dismiss browser dialogs
`runPlaywrightCode`	Run custom Playwright automation

Enable Browser Tools

Set workbench.browser.enableChatTools to true
Open Chat → Agent mode → Tools picker
Enable all tools under Built-in > Browser

Autonomous Dev Loop

Build App → Open in Browser → Test & Interact → Fix Issues → Validate

Sharing Pages

Agent-opened pages use isolated ephemeral sessions (no shared cookies)
Share with Agent button — share your pages (uses your session/cookies)
Visual indicator shows when a page is shared

⚠️ Browser agent tools are experimental and may change in future releases.

Use Cases

Form validation testing — "Build a contact form, open it in the browser, test all validation rules and fix any issues" (full loop)

Responsive layout check — "Screenshot this page at 320px, 768px, and 1440px widths and verify the layout is correct"

Accessibility audit — "Check this page for missing alt text, heading hierarchy, keyboard nav, and color contrast issues"

📚 Sources: VS Code Docs — Browser Agent Testing · Integrated Browser

23

Checkpoints & Session Forking

What: VS Code auto-snapshots your workspace before each agent action. Restore to any previous state, redo undone changes, edit & resend earlier prompts, or fork a conversation to explore an alternative approach — all without losing work.

Checkpoints

Enable: chat.checkpoints.enabled
Auto-created before each chat request
Hover chat request → Restore Checkpoint
Reverts all file changes made after that point
Redo button appears after restore — undo mistakes

View File Changes

Enable: chat.checkpoints.showFileChanges
Shows modified files + lines added/removed per request
Helps decide which checkpoint to restore to

💡 Checkpoints complement Git but don't replace it. They're for quick iteration within a session — use Git for permanent version control.

Edit Previous Requests

Click any previous chat request to edit it
Reverts changes from that request + all later ones
Resends as a new request with your edits
Configure: chat.editRequests

Fork from Checkpoint

Hover chat request → Fork Conversation
Creates new independent session from that point
Original conversation preserved
Explore alternative approaches side by side

Workflow

Agent Acts → Review Output → ✅ Keep / 🔄 Restore / 🍴 Fork

Use Cases

Safe experimentation — let the agent try a risky refactor, restore checkpoint if it breaks tests, fork to try an alternative

Prompt refinement — edit a vague prompt 3 requests back → agent re-runs with better instructions, previous bad output is undone

📚 Sources: VS Code Docs — Checkpoints · Chat Sessions

24

Agent Sessions, Handoffs & Orchestration

What: Run multiple agent sessions in parallel across local, background (CLI), and cloud environments. Hand off tasks between agent types with full context carry-over. Manage everything from a unified sessions view.

Agent Types

Type	Runs	Best For
Local	VS Code (interactive)	Brainstorm, debug, browse
Copilot CLI	Background on machine	Well-defined tasks, POCs
Cloud	Remote infra	PRs, team collaboration
Third-party	Claude / Codex	Provider-specific models

Handoff Flow

Plan (Local) → Implement (CLI) → PR (Cloud) → Review

Select different agent type from session dropdown
Full conversation history carries over
Original session archived after handoff
/delegate in CLI → sends to cloud agent

Sessions View

Unified list of all sessions (local, CLI, cloud)
Compact or Side-by-side layout modes
Shows status, type, and file change stats
Archive / unarchive completed sessions
Grouped by time (Today, Last Week, etc.)

Agent Status Indicator

Badge in command center title bar Experimental
Shows unread messages + in-progress count
Enable: chat.agentsControl.enabled

Parallel Sessions

Create multiple sessions via + button
Each session: independent context window
Run different tasks simultaneously
Assign TODOs: right-click code → assign to agent

Use Cases

Plan → Build → Ship — Plan agent designs architecture, hand off to CLI for implementation, then cloud agent opens the PR for team review

Parallel features — run 3 local sessions: one for API endpoints, one for UI components, one for tests — all working simultaneously

TODO delegation — add // TODO: add input validation in code → right-click → assign to Copilot coding agent → agent creates a PR

📚 Sources: VS Code Docs — Agents Overview · Chat Sessions

25

Prompt & Context Engineering

What: Proven techniques for writing effective prompts and providing the right context. The quality of Copilot's output depends directly on how well you communicate — be specific, break tasks down, include expected output, and choose the right interaction mode.

Writing Effective Prompts

Be specific — state language, framework, expected I/O
Break down complex tasks — smaller steps = better results
Include expected output — test cases, acceptance criteria
Avoid vague prompts — "make this better" → "reduce time complexity"
Iterate with follow-ups — refine, don't rewrite the whole prompt
Ask AI to ask questions — "ask me clarifying questions before starting"
Course-correct early — steer mid-request if heading wrong way

Prompt Example

Write a TypeScript function that validates
email addresses. Return true for valid,
false otherwise. Don't use regex.
Example: validateEmail("user@example.com")
  → true
Example: validateEmail("invalid") → false

Providing Context

Agent auto-searches workspace — usually no need for #codebase
Reference specific files: #file, #folder, #symbol
#fetch — pull info from web pages / docs
Attach images / screenshots for visual context
Use integrated browser to select page elements

Pick the Right Mode

Mode	When to Use
Inline suggestions	In-flow coding, boilerplate
Ask	Questions, brainstorm, explore
Inline chat	Targeted in-place edits
Agent	Multi-file autonomous changes
Plan	Architecture, migration strategy
Smart actions	One-click commit msg, fix, rename

Session Hygiene

New session for unrelated tasks — avoid context pollution
Use subagents for isolated research
Run parallel sessions for independent work

Use Cases

High-quality output — "Implement a rate limiter using token bucket. Write tests that verify: 10 req/s allowed, 11th rejected, refills after 1s. Run the tests."

Plan first — use Plan agent to design architecture → review → hand off to Agent mode for implementation with tests as verification

📚 Sources: VS Code Docs — Best Practices · Context Engineering Guide · Prompt Cookbook

26

Smart Actions

What: One-click AI-powered actions built into VS Code — no prompt needed. Generate commit messages, rename symbols intelligently, fix diagnostics, and search semantically. Available via right-click, lightbulb, or keyboard shortcuts.

Available Actions

Action	Where
Generate Commit Message	Source Control panel
Rename Symbol	F2 on any symbol
Fix with Copilot	Lightbulb on errors/warnings
Fix Test Failure	Test Explorer failed tests
Generate Docs	Right-click → Generate Code
Semantic Search	Search view (meaning, not keywords)
Generate PR Summary	PR description field

How to Access

Lightbulb (⌘.) — hover over error → AI fix suggestion
Right-click → Generate Code menu
Context menus in Source Control, Test Explorer
No prompt required — Copilot infers from context

Use Cases

Instant commit messages — click ✨ in Source Control → Copilot analyzes diff and generates a Conventional Commit message

Smart rename — F2 on processData → Copilot suggests transformUserPayload based on function body semantics

📚 Sources: VS Code Docs — Smart Actions

27

BYOK — Bring Your Own Key

What: Use your own API keys to access hundreds of models beyond the built-in ones — including local models via Ollama or AI Toolkit. Bypass rate limits, experiment with cutting-edge models, and use your own compute.

Benefits

Model choice — access models not available built-in
Experimentation — try new models or features early
Local compute — run models on your machine (Ollama)
Greater control — bypass standard rate limits

How to Add

Model picker → Manage Models → Add Models
Select built-in provider or install extension
Enter API key / endpoint URL
Or: Chat: Manage Language Models command

Options

Built-in providersOpenAI, Anthropic, Google, etc.

ExtensionsAI Toolkit, Foundry Local

Local modelsOllama, custom OpenAI-compat

⚠️ BYOK is for Pro/Pro+ individual plans only. Not yet available for Business/Enterprise. Still requires Copilot service & internet for embeddings and indexing.

💡 BYOK models need tool calling support to work in Agent mode. No responsible AI filtering on BYOK model output.

Use Cases

Run local Ollama — deploy Phi-4 locally, add via Manage Models → use in chat with zero API cost and full privacy

Cutting-edge models — add your Anthropic key to try Claude's latest release before it appears in the built-in list

📚 Sources: VS Code Docs — Language Models

28

Privacy, Security & Trust

What: How GitHub protects your data — code is not used for training (Business/Enterprise), prompts are not retained, responsible AI filters run pre- and post-model, and IP indemnity covers Copilot-generated code.

Data Handling

What	Behavior
Prompts & suggestions	Not retained after response delivered
Training on your code	No (Business/Enterprise)
Telemetry opt-out	Individual users can opt out
Code snippets	Encrypted in transit & at rest

Responsible AI Filters

Pre-model — content exclusion, harmful prompt detection
Post-model — duplicate/public code detection, safety checks
Configurable: enable/disable public code matching

IP & Compliance

IP indemnity — GitHub indemnifies Copilot output (Business/Enterprise)
SOC 2 Type II compliant
GDPR compliant — EU data processing
Subprocessor list published on Trust Center

Security Best Practices

Review AI output for vulnerabilities (OWASP Top 10)
Don't paste credentials into prompts
Use content exclusion for sensitive files
Only use MCP servers from trusted sources
BYOK: no responsible AI filtering on output

💡 Enable public code filter to block suggestions matching public repositories — reduces IP risk.

Use Cases

Compliance review — point stakeholders to the Trust Center FAQ for SOC 2, GDPR, and data handling evidence

Reduce IP risk — enable public code filter + content exclusion for proprietary algorithms → dual protection

📚 Sources: GitHub Copilot Trust Center · VS Code — Copilot Security · Responsible Use

29

Org & Enterprise Administration

What: Admin controls for managing Copilot across your organization — assign seats, set policies for features & models, review usage analytics, audit logs, and configure content exclusions at scale.

Policy Management

Policy	Controls
Features	Chat, completions, agents, MCP
Models	Enable/disable premium models
Coding agent	Enable cloud agent + 3rd-party
Editor preview	Opt in to preview features
Public code filter	Block public code matches
Content exclusion	Exclude files/repos from AI

Access Management

Assign Copilot seats per user or team
Enterprise owners → org-level access
Org owners → member-level access
Policies cascade: Enterprise → Org → User

Usage Analytics

Dashboard: acceptance rates, active users, languages
Premium request consumption by user/team
Breakdown by feature (chat, completions, agent)
Export data via API for custom reporting

Audit Logs

Track Copilot actions by user
Seat assignments, policy changes
Available for Business & Enterprise plans

Settings Path

OrgSettings → Copilot → Policies / Models

EnterpriseEnterprise Settings → Copilot → Policies

💡 Enterprise policies override org settings. If an explicit setting is chosen at enterprise level, orgs cannot change it.

Use Cases

Rollout strategy — enable Copilot for a pilot team, review usage analytics for 30 days, then expand to the full org

Model governance — disable Opus 4.6 (30× cost) org-wide, allow only 0×–1× models to control premium request spend

📚 Sources: GitHub Docs — Org Management · Usage & Audit Logs

30

Subagents

What: Isolated child agents that run research or execution tasks within a parent agent session. Context stays separate to avoid polluting the main conversation — results are summarized back to the parent.

Built-in Subagents

Subagent	Purpose
Explore	Quick codebase analysis & Q&A
Task	Run tests/builds, return brief summaries
Code-review	Review changes, surface real issues

How They Work

Parent agent spawns subagent for a focused task
Subagent runs in isolated context — no pollution
Returns a single summary message to parent
Can run in parallel for independent tasks
Available in VS Code agent mode & Copilot CLI

When to Use

Research a topic without cluttering main chat
Run tests and get a pass/fail summary
Explore multiple approaches in parallel

Use Cases

Parallel research — agent spawns 3 Explore subagents to investigate auth, caching, and logging patterns simultaneously

Test runner — Task subagent runs full test suite, returns "2 of 47 tests failed: test_auth, test_cache" — no noisy output in main chat

📚 Sources: VS Code Docs — Subagents

★

Quick Reference & Resources

What: Essential keyboard shortcuts, AI-powered slash commands for creating customizations, and key links to documentation, changelogs, and community resources.

Chat Shortcuts

Shortcut	Action
⌃⌘I / Ctrl+Alt+I	Open Chat panel
⌘I / Ctrl+I	Inline chat
⌘⇧I	Toggle secondary sidebar
Tab	Accept suggestion
Esc	Dismiss suggestion
Alt+] / Alt+[	Next / prev suggestion
Ctrl+→	Accept word by word

Useful Extensions

Awesome CopilotCurated tips & resources · ↗ Link

Prompt BoostEnhance your prompts · ↗ Link

Token TrackerTrack Copilot usage · ↗ Link

SpecStorySave & search AI chat history · ↗ Link

HuggingFaceHF models in VS Code · ↗ Link

Quick Commands

Command	Action
`/init`	Generate workspace instructions
`/create-agent`	AI-create a custom agent
`/create-skill`	AI-create a skill
`/create-prompt`	AI-create a prompt file
`/create-instruction`	AI-create an instruction
`/create-hook`	AI-create a hook config
`/hooks`	Configure hooks menu

Key Resources

Feature MatrixCopilot feature comparison · ↗ Link

MCP MarketplaceDiscover MCP servers · ↗ Link

Skills RepositoryBrowse agent skills · ↗ Link

ChangelogLatest Copilot updates · ↗ Link

awesome-copilotCommunity resources · ↗ Link

Use Cases

Fast navigation — memorize ⌃⌘I (open chat) + ⌘I (inline chat) + Tab (accept) for fluid keyboard-only workflow

Stay current — check github.blog/changelog/copilot weekly for new models, features, and API changes

📚 Sources: GitHub Copilot Docs · Changelog