← Back to Learning Portal

GH-300 Study Manual

Complete exam guide — Responsible AI, features, setup, and effective use of GitHub Copilot.

GitHub Copilot Certification (GH-300) — Complete Exam Guide

Exam: GitHub Copilot Certification (GH-300)

Format: ~60 multiple-choice questions, 120 minutes

Passing score: approximately 70%

Delivered via: PSI Online Proctoring

1. [Domain 1: Responsible AI (~10%)](#domain-1-responsible-ai)
2. [Domain 2: GitHub Copilot Features & Plans (~25%)](#domain-2-features-and-plans)
3. [Domain 3: Setup & Configuration (~20%)](#domain-3-setup-and-configuration)
4. [Domain 4: Effective Use (~45%)](#domain-4-effective-use)
5. [Practice Questions by Domain](#practice-questions)
6. [Key Terms Glossary](#glossary)

DOMAIN 1: RESPONSIBLE AI

1.1 What Is Generative AI?

Generative AI refers to machine learning models that can generate new content — code, text, images, audio — by learning statistical patterns from large training datasets. Unlike discriminative models that classify existing data, generative models produce novel outputs.

Key characteristics:

Outputs are probabilistic, not deterministic — the same prompt may produce different outputs
Models learn from training data and generalize patterns to new inputs
Output quality depends heavily on training data quality and prompt quality
Models do not "understand" in a human sense — they predict likely token sequences

Large Language Models (LLMs):

LLMs are neural networks trained on massive text corpora
They use the Transformer architecture with attention mechanisms
They predict the next token given preceding context
GitHub Copilot is built on Codex and later GPT-4-based models fine-tuned on code
Context window limits how much code/text the model considers at once
GitHub Copilot's context window includes: open files, cursor position, recently viewed files, repository structure

1.2 How GitHub Copilot Works

Training data sources:

Public repositories on GitHub (the primary source)
Selected public internet text
GitHub's internal data (with appropriate consent)
Note: Copilot is NOT trained on private repositories by default

Inference pipeline (what happens when you type):

1. Editor collects context: current file, cursor position, open tabs, imports, function signatures
2. Context is sent to GitHub's servers as a "prompt"
3. The model generates one or more code completions
4. The highest-ranked completion appears as ghost text in your editor
5. Tab accepts it; Escape or continued typing dismisses it

What context Copilot uses (telemetry inputs for completions):

The file you are currently editing
Other open tabs in the same editor session
The programming language detected
Imports and dependencies already in the file
Comments and docstrings
Function names, variable names, and existing code patterns
File path and project structure hints

What Copilot does NOT use:

Files from other users' private repositories
Your past accepted/rejected suggestions (unless telemetry is enabled for training)
Contents of files you have not opened in the session

1.3 Types of Bias in AI Systems

AI bias occurs when a model produces systematically skewed outputs due to issues in training data, design, or evaluation.

Types of bias relevant to GitHub Copilot:

Bias Type	Definition	Copilot Example
---	---	---
Training data bias	Biased or unrepresentative training data	Over-representing popular languages like JavaScript/Python, under-representing others
Recency bias	Favoring recently popular patterns	Suggesting deprecated APIs because they are common in old public code
Popularity bias	Suggesting common but not necessarily best-practice code	Stack Overflow copy-paste patterns
Confirmation bias	Users accept suggestions without review because they look correct	Accepting insecure code that compiles and runs
Language/cultural bias	Under-performance on languages less represented online	Lower quality suggestions for code commented in non-English languages
Algorithmic bias	Model favoring certain patterns structurally	Preference for certain loop patterns over others

How to detect bias:

Test Copilot's suggestions across multiple languages and problem types
Compare suggestions for equivalent problems expressed differently
Check if suggestions match your team's agreed standards, not just popular patterns
Review suggestions from a security perspective, not just correctness

Mitigation strategies:

Always review suggestions before accepting
Provide clear, specific prompts
Use custom instructions to guide Copilot toward your standards
Content exclusions to prevent training on sensitive patterns
Organization policies to control feature availability

1.4 Privacy: What Data Copilot Sends

Data sent to GitHub during code completion (by default):

Code snippets (prompts) sent for completion requests
File paths (for context)
Editor metadata (IDE version, extension version, language)
Engagement telemetry (did you accept or reject a suggestion?)

Data that is NOT sent:

Complete contents of files you have not opened
Private repository contents (unless you open them in your editor)
Authentication credentials or secrets (though you should never put these in code)

Telemetry settings and controls:

editor.telemetry settings in your IDE
GitHub Copilot-specific telemetry can be disabled in VS Code settings
Organization admins can control whether Copilot uses suggestion data for model improvement
Enterprise: additional controls over data retention and usage

For organizations (Business/Enterprise):

Prompts sent to GitHub are not used to train the base model by default for Business and Enterprise plans
GitHub does NOT retain prompts sent by Business/Enterprise users beyond the request
Individual plan users: prompts MAY be used for product improvement unless opted out

Key privacy distinctions to know for the exam:

Individual plan: code snippets may be retained for model improvement (opt-out available)
Business plan: code snippets are NOT retained for model training
Enterprise plan: code snippets are NOT retained, additional data governance available

1.5 Security Considerations

When NOT to use Copilot suggestions:

1. Secrets and credentials: Never accept suggestions that include API keys, passwords, tokens, or connection strings. Copilot may suggest hardcoded secrets it has seen in public code.

2. Known CVE patterns: Common vulnerable patterns (SQL injection, XSS, buffer overflows) may appear in suggestions because they appear in training data. Always audit security-sensitive code.

3. Cryptographic implementations: Custom crypto is almost always wrong. Copilot may suggest weak algorithms or flawed implementations. Use established libraries.

4. Authentication and authorization logic: Critical security logic requires human review and security expertise, not AI generation.

5. Input validation: Copilot may omit or under-implement validation. Always verify that all inputs are properly sanitized.

Common insecure patterns Copilot might suggest:

Hardcoded credentials: password = "admin123"
SQL string concatenation: "SELECT * FROM users WHERE id = " + user_id
Disabled SSL verification: verify=False in Python requests
Weak random number generation for security contexts
Missing error handling that silently swallows exceptions
Overly permissive file permissions

Security best practices when using Copilot:

Treat every suggestion as untrusted code requiring review
Run static analysis tools (GitHub Advanced Security, Snyk) alongside Copilot
Enable Dependabot and secret scanning in your repository
Use GitHub Copilot's /fix command to address identified vulnerabilities, then verify the fix
Maintain a security review process that Copilot suggestions must pass through

1.6 Responsible Use Principles

GitHub's responsible AI principles for Copilot:

1. Review all suggestions before accepting

Copilot suggestions are starting points, not finished code
You are responsible for the code you commit, not GitHub or Microsoft

2. Understand before accepting

Do not accept code you do not understand
Use /explain to understand what a suggestion does before committing it

3. Test generated code

Write or generate tests for Copilot-produced code
Code that looks correct may have edge case failures

4. Maintain human oversight

Copilot is a productivity tool, not a replacement for engineering judgment
Critical architectural decisions must remain human-driven

5. Be transparent with your team

Teams should establish norms around Copilot use
Code reviewers should know Copilot may have contributed

6. Consider the impact on learning

Junior developers: balance Copilot use with learning fundamentals
Use Copilot's /explain command to learn from suggestions

1.7 Copyright and Licensing

How Copilot handles licensed code:

Copilot is trained on public code which includes many open-source licenses
Copilot may occasionally suggest code similar to existing licensed code
GitHub implemented a "duplication detection" filter that can block suggestions matching public code verbatim

Duplication detection (Public Code Matching):

GitHub Copilot can detect when a suggestion closely matches public code (>150 characters)
When a match is found, Copilot shows a reference to the original source
Organization admins can enable/disable this filter
Enterprise can enforce that suggestions matching public code are always blocked

License risks:

Copyleft licenses (GPL, LGPL) may require derivative works to also be open-source
Permissive licenses (MIT, Apache) generally allow any use with attribution
The legal status of AI-generated code is still evolving
Best practice: understand your organization's policy on AI-generated code

Exam key point: GitHub Copilot has a "Public Code" filter that can be set to:

Allowed: Show suggestions even if they match public code (default for Individual)
Blocked: Do not show suggestions that match public code (can be set by org admins)

1.8 Transparency

GitHub Copilot surfaces context and sources when appropriate:

When a suggestion closely matches a public repository, it may show a reference link
Copilot Chat responses can include references to documentation or GitHub sources
The Copilot output is not auditable in the same way as human code — you cannot always know why a specific suggestion was made

DOMAIN 2: FEATURES AND PLANS

2.1 Plan Overview

GitHub Copilot has three tiers. Knowing the exact features in each plan is heavily tested.

2.2 GitHub Copilot Individual

Target user: Individual developer, not part of an organization

Billing: Monthly or yearly subscription per user, paid by credit card

Authentication: Personal GitHub account

Key features included:

Code completions in supported IDEs
GitHub Copilot Chat in IDE
GitHub Copilot CLI (via gh extension)
GitHub Copilot Mobile (iOS and Android)
Basic Copilot on GitHub.com (limited)

What Individual does NOT have:

Organization-wide policy management
Audit logs
SSO/SAML enforcement
Seat management dashboard
Knowledge bases
Content exclusions managed centrally
PR summary generation (Enterprise only)
Bing web search integration (Enterprise only)

Trial: GitHub Copilot Individual offers a 30-day free trial for new users

Pricing (approximate, verify at time of exam):

$10/month or $100/year per user

2.3 GitHub Copilot Business

Target user: Teams and organizations

Billing: Per-seat, billed to GitHub organization, managed by org admins

Authentication: GitHub organization membership, supports SSO

Everything in Individual PLUS:

Organization-level policy controls
Seat management: assign/revoke seats for members
Audit logs: track who used Copilot and when
SAML/SSO enforcement
Public code matching policy (org-wide)
Content exclusions managed centrally for the organization
Network proxy support
IP allow-list enforcement
Policy for: suggestion matching public code, Copilot Chat, Copilot in CLI

What Business does NOT have (vs Enterprise):

Knowledge bases (Copilot Enterprise only)
Copilot on GitHub.com pull request summaries
Fine-grained model control per enterprise
Bing web search integration in Chat
Copilot for GitHub Docs (Enterprise only)

Data handling: Prompts sent by Business users are NOT retained for model training

Seat management:

Org owners can enable Copilot for all members or specific teams/users
Unused seats can be revoked
Seats can be assigned to outside collaborators

Pricing (approximate): ~$19/user/month

2.4 GitHub Copilot Enterprise

Target user: Large enterprises with advanced needs

Billing: Per-seat, billed to enterprise account

Authentication: Enterprise-managed users (EMU) supported, SAML/SSO

Everything in Business PLUS:

Knowledge Bases:

Create custom knowledge bases from your organization's documentation, code, and wikis
Index markdown files, code files, GitHub Issues, GitHub Discussions
Copilot Chat can reference these knowledge bases when answering questions
Available in VS Code via @github with knowledge base selection
Particularly powerful for internal APIs, design system docs, onboarding

Copilot on GitHub.com:

Chat with Copilot directly in the GitHub.com interface (not just IDE)
Available on pull request pages, issue pages, code search

Pull Request Summaries:

Copilot can automatically generate a summary of changes in a pull request
Accessible via the PR page on GitHub.com
Summarizes what changed and why based on diff analysis
Can be triggered manually or set up with policies

Copilot for GitHub Search:

Natural language queries in code search
"Find all places where we handle authentication errors"

Bing Web Search Integration:

Copilot Chat can search the web via Bing for current information
Useful for recent package versions, new APIs, documentation updates
Must be enabled by enterprise admin

Copilot for Docs:

Ask questions about GitHub's own documentation
Answers grounded in official docs

Additional Enterprise controls:

Fine-grained policy enforcement at enterprise level
Enterprise-wide audit logs
Network restrictions
Expanded data governance

Pricing (approximate): ~$39/user/month

2.5 Plan Feature Comparison Table

Feature	Individual	Business	Enterprise
---	---	---	---
Code completions	Yes	Yes	Yes
Copilot Chat in IDE	Yes	Yes	Yes
Copilot CLI	Yes	Yes	Yes
Copilot Mobile	Yes	Yes	Yes
Multi-model selection	Limited	Yes	Yes
Org policy management	No	Yes	Yes
Seat management dashboard	No	Yes	Yes
Audit logs	No	Yes	Yes
SAML/SSO enforcement	No	Yes	Yes
Content exclusions (central)	No	Yes	Yes
Public code matching policy	Personal only	Org-wide	Enterprise-wide
Knowledge bases	No	No	Yes
PR summaries on GitHub.com	No	No	Yes
Copilot on GitHub.com (Chat)	Limited	Limited	Yes
Bing web search in Chat	No	No	Yes (opt-in)
Prompts retained for training	Opt-out	No	No
IP allow list	No	Yes	Yes
Fine-grained network proxy	No	Yes	Yes

2.6 Code Completion — How It Works

Code completion is Copilot's foundational feature. It appears as "ghost text" — a grayed-out suggestion inline with your cursor.

Triggering completions:

Completions appear automatically as you type (with a short delay)
They can be triggered manually depending on IDE settings
Comments written in natural language strongly influence completion quality
Function signatures trigger completions for the implementation
Docstrings trigger completions for the described functionality

Keyboard shortcuts (VS Code — most commonly tested):

Action	Shortcut
---	---
Accept suggestion	Tab
Dismiss suggestion	Escape
See next suggestion	Alt + ] (Windows/Linux) or Option + ] (Mac)
See previous suggestion	Alt + [ (Windows/Linux) or Option + [ (Mac)
Open completions panel (see all)	Ctrl + Enter
Trigger inline chat	Ctrl + I
Accept word by word	Ctrl + Right Arrow (partial accept)

Completion types:

Single-line completions: completing the current line
Multi-line completions: suggesting entire functions, classes, or blocks
Whole-file generation: for new files, Copilot can suggest a complete initial implementation

Quality factors affecting completions:

Clear, descriptive function names
Comments explaining intent
Well-named parameters with type annotations
Consistent code style in the file
Imports already present for relevant libraries

Ghost text behavior:

If you continue typing and what you type matches the suggestion, Copilot keeps showing it
If you type something different, the suggestion updates
Copilot shows one suggestion at a time inline; Ctrl+Enter opens the completions panel with up to 10 alternatives

2.7 GitHub Copilot Chat

Chat is a conversational interface to Copilot, allowing natural language questions and commands about code.

Chat interfaces:

1. IDE Chat Panel: Side panel in VS Code/JetBrains with full conversation history
2. Inline Chat: Triggered directly in the editor on selected code (Ctrl+I in VS Code)
3. GitHub.com Chat: Available on the GitHub.com interface (Business limited, Enterprise full)
4. Voice: Dictate queries to Copilot Chat in supported IDEs

Chat capabilities:

Explain code: "What does this function do?"
Fix bugs: "Why is this throwing a null pointer exception?"
Generate code: "Write a function that sorts a list of objects by date"
Answer questions: "What's the difference between async and sync in Python?"
Refactor: "Rewrite this to use list comprehensions"
Generate tests: "Write unit tests for this class"
Generate documentation: "Write a docstring for this function"

Chat vs. completions:

Completions: passive, triggered by typing, inline ghost text
Chat: active, conversational, can span multiple turns, can reference context explicitly

2.8 GitHub Copilot CLI

The Copilot CLI is installed as a GitHub CLI extension and provides AI assistance directly in the terminal.

Installation:

# Install GitHub CLI first
gh extension install github/gh-copilot

Main commands:

# Suggest a command
gh copilot suggest "list all files larger than 1GB"

# Explain a command
gh copilot explain "find . -name '*.log' -mtime +30 -delete"

# Alias shortcuts
ghce  # gh copilot explain shortcut
ghcs  # gh copilot suggest shortcut

Command types for gh copilot suggest:

-t shell — shell commands (bash, zsh, etc.)
-t gh — GitHub CLI commands
-t git — Git commands
Default: Copilot picks the best type based on context

Example interactions:

$ gh copilot suggest "delete all local git branches that have been merged"
? Select a command type  [Use arrows to move, type to filter]
> shell
  gh
  git

Suggestion: git branch --merged main | grep -v "^\* main" | xargs git branch -d

? Select an option  [Use arrows to move, type to filter]
> Copy command to clipboard
  Explain command
  Execute command
  Exit

Copilot CLI use cases:

Learning new CLI tools without memorizing flags
Quickly finding the right git command
Understanding what an existing script does
Generating complex one-liners

2.9 GitHub Copilot Mobile

Available for iOS and Android, Copilot Mobile brings AI coding assistance to smartphones and tablets.

Key features:

Natural language to code generation
Code explanation
Copilot Chat interface on mobile
Available in the GitHub Mobile app

Use cases:

Quick code reviews on the go
Asking Copilot questions while away from your desk
Code explanation during code reviews in the mobile app

Limitations:

No code completion (no IDE integration on mobile)
Primarily conversational interface
Smaller context window than desktop

2.10 GitHub Copilot on GitHub.com

Available for:

Business: limited features
Enterprise: full features

Features on GitHub.com:

Copilot Chat on GitHub.com: Available in the browser, can reference repositories, issues, PRs
PR Summaries (Enterprise): Auto-generate pull request descriptions
Code Search with Copilot (Enterprise): Natural language code search
Copilot for Issues: Ask questions about issue context

@github chat participant (Enterprise):

In IDE Chat, @github connects to your GitHub.com repositories
Can search across repos: @github What's the pattern we use for error handling?
Can reference PRs, issues, commits

DOMAIN 3: SETUP AND CONFIGURATION

3.1 Supported IDEs and Editors

GitHub Copilot has varying levels of support across editors. The exam tests which features are available where.

IDE/Editor	Code Completion	Copilot Chat	Inline Chat	Agent Mode
---	---	---	---	---
VS Code	Yes	Yes	Yes	Yes
Visual Studio 2022	Yes	Yes	Yes	Limited
JetBrains IDEs	Yes	Yes	Yes	No
Neovim	Yes	No	No	No
Vim	Yes	No	No	No
Eclipse	Yes	Limited	No	No
GitHub.com (web)	No	Yes (Enterprise)	No	No
GitHub Codespaces	Yes	Yes	Yes	Yes

JetBrains IDEs supported:

IntelliJ IDEA, PyCharm, WebStorm, GoLand, CLion, Rider, RubyMine, PhpStorm, DataGrip, DataSpell, Android Studio

VS Code is the primary IDE for Copilot features. Agent mode, the most advanced feature, is currently VS Code and GitHub Codespaces only (as of exam scope).

3.2 VS Code Installation

Step-by-step installation:

1. Open VS Code
2. Open Extensions panel (Ctrl+Shift+X)
3. Search for "GitHub Copilot"
4. Install "GitHub Copilot" (for completions)
5. Install "GitHub Copilot Chat" (for chat features — may be bundled)
6. VS Code will prompt you to sign in to GitHub
7. Complete OAuth flow in browser
8. Return to VS Code — Copilot icon appears in status bar

Verifying installation:

Copilot icon in the VS Code status bar (bottom right)
Green icon = active and authenticated
Yellow icon = not authenticated
Red icon = error or disabled

Extension IDs (for exam):

GitHub.copilot — code completions extension
GitHub.copilot-chat — chat extension

3.3 JetBrains Installation

1. Open any JetBrains IDE
2. Go to Settings/Preferences > Plugins
3. Search "GitHub Copilot" in Marketplace
4. Click Install
5. Restart the IDE when prompted
6. Go to Tools > GitHub Copilot > Login to GitHub
7. Copy the device code shown
8. Open the GitHub device activation URL
9. Enter the code and authorize

Verification: GitHub Copilot icon appears in the status bar at the bottom of the IDE.

3.4 Neovim Installation

Neovim requires a plugin. The official plugin is github/copilot.vim.

Installation with vim-plug:

Plug 'github/copilot.vim'

Post-install:

:Copilot setup

This opens a browser for GitHub OAuth authentication.

Key mapping: Copilot uses <Tab> to accept suggestions by default. This may conflict with existing tab mappings.

Note for exam: Neovim/Vim supports code completions ONLY, not Copilot Chat.

3.5 Visual Studio Installation

1. Open Visual Studio 2022 (version 17.6+ required)
2. Go to Extensions > Manage Extensions
3. Search for "GitHub Copilot"
4. Download and install
5. Restart Visual Studio
6. Sign in via Tools > GitHub Copilot > Manage GitHub Copilot Subscription

Visual Studio supports: Code completions, Copilot Chat, Inline Chat

3.6 Authentication Flow

OAuth Device Flow (used for Neovim, some CLI scenarios):

1. User runs auth command
2. A device code is generated
3. User goes to github.com/login/device
4. User enters the code
5. User authorizes the application
6. Token stored locally in credential manager

OAuth Browser Flow (VS Code, JetBrains):

1. Copilot extension prompts sign-in
2. Browser opens with GitHub OAuth page
3. User authorizes the GitHub Copilot application
4. Browser redirects back to IDE
5. Token stored in system credential manager

Token storage:

VS Code: stored in system keychain / VS Code credential store
JetBrains: stored in system credential manager
Neovim/Vim: stored in ~/.config/github-copilot/ directory

Token scopes required:

read:user — read user profile
user:email — read user email address
(Copilot subscription is validated server-side, not via token scope)

3.7 Organization Policy Configuration

Organization owners can configure Copilot policies from:

GitHub.com > Organization Settings > Copilot > Policies

Seat management (Copilot Business/Enterprise):

Enable for all current and future members
Enable for specific teams
Enable for specific users (manual assignment)
Disable for all (turn off org-wide)

Policy settings available at org level:

Policy	Options
---	---
Suggestions matching public code	Allowed / Blocked
GitHub Copilot Chat in IDE	Enabled / Disabled
GitHub Copilot CLI	Enabled / Disabled
GitHub Copilot in GitHub.com	Enabled / Disabled
Copilot for Pull Requests (Enterprise)	Enabled / Disabled
Bing web search (Enterprise)	Enabled / Disabled

Audit logs:

Available under Organization Settings > Audit Log
Records: who enabled/disabled Copilot, seat assignments, policy changes
Exportable via API or UI
Retention: 7 days for free, 90 days for GitHub Enterprise

3.8 Enterprise Policy Configuration

Enterprise admins (owner of a GitHub Enterprise account) have top-level policy controls:

Enterprise-level policies:

Set a default policy that all organizations in the enterprise inherit
Organizations can override if the enterprise allows it
Enterprise can enforce a setting that organizations cannot change

Enterprise Copilot settings path:

GitHub.com > Enterprise account > Settings > Copilot > Policies

Additional Enterprise controls:

IP allow list for Copilot API access
Managed knowledge bases
Fine-grained audit logging
Data governance controls

3.9 Content Exclusions

Content exclusions prevent Copilot from referencing specific files or directories when generating suggestions.

How content exclusions work:

Configured at organization or repository level
Excluded files are not sent to GitHub servers as context
Copilot will not suggest code based on excluded files
Also prevents excluded files from appearing in completions

Where to configure:

Repository level: Repository Settings > Copilot > Content exclusions
Organization level: Organization Settings > Copilot > Content exclusions (applies to all repos)

Configuration syntax (YAML):

# .github/copilot-exclusions (or set in UI)
# Exclude specific paths
paths:
  - "**/.env"
  - "**/secrets/**"
  - "config/production.yml"
  - "**/*.pem"
  - "src/proprietary/**"

Pattern syntax:

** matches any directory depth
* matches any characters within a single path segment
Patterns follow glob syntax
Paths are relative to the repository root

Common use cases for exclusions:

.env files with real secrets
Proprietary algorithm files
Compliance-sensitive data files
Files with personal information
Legacy files that contain patterns you don't want to propagate

Important exam points:

Content exclusions apply to CONTEXT, not just completions
Excluded files are not sent as prompt context to the model
Users see a message indicating a file is excluded
Exclusions are enforced on the server side for Business/Enterprise

3.10 Network Requirements

For GitHub Copilot to function, the following URLs must be accessible:

Required endpoints:

github.com                   # Authentication
api.github.com               # GitHub API
copilot-proxy.githubusercontent.com  # Copilot completions
copilot-telemetry.githubusercontent.com  # Telemetry
objects.githubusercontent.com         # Assets

Ports required:

443 (HTTPS) — all Copilot traffic uses HTTPS

Proxy configuration:

VS Code: configured in VS Code settings via http.proxy
System-level proxy: Copilot respects OS proxy settings
Enterprise can configure allowlisted proxy servers
Authenticated proxies are supported

VS Code proxy settings:

{
  "http.proxy": "http://proxy.company.com:8080",
  "http.proxyAuthorization": null,
  "http.proxyStrictSSL": true
}

Certificate issues:

Corporate SSL inspection may break Copilot's HTTPS
Custom root certificates can be added via OS trust store
VS Code: http.systemCertificates: true to use OS cert store

3.11 Troubleshooting Common Setup Issues

Problem: Copilot icon is red or not visible

Check: Is the extension installed? (Extensions panel)
Check: Are you signed in? (Accounts menu in VS Code)
Check: Does your account have a Copilot subscription?
Fix: Sign out and back in via VS Code Accounts menu

Problem: Suggestions not appearing

Check: Is the file type supported?
Check: Is Copilot enabled for this file (check status bar)?
Check: Are you on a network that blocks Copilot endpoints?
Fix: Check network connectivity to api.github.com

Problem: "Content excluded" message

Cause: File matches an organization content exclusion pattern
Info: This is expected behavior; the file is intentionally excluded
Action: If unintentional, check organization Content Exclusion settings

Problem: "GitHub Copilot could not connect to server"

Check: Network connectivity
Check: Proxy settings
Check: Firewall rules for copilot endpoints
Fix: Add Copilot URLs to network allowlist

Problem: JetBrains plugin not working after update

Fix: Invalidate caches and restart (File > Invalidate Caches)
Fix: Ensure IDE version meets minimum requirements

DOMAIN 4: EFFECTIVE USE

4.1 Prompt Engineering Fundamentals

Prompt engineering is the practice of structuring your inputs to Copilot to get better outputs. This is the highest-weighted domain on the exam.

The anatomy of an effective prompt:

1. Context: What is the broader situation?
2. Task: What specifically do you want done?
3. Constraints: What limitations or requirements apply?
4. Format: What should the output look like?

Example of poor vs. good prompt:

Poor:

# sort the list

Good:

# Sort a list of Employee objects by their hire_date (datetime) in descending order.
# Return a new list, do not modify the original. Handle None hire_date values by placing them last.

Core prompt engineering principles:

1. Be specific over general

"Write a function to process user data" → vague
"Write a Python function that takes a list of User objects and returns a dict mapping user IDs to email addresses" → specific

2. Provide context before the task

Write the relevant imports first
Name the class or module Copilot is working in
List the data structures being used

3. Use comments as prompts

Single-line comments trigger completions
Multi-line comments explain complex requirements
Docstrings provide structured guidance for function implementation

4. Name things clearly

calculateMonthlyInterestRate() tells Copilot much more than calc()
Good variable names guide completion quality

5. Provide examples in comments

# Input:  [{"name": "Alice", "score": 95}, {"name": "Bob", "score": 87}]
# Output: [("Alice", 95), ("Bob", 87)]
def convert_to_tuples(records):

6. Reference existing patterns

Open files that show the pattern you want to follow
Copilot uses open tabs as context
If you have a working example, Copilot will often follow it

7. Iterative refinement

Start with a prompt, review the output
Use Chat to refine: "That's close, but add error handling for the case where the list is empty"
Multi-turn conversations let you iteratively improve

4.2 Slash Commands

Slash commands are special directives in GitHub Copilot Chat that trigger specific behaviors.

Complete slash command reference:

/explain

Purpose: Explains what selected code does in plain language

Usage:

/explain
/explain what does this regex do
/explain step by step how this sorting algorithm works

When to use:

Understanding inherited code you did not write
Learning from Copilot's suggestions before accepting them
Onboarding to a new codebase
Understanding complex algorithms or regular expressions

Example interaction:

User: /explain
[code selected: complex regex pattern]

Copilot: This regular expression validates an email address format.
Breaking it down:
- `^` asserts start of string
- `[a-zA-Z0-9._%+-]+` matches one or more characters that can appear in the local part of an email
- `@` matches the literal @ symbol
- `[a-zA-Z0-9.-]+` matches the domain name
...

/fix

Purpose: Identifies and fixes bugs, errors, or issues in selected code

Usage:

/fix
/fix the null pointer exception
/fix this function to handle empty input
/fix the syntax errors

What /fix can handle:

Syntax errors
Logic bugs
Null/undefined reference errors
Type mismatches
Missing error handling
Performance issues
Security vulnerabilities (use with caution — verify the fix)

Example:

User: /fix the index out of bounds error
[code selected: array access without bounds check]

Copilot: The issue is that `items[index]` can throw an IndexError if index >= len(items).
Here's the fixed version:
[shows corrected code with bounds check]

/tests

Purpose: Generates unit tests for selected code

Usage:

/tests
/tests using pytest
/tests including edge cases
/tests with mocks for the database calls

Test generation capabilities:

Generates test functions/methods following your existing test patterns
Detects test framework in use (Jest, pytest, JUnit, etc.)
Can generate edge case tests
Can suggest mocks for external dependencies
Follow-up: "Add a test for when the input is null"

Best practices:

Select the specific function you want tested
Specify the testing framework if not obvious from context
Ask for edge cases explicitly
Review generated tests — they may not cover all paths

/doc

Purpose: Generates documentation for selected code

Usage:

/doc
/doc add JSDoc comments
/doc write a docstring following Google style
/doc add inline comments explaining the business logic

Documentation types generated:

Function/method docstrings (Python, Java, C#, etc.)
JSDoc comments (JavaScript/TypeScript)
XML documentation comments (C#)
Inline code comments
README sections

Example:

User: /doc
[code selected: Python function]

Copilot:
"""
Calculate the compound interest for a principal amount.

Args:
    principal (float): The initial investment amount.
    rate (float): Annual interest rate as a decimal (e.g., 0.05 for 5%).
    years (int): Number of years to compound.
    n (int, optional): Number of times interest compounds per year. Defaults to 12.

Returns:
    float: The final amount after compound interest.

Raises:
    ValueError: If principal or rate is negative, or years is not positive.

Example:
    >>> calculate_compound_interest(1000, 0.05, 10)
    1647.01
"""

/new

Purpose: Creates a new project, file, or scaffold based on a description

Usage:

/new React application with TypeScript and Tailwind CSS
/new Express.js REST API with user authentication
/new Python FastAPI service with SQLAlchemy

What /new creates:

Project scaffolding (package.json, tsconfig.json, etc.)
Directory structure
Basic boilerplate files
Sometimes offers to create the files directly in your workspace

Note: /new is primarily a VS Code feature and may create files in a new Copilot workspace context.

/newNotebook

Purpose: Creates a new Jupyter notebook

Usage:

/newNotebook exploring pandas data analysis
/newNotebook with matplotlib charts for sales data
/newNotebook machine learning pipeline for classification

Creates:

A new .ipynb file with appropriate cells
Import cells for common libraries
Markdown cells explaining sections
Code cells with starter implementation

/clear

Purpose: Clears the current Chat conversation history

Usage:

/clear

When to use:

Starting a new, unrelated task
When previous context is confusing new responses
To reset conversation state

Important: Clearing chat does not affect Copilot's context from open files; it only clears the chat history.

/help

Purpose: Shows available slash commands and their descriptions

Usage:

/help

Returns: A list of available slash commands with brief descriptions. Useful when you cannot remember all available commands.

4.3 Context Variables

Context variables explicitly tell Copilot Chat what to include as context. They dramatically improve response quality.

The @ prefix — chat participants:

@workspace

Scope: Entire workspace/project

What it does: Tells Copilot to consider all files in your workspace when formulating a response. Copilot indexes your workspace and can search across all files.

Usage examples:

@workspace how do we handle authentication in this project?
@workspace where is the database connection configured?
@workspace what testing framework do we use and what's the pattern?
@workspace find all places where we call the payment API

Best for:

Architecture questions
Finding patterns across the codebase
Understanding how components relate
Codebase onboarding

Limitations:

Very large workspaces may not be fully indexed
Copilot may not find every reference in very large repos
Slower than file-specific queries

@file (also written as #file in some contexts)

Scope: Specific file

Usage:

@file:src/auth/user.service.ts explain this file
#file:package.json what version of React are we using?

Best for:

Questions about a specific file
When you want to ensure a particular file is in context
Cross-referencing a file that is not currently open

@terminal

Scope: Current terminal content

What it does: Includes the current terminal output in the chat context. Especially useful for debugging error messages.

Usage examples:

@terminal what does this error mean?
@terminal help me fix this npm install failure
@terminal why did this test run fail?

Best for:

Debugging terminal errors
Explaining build failures
Understanding CLI tool output
Analyzing test failure logs

@vscode

Scope: VS Code itself — settings, extensions, commands

What it does: Provides context about VS Code configuration and enables asking VS Code-specific questions.

Usage examples:

@vscode how do I configure the linter
@vscode what keyboard shortcut opens the integrated terminal
@vscode how do I set up launch.json for debugging

Best for:

VS Code configuration questions
Setting up debugging
Finding VS Code settings
Understanding VS Code extensions and features

@github (Enterprise)

Scope: GitHub.com — repositories, issues, PRs, discussions

What it does: Connects Copilot Chat to your GitHub.com repositories and can search across them.

Usage examples:

@github search for our API client implementation
@github what's the status of PR #234
@github find the issue about the login bug

Best for:

Searching across multiple repositories
Referencing PRs and issues in conversation
Enterprise knowledge base queries

Note: @github is primarily an Enterprise feature, though limited GitHub.com integration exists in Business.

The # prefix — context attachments:

#file

Purpose: Attach a specific file to the chat context

Usage:

#file:src/models/user.ts how should I extend this model?
Refactor this using the same pattern as #file:src/models/product.ts

#selection

Purpose: Reference the currently selected text in the editor

Usage:

/explain #selection
What's the time complexity of #selection?

#editor

Purpose: Reference the full content of the currently active editor file

Usage:

Review #editor for potential bugs
What improvements would you suggest for #editor?

4.4 Agent Mode

What is Agent Mode?

Agent mode (also called "agentic" mode) is an advanced Copilot capability where Copilot can take multi-step actions autonomously to complete a complex task. Rather than responding to a single question, Copilot in agent mode can:

Read multiple files
Write or modify multiple files
Run terminal commands
Iterate on its work based on results
Ask clarifying questions when needed

How to enable Agent Mode:

In VS Code:

Open Copilot Chat panel
Click the mode selector (shows "Chat" by default)
Select "Agent" mode

Or use the #codebase context variable in newer versions.

Agent mode vs. Chat mode:

Aspect	Chat Mode	Agent Mode
---	---	---
Scope	Single response	Multi-step execution
File changes	Suggests changes	Can make changes directly
Terminal	Cannot run commands	Can run terminal commands
Iteration	Requires user prompts	Self-iterates
Approval	Not needed	May ask for approval on destructive actions
Best for	Questions, explanations	Complex implementation tasks

When to use Agent Mode:

Implementing a feature that spans multiple files
Refactoring across a codebase
Setting up a project from scratch
Running and fixing failing tests automatically
Making changes based on linting/compilation errors

When NOT to use Agent Mode:

Simple questions or explanations (use Chat)
When you want fine-grained control over each change
Security-sensitive code (autonomous changes need careful review)
Production environments (never run agents with production credentials)

Agent mode workflow example:

User: Implement a user authentication system using JWT.
      Create the necessary files in src/auth/

Copilot (agent):
Step 1: Reading existing project structure...
Step 2: Creating src/auth/jwt.service.ts
Step 3: Creating src/auth/auth.middleware.ts
Step 4: Updating src/app.ts to register auth routes
Step 5: Running npm run test to verify...
[Test output shows 3 failures]
Step 6: Fixing test failures...
Step 7: Tests passing. Implementation complete.

Exam key point: Agent mode is currently supported in VS Code and GitHub Codespaces. It is NOT available in JetBrains, Neovim, or Visual Studio.

4.5 Testing Workflows

Test-Driven Development (TDD) with Copilot:

1. Write a comment or docstring describing what you want to test
2. Copilot suggests the test implementation
3. Use the test as a specification for your implementation
4. Ask Copilot to implement the code to make the test pass

Generating tests with /tests:

# Select a function, then:
/tests
# Copilot generates:
def test_calculate_tax_with_zero_income():
    assert calculate_tax(0) == 0

def test_calculate_tax_with_standard_income():
    assert calculate_tax(50000) == 7500.0

def test_calculate_tax_with_negative_income():
    with pytest.raises(ValueError):
        calculate_tax(-100)

Testing workflows with Copilot Chat:

"Generate edge case tests for this function"
"What inputs would cause this function to fail?"
"Add tests for the error paths in this service"
"Generate integration tests for this API endpoint"
"Mock the database calls in these tests"

Test quality assessment:

Ask Copilot: "What test cases are missing from this test file?"
Ask Copilot: "What's the code coverage of these tests?"
Use /explain on generated tests to verify they test what you expect

4.6 Debugging Workflows

Using /fix for debugging:

Select the problematic code
Type /fix optionally with a description of the error
Review Copilot's explanation of the bug and the proposed fix
Use Ctrl+Enter or the inline diff to apply or reject

Using @terminal for runtime errors:

[Error in terminal:]
TypeError: Cannot read properties of undefined (reading 'map')
    at processUsers (user.service.ts:45)

[In Copilot Chat:]
@terminal what's causing this error and how do I fix it?

Rubber duck debugging with Chat:

Explain your problem to Copilot step by step
Copilot often identifies the issue as you describe it
"I have a function that should X, but instead it Y. Here's the code: ..."

Common debugging prompts:

"Why would this function return undefined?"
"What edge cases could cause this to fail?"
"Explain what this stack trace means"
"Is there a race condition in this async code?"
"Why is this test flaky?"

Debugging loop with agent mode:

In agent mode, Copilot can run tests, see failures, and fix them autonomously
Useful for: "Fix all failing tests in the auth module"

4.7 Documentation Workflows

Generating docstrings:

Place cursor inside a function
Type /doc
Copilot generates the appropriate docstring format for your language

Generating README content:

/doc write a README section explaining how to install and configure this module

Generating API documentation:

/doc generate OpenAPI-style documentation for this endpoint

Adding inline comments:

/doc add inline comments explaining the business logic

Documentation in different styles:

Python: Google style, NumPy style, reStructuredText
JavaScript/TypeScript: JSDoc
Java: Javadoc
C#: XML documentation comments
Go: Godoc style

Specify your preferred style:

/doc write a docstring in Google style format

Maintaining documentation:

After modifying a function: /doc update this docstring to reflect the new parameter
After refactoring: @workspace which docstrings are now out of date?

4.8 Code Review Workflows

Using Copilot for self-review before submitting a PR:

Review this function for potential issues:
- Security vulnerabilities
- Performance problems
- Missing error handling
- Edge cases not handled

Inline chat for targeted review:

1. Select code you want reviewed
2. Ctrl+I to open inline chat
3. Type "review this for security issues"

PR description generation (Enterprise):

On GitHub.com, in a PR
Click "Copilot" button in the PR description field
Copilot generates a summary based on the diff

Understanding someone else's code:

/explain [select code]
@workspace what's the purpose of the OrderProcessor class?
What design pattern is this implementing?

Reviewing pull requests with Copilot Chat:

"What are the main changes in this diff?"
"Are there any potential security issues in these changes?"
"What test coverage is missing for this feature?"

4.9 Custom Instructions

What are custom instructions?

Custom instructions allow you to provide persistent context that Copilot applies to all interactions in a repository. They override Copilot's defaults with your team's conventions.

File location: .github/copilot-instructions.md

Scope: Applies to all users of Copilot in that repository

What you can specify:

Coding style preferences
Preferred frameworks and libraries
Naming conventions
Error handling patterns
Testing requirements
Architecture patterns to follow
Things to avoid

Example .github/copilot-instructions.md:

# GitHub Copilot Instructions for MyProject

## General Guidelines
- Use TypeScript for all new files
- Prefer functional programming patterns over class-based approaches
- All functions must have explicit return type annotations

## Code Style
- Use 2-space indentation
- Use single quotes for strings
- Trailing commas required in multi-line expressions
- Follow Airbnb style guide

## Error Handling
- Always use Result<T, E> pattern for functions that can fail
- Never throw exceptions in service layer — return error objects
- Log errors with structured logging using our Logger class

## Testing
- Write tests before implementation (TDD)
- Use Jest with the testing-library patterns
- Minimum 80% coverage required for new code
- Mock all external services in unit tests

## Framework Preferences
- Use React functional components with hooks only (no class components)
- State management: Zustand (not Redux)
- HTTP client: use our custom ApiClient wrapper, not axios directly
- Database: use the Repository pattern with TypeORM

## Avoid
- Do not use any (use unknown instead)
- Do not use var (use const or let)
- Do not commit TODO comments
- Do not use console.log (use our Logger service)

Limits and constraints:

Maximum file size: 8KB (as of current docs)
Markdown format only
Applied at the repository level
Users can add personal instructions via IDE settings as well

Personal vs. repository instructions:

Repository: .github/copilot-instructions.md — shared with the team
Personal: Can be set in VS Code settings > GitHub Copilot > Instructions

How Copilot applies custom instructions:

Instructions are prepended to the context of each Chat interaction
They influence completions in that repository
More specific instructions take precedence

4.10 Copilot Extensions

What are Copilot Extensions?

Copilot Extensions (formerly called Copilot plugins) allow third-party tools and internal tools to integrate into the Copilot Chat experience. They extend Copilot's capabilities with domain-specific knowledge or tool integrations.

Types of extensions:

GitHub Marketplace extensions: Published by third parties, available to all
Internal extensions: Built by your organization for internal tools
Partner extensions: Integrated tools from Copilot's ecosystem

Examples of Copilot Extensions:

Sentry: Ask Copilot about production errors from your Sentry account
Docker: Get help with Docker containers and compose files
Datadog: Query your observability data with natural language
MongoDB: Database assistance
Stripe: Payment API assistance

Enabling extensions:

GitHub Marketplace > Copilot Extensions category
Install the extension to your organization or personal account
Enable in Copilot settings
Access in Chat using @extension-name

How to use extensions in Chat:

@docker how do I optimize this Dockerfile for smaller image size?
@sentry what's causing the spike in errors today?

Building extensions:

Copilot extensions use the GitHub Apps framework
Extensions receive a subset of conversation context
Respond with Copilot-formatted messages
Can access external systems on your behalf

Policy management:

Organization admins can allow or block specific extensions
Enterprise can control extension access organization-wide

4.11 Copilot Limitations

Understanding Copilot's limitations is as important as knowing its features.

Technical limitations:

Context window: Copilot has a limited context window; very large files may not be fully considered
Language support: Best for popular languages; less accurate for niche languages
Proprietary APIs: Copilot doesn't know your internal APIs without context
Real-time data: Copilot doesn't know about events after its training cutoff
Non-deterministic: Same prompt can produce different results each time

When NOT to use Copilot suggestions:

1. Novel algorithm design: For truly new algorithms, expert design is required
2. Security-sensitive implementations: Crypto, auth, payment flows — always expert review
3. Regulatory compliance code: Healthcare (HIPAA), financial (PCI-DSS) — requires compliance review
4. Code you cannot understand: Never accept code you cannot explain
5. Hardcoded secrets: Never accept suggestions with credentials
6. Legally sensitive code: License management, DRM — legal review required

Accuracy limitations:

Copilot may suggest confidently wrong code
Generated tests may not cover all edge cases
Documentation may be generic rather than accurate
Refactoring suggestions may miss subtle dependencies

Organizational considerations:

IP ownership of AI-generated code is legally uncertain
Establish policies before widespread adoption
Consider how Copilot affects junior developer learning
Set expectations with stakeholders about productivity gains

PRACTICE QUESTIONS

Domain 1: Responsible AI

Q1: What happens to code snippets (prompts) sent to GitHub Copilot by a GitHub Copilot Business user?

A) They are stored for 30 days and then deleted

B) They are used to retrain the model

C) They are not retained by GitHub beyond the request

D) They are stored and can be reviewed by organization admins

Answer: C — Business plan prompts are not retained for training.

Q2: Which of the following is a responsible practice when using GitHub Copilot?

A) Accept suggestions quickly to maximize productivity

B) Only review suggestions for security-sensitive code

C) Understand and review all suggestions before committing

D) Trust Copilot for cryptographic implementations since it was trained on best practices

Answer: C — All suggestions should be reviewed before accepting.

Q3: GitHub Copilot's Public Code Matching feature, when set to "Blocked", does what?

A) Blocks Copilot from accessing public repositories for training

B) Prevents suggestions that closely match existing public code from being shown

C) Blocks all Copilot suggestions until code is reviewed

D) Prevents the user from copying public code manually

Answer: B — It prevents showing suggestions that match public code verbatim.

Domain 2: Features and Plans

Q4: Which GitHub Copilot plan includes knowledge bases?

A) Individual

B) Business

C) Enterprise

D) All plans

Answer: C — Knowledge bases are an Enterprise-only feature.

Q5: A developer wants to use gh copilot suggest to generate a git command. Which flag specifies the command type?

A) --type git

B) -t git

C) --mode git

D) -m git

Answer: B — The -t flag specifies the type: shell, gh, or git.

Q6: Which plan supports automatic PR summary generation on GitHub.com?

A) Individual

B) Business

C) Enterprise

D) Business and Enterprise

Answer: C — PR summaries are an Enterprise-only feature.

Domain 3: Setup and Configuration

Q7: Which editor supports GitHub Copilot Agent Mode?

A) VS Code and JetBrains

B) VS Code and Visual Studio

C) VS Code and GitHub Codespaces

D) All supported IDEs

Answer: C — Agent mode is available in VS Code and GitHub Codespaces.

Q8: Where should content exclusion patterns be configured to apply to all repositories in an organization?

A) In each repository's .github/copilot-exclusions file

B) In the organization's Copilot settings on GitHub.com

C) In the enterprise's SAML configuration

D) In each user's VS Code settings

Answer: B — Organization-level exclusions are configured in organization settings.

Q9: What is the correct file location for repository-level content exclusions configured in code?

A) .github/copilot-exclusions

B) .copilot/exclusions.yml

C) copilot.config.json

D) .github/copilot.yml

Answer: A — Content exclusions can be set via .github/copilot-exclusions or in repository settings UI.

Domain 4: Effective Use

Q10: Which context variable would you use to ask Copilot about the current terminal error output?

A) @editor

B) @terminal

C) @vscode

D) #selection

Answer: B — @terminal includes current terminal content in the chat context.

Q11: What is the primary difference between Copilot Chat and Agent Mode?

A) Agent mode uses a different AI model

B) Agent mode can take multi-step actions including reading/writing files and running commands

C) Agent mode only works offline

D) Chat mode is faster than agent mode

Answer: B — Agent mode can autonomously take multi-step actions.

Q12: Where is the custom instructions file for a repository located?

A) .copilot/instructions.md

B) .github/copilot-instructions.md

C) docs/copilot.md

D) .vscode/copilot.md

Answer: B — The file is .github/copilot-instructions.md.

Q13: Which slash command would you use to generate unit tests for a selected function?

A) /doc

B) /new

C) /tests

D) /fix

Answer: C — /tests generates unit tests for selected code.

Q14: To cycle to the next code completion suggestion in VS Code, which keyboard shortcut do you use?

A) Ctrl + ]

B) Alt + ]

C) Shift + Tab

D) Ctrl + Space

Answer: B — Alt + ] cycles to the next suggestion.

GLOSSARY

Agent Mode: An advanced Copilot mode where Copilot autonomously takes multi-step actions to complete complex tasks.

Chat Participant: Context providers prefixed with @ in Copilot Chat (e.g., @workspace, @terminal, @vscode, @github).

Completion: An inline code suggestion shown as ghost text in the editor.

Content Exclusion: Configuration that prevents specific files or directories from being used as Copilot context.

Context Window: The amount of text a language model can consider at one time.

Copilot Extension: A third-party or internal integration that extends Copilot Chat with domain-specific capabilities.

Custom Instructions: Team-specific guidance provided via .github/copilot-instructions.md that Copilot applies to all interactions in a repository.

Ghost Text: The grayed-out text that appears inline as Copilot suggests a completion.

Knowledge Base: Enterprise-only feature that indexes organizational documentation for Copilot to reference.

LLM (Large Language Model): A neural network trained on large text datasets that can generate text, code, and other content.

Prompt: The input context sent to Copilot's AI model to generate a completion or response.

Prompt Engineering: The practice of crafting inputs to AI systems to improve the quality of outputs.

Public Code Matching: A setting that controls whether Copilot suggestions matching existing public code are shown or blocked.

Seat: A license assignment that gives a specific user access to GitHub Copilot.

Slash Command: A command prefixed with / in Copilot Chat that triggers specific behaviors (e.g., /explain, /fix, /tests).

Telemetry: Usage data sent to GitHub to improve the Copilot product.

Training Data: The code and text used to train the GitHub Copilot model.

*Last updated for GH-300 exam scope. Verify feature availability at docs.github.com/copilot before the exam.*

GH-300 Study Manual

GitHub Copilot Certification (GH-300) — Complete Exam Guide

TABLE OF CONTENTS

DOMAIN 1: RESPONSIBLE AI

1.1 What Is Generative AI?

1.2 How GitHub Copilot Works

1.3 Types of Bias in AI Systems

1.4 Privacy: What Data Copilot Sends

1.5 Security Considerations

1.6 Responsible Use Principles

1.7 Copyright and Licensing

1.8 Transparency

DOMAIN 2: FEATURES AND PLANS

2.1 Plan Overview

2.2 GitHub Copilot Individual

2.3 GitHub Copilot Business

2.4 GitHub Copilot Enterprise

2.5 Plan Feature Comparison Table

2.6 Code Completion — How It Works

2.7 GitHub Copilot Chat

2.8 GitHub Copilot CLI

2.9 GitHub Copilot Mobile

2.10 GitHub Copilot on GitHub.com

DOMAIN 3: SETUP AND CONFIGURATION

3.1 Supported IDEs and Editors

3.2 VS Code Installation

3.3 JetBrains Installation

3.4 Neovim Installation

3.5 Visual Studio Installation

3.6 Authentication Flow

3.7 Organization Policy Configuration

3.8 Enterprise Policy Configuration

3.9 Content Exclusions

3.10 Network Requirements

3.11 Troubleshooting Common Setup Issues

DOMAIN 4: EFFECTIVE USE

4.1 Prompt Engineering Fundamentals

4.2 Slash Commands

/explain

/fix

/tests

/doc

/new

/newNotebook

/clear

/help

4.3 Context Variables

@workspace

@file (also written as #file in some contexts)

@terminal

@vscode

@github (Enterprise)

The # prefix — context attachments:

#file

#selection

#editor

4.4 Agent Mode

4.5 Testing Workflows

4.6 Debugging Workflows

4.7 Documentation Workflows

4.8 Code Review Workflows

4.9 Custom Instructions

4.10 Copilot Extensions

4.11 Copilot Limitations

PRACTICE QUESTIONS

Domain 1: Responsible AI

Domain 2: Features and Plans

Domain 3: Setup and Configuration

Domain 4: Effective Use

GLOSSARY