Overview
Use GitHub Copilot features is the broadest domain on GH-300 and was updated on August 7, 2026. It has four official groups. Using Copilot in the IDE covers enabling it, triggering it through inline suggestions, chat, CLI and agent mode, and configuring content exclusions. Using GitHub Copilot CLI covers what the CLI is, installing it, its key commands, interactive and session use, and generating scripts and managing files.
The features and capabilities group covers agent mode, Copilot Edits and the Model Context Protocol, agent sessions and delegating work to sub-agents, Copilot code review, Copilot Spaces, GitHub Spark, pull request summaries, instructions files for review standards, and Chat limits, commands, feedback and prompt files. The final group covers organization-wide policy management, Copilot code review policies, feature availability across IDEs and github.com, audit log events, and managing Copilot subscriptions through the REST API.
How it's tested
Feature questions describe a goal and ask which Copilot surface, command, file or setting meets it. Some focus on developers choosing between chat, agent mode and the CLI. Others put you in the organization owner's role, deciding on policies, seat assignment or audit evidence. Read for who is acting and where they are working.
-
Pick the surface
A task is described, and you choose inline suggestions, Chat, agent mode, the Copilot CLI, the coding agent, Spaces or Spark.
-
Right file, right place
A team wants consistent behavior, and you choose between repository custom instructions, path-specific instructions files and reusable prompt files.
-
Administrator action
An organization owner needs to enable a feature, assign seats, review activity or automate licensing, and you pick the policy, audit log or REST API.
A team lead wants Copilot code review to flag missing input validation in every pull request, using the team's own standards. Writing the rule in each review comment does not scale, and a prompt file only runs when someone invokes it. Adding the standard to the repository's Copilot instructions file lets code review apply it automatically, so the instructions file is the correct choice.
Functional groups 4
Official functional groups from the GitHub (Microsoft) outline, in outline order.
2.1 Use GitHub Copilot in the IDEEnabling Copilot, triggering it in several ways, and IDE content exclusions.
- What it means
- This group covers three official skills: enable Copilot in the IDE, trigger Copilot through inline suggestions, chat, CLI and agent mode, and configure content exclusions for specific files or repositories at an application knowledge level.
- What to understand
- Copilot runs as an extension in supported editors such as Visual Studio Code, Visual Studio, JetBrains IDEs, Xcode, Eclipse and Vim or Neovim, after signing in with a GitHub account that has Copilot access. Inline suggestions appear as ghost text while typing and are accepted with Tab. Chat answers questions and proposes changes, agent mode plans and performs multi-step edits and terminal commands, and the CLI brings the agent to the terminal. Content exclusions stop chosen paths from being used.
- How it shows up
- Expect a developer goal, such as a quick completion or an autonomous multi-file change, and a choice of how to invoke Copilot.
- Common confusion
- Assuming content exclusions apply to every mode; GitHub documents that edit and agent modes in IDEs do not honor them.
2.2 Use GitHub Copilot CLIWhat the Copilot CLI is, installing it, commands, sessions, and scripting work.
- What it means
- This group covers five official skills: define GitHub Copilot CLI and its benefits, identify the installation steps, describe key features and commands, use it interactively and in sessions, and generate scripts and manage files with it.
- What to understand
- GitHub Copilot CLI is a terminal-based agent started with the copilot command. It answers questions, edits files, runs shell commands with your approval and works with GitHub.com. Interactive mode is a conversation you steer, while programmatic mode takes a single prompt through the -p flag and exits. Slash commands such as /model, /mcp, /context and /compact manage the session, and options like --allow-tool and --deny-tool control which tools run without prompting.
- How it shows up
- Look for terminal-centric tasks, such as generating a deployment script or renaming files in bulk, where the CLI fits best.
- Common confusion
- Confusing the current Copilot CLI agent with the older gh copilot extension that only suggested and explained single commands.
2.3 Use GitHub Copilot features and capabilitiesAgent mode, Edits, MCP, sub-agents, code review, Spaces, Spark, PR summaries, Chat and prompt files.
- What it means
- This group covers four official skills: use agent mode, Copilot Edits and MCP and manage agent sessions with sub-agents; use Copilot for code review and coding help; use Spaces, Spark, pull request summaries and instructions files for review standards; and understand Chat limits, options, feedback, commands and prompt files.
- What to understand
- Agent mode works autonomously across files, while edit mode applies changes to files you select. MCP connects Copilot to external tools and data through servers such as the GitHub MCP server. Sub-agents run a delegated task in their own context window and return only the result. Code review comments on pull requests and follows instructions files. Spaces collect curated context, Spark builds small apps from natural language, and prompt files store reusable prompts.
- How it shows up
- Expect to choose the feature that matches a stated need, such as shared project context, reusable prompts or a review standard.
- Common confusion
- Mixing up instructions files, which apply automatically, with prompt files, which run only when a user invokes them.
2.4 Manage organization-wide settings and policiesCopilot policies, code review policies, audit log events and seat management via REST API.
- What it means
- This group covers three official skills: configure organization-wide policy management, including Copilot code review policies and feature availability across IDEs and github.com; use audit log events; and manage subscriptions using the REST API.
- What to understand
- Organization owners on Copilot Business or Enterprise decide which features members may use, such as Chat, the CLI, the coding agent, MCP servers, preview features and alternative models. Enterprise policies can enforce a setting or leave the choice to each organization. Audit log events record seat assignments and policy changes. The REST API can list, add and remove Copilot seats for users and teams, which supports automated licensing.
- How it shows up
- Look for an administrator scenario asking how to enable, restrict, audit or automate Copilot across many users.
- Common confusion
- Expecting the audit log to hold prompt and suggestion content; it records administrative events, not what developers typed.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Agent mode
An IDE chat mode where Copilot plans, edits multiple files and runs commands.
- Remember
- It iterates on errors and asks before running terminal commands.
- Tested as
- Surface-selection questions.
- Trap
- Confusing it with the cloud-based coding agent.
-
Copilot coding agent
An agent assigned an issue on GitHub that works in the background and opens a pull request.
- Remember
- It runs in a GitHub Actions powered environment.
- Tested as
- Delegation questions.
- Trap
- Thinking it edits your local workspace.
-
Copilot Edits (edit mode)
Chat-driven changes applied to a working set of files you choose.
- Remember
- You control which files change.
- Tested as
- Edits versus agent questions.
- Trap
- Expecting it to run terminal commands.
-
Model Context Protocol (MCP)
An open standard for connecting AI agents to tools and data sources.
- Remember
- Servers are configured per editor or repository and governed by policy.
- Tested as
- Extending agent capabilities.
- Trap
- Treating MCP as a Copilot model.
-
Sub-agents
Delegated agents that run a task in a separate context window.
- Remember
- They return a result and keep the main context small.
- Tested as
- New August 2026 content.
- Trap
- Assuming they share the full parent context.
-
Copilot CLI
A terminal agent launched with the copilot command.
- Remember
- Use -p for single-prompt programmatic runs.
- Tested as
- CLI questions.
- Trap
- Confusing it with the GitHub CLI itself.
-
Repository custom instructions
A .github/copilot-instructions.md file applied to Copilot requests in that repository.
- Remember
- Path-specific .instructions.md files target matching files.
- Tested as
- Review standard questions.
- Trap
- Putting team rules in a prompt file instead.
-
Prompt files
Reusable .prompt.md files invoked by name in Chat.
- Remember
- They give consistent responses on demand.
- Tested as
- Chat reuse questions.
- Trap
- Expecting them to apply automatically.
-
Copilot Spaces
Curated collections of code, docs and notes used as grounding context.
- Remember
- Spaces can be shared across a team.
- Tested as
- Context-sharing questions.
- Trap
- Confusing Spaces with Codespaces.
-
GitHub Spark
A tool that builds and deploys small apps from natural language descriptions.
- Remember
- Aimed at quick micro apps, not large codebases.
- Tested as
- Feature identification.
- Trap
- Confusing it with agent mode.
-
Copilot code review
Copilot reviews a pull request and leaves comments and suggested changes.
- Remember
- It can be requested manually or automatically and follows instructions files.
- Tested as
- Review policy questions.
- Trap
- Treating its review as a required approval.
-
Copilot policies
Organization and enterprise settings controlling feature availability.
- Remember
- Enterprise policy can override organization choice.
- Tested as
- Administrator questions.
- Trap
- Configuring them per developer in the IDE.
-
Copilot user management REST API
Endpoints for listing, adding and removing Copilot seats.
- Remember
- Supports team-based and user-based assignment.
- Tested as
- Automation questions.
- Trap
- Using the audit log to assign seats.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Ask vs. edit vs. agent vs. coding agent
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Chat (ask) | Answers questions and proposes code | No automatic file changes | Expecting it to edit files directly |
| Edit mode | Applies changes to selected files | You define the working set | Expecting autonomous terminal use |
| Agent mode | Plans and executes multi-step work locally | Edits files and runs commands with approval | Confusing it with the coding agent |
| Coding agent | Works on an assigned issue on GitHub | Runs in the cloud and opens a pull request | Thinking it changes your local files |
Instructions files vs. prompt files vs. Spaces
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Repository instructions file | Standing guidance for every request | Applied automatically | Expecting it only when invoked |
| Path-specific instructions | Guidance for files matching a glob | Scoped with applyTo | Assuming it covers the whole repository |
| Prompt file | A reusable task prompt | Invoked on demand by name | Expecting automatic application |
| Copilot Space | Curated grounding context | Collects sources for answers | Treating it as a rules file |
Policies vs. audit log vs. REST API
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Policies | Control which Copilot features are allowed | Preventive configuration | Using them to report activity |
| Audit log | Records administrative events | Evidence after the fact | Expecting prompt content |
| REST API | Programmatic seat and settings management | Automation at scale | Using it as a policy override |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Agent mode is the coding agent
- What candidates pick
- Choose agent mode to have Copilot work on an issue overnight and open a pull request.
- Why it looks right
- Both are called agents.
- Why it's wrong
- Agent mode runs in your editor session; background work on an issue that ends in a pull request is the Copilot coding agent.
Clue to watch for The scenario mentions assigning an issue or working while the developer is away.
-
Prompt files apply themselves
- What candidates pick
- Use a prompt file so code review always checks a standard.
- Why it looks right
- Prompt files hold reusable instructions.
- Why it's wrong
- Prompt files run only when invoked; automatic standards belong in repository or path-specific instructions files.
Clue to watch for The requirement says every request or every review.
-
Audit log shows prompts
- What candidates pick
- Search the audit log for what a developer asked Copilot.
- Why it looks right
- The audit log tracks Copilot activity.
- Why it's wrong
- Audit log events cover administrative actions such as seat and policy changes, not prompt or suggestion content.
Clue to watch for The question asks for evidence of who changed a setting or seat.
-
Manage seats manually
- What candidates pick
- Assign licenses one by one in the web UI for a large reorganization.
- Why it looks right
- It is the familiar path.
- Why it's wrong
- The Copilot user management REST API lets administrators add or remove seats for users and teams programmatically.
Clue to watch for Words like automate, script or hundreds of users.
-
Exclusions cover agent mode
- What candidates pick
- Rely on content exclusions to keep files out of agent mode.
- Why it looks right
- Exclusions sound global.
- Why it's wrong
- GitHub documents that edit and agent modes in IDEs do not support content exclusions, so other controls are needed.
Clue to watch for The scenario combines agent mode with sensitive files.
-
Sub-agents share context
- What candidates pick
- Expect a sub-agent to see the whole parent conversation.
- Why it looks right
- It is part of the same session.
- Why it's wrong
- A sub-agent works in its own context window and returns only its result, which keeps the main context lean.
Clue to watch for The goal is to save context or isolate a research task.
-
Spaces are Codespaces
- What candidates pick
- Pick GitHub Codespaces to share curated context with Copilot.
- Why it looks right
- The names are similar.
- Why it's wrong
- Codespaces are cloud development environments; Copilot Spaces gather code, documents and notes to ground Copilot answers.
Clue to watch for The need is shared reference context, not a dev environment.
Answer framework
For a GH-300 feature scenario, use these steps to land on the expected Copilot surface or setting.
- Identify the actor: a developer working in an editor or terminal, a reviewer on a pull request, or an organization or enterprise owner.
- For developers, match the task size: inline suggestions for small completions, Chat for questions, edit mode for chosen files, agent mode for multi-step local work, the CLI for terminal work.
- If the work should happen in the background from an issue and end in a pull request, choose the Copilot coding agent rather than agent mode.
- For consistent behavior, choose instructions files for automatic rules, prompt files for on-demand tasks, Spaces for shared context and MCP for external tools.
- For administrators, use policies to allow or block features, the audit log for evidence of changes, and the REST API to automate seat management.
Practice question
Want more like this? The GH-300 practice test has questions for every domain.
Checklist
0 of 14
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Give this domain the most study time, since it is the largest and the most practical. Work through it with Copilot open: Visual Studio Code with the Copilot extension, a terminal with Copilot CLI installed, and a test organization or repository on github.com.
Begin with the IDE. Try inline suggestions, ask Chat questions, make a multi-file change in edit mode, then repeat it in agent mode and watch how it runs commands. Add an MCP server and see new tools appear. Next, install Copilot CLI, run it interactively, then use the -p flag in a small script, and practise approving and denying tools.
Then cover the github.com features: assign an issue to the coding agent, request a Copilot code review, add a copilot-instructions.md file, create a prompt file, and build a Space. Finish with the administrator view by reading the Copilot policies pages, audit log event list and seat management REST endpoints. Because the August 2026 outline added sub-agents, Spaces and Spark, check that your notes are current and use practice questions to sharpen surface selection.
FAQ
How much of GH-300 is Domain 2, Use GitHub Copilot features?
Use GitHub Copilot features is 25–30% of the exam, the largest domain, so plan for roughly fifteen to eighteen questions.
What changed in this domain on August 7, 2026?
Microsoft marked the IDE group and the features and capabilities group as having minor changes. The current wording adds agent mode triggering, agent sessions, sub-agents, Spaces, Spark and prompt file reuse.
What is the difference between agent mode and the Copilot coding agent?
Agent mode works inside your editor on local files and asks before running commands. The coding agent takes an assigned issue on GitHub, works in a cloud environment and opens a pull request.
How do I install GitHub Copilot CLI?
GitHub documents installers for macOS, Linux and Windows, including an npm package. After installing, run copilot in a trusted directory and sign in with an account that has Copilot access.
Where should team review standards go?
In repository custom instructions, .github/copilot-instructions.md, or path-specific .instructions.md files, which Copilot code review reads automatically.
Can organization owners control which Copilot features are available?
Yes. Copilot Business and Enterprise policies let owners enable or disable features such as Chat on github.com, the CLI, the coding agent, MCP servers and preview models.
Do I need to memorise REST API endpoints?
You should know that the Copilot user management API lists, adds and removes seats for users and teams. Exact paths are less important than knowing the API is the automation route.
Other Artificial Intelligence & Machine Learning certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 2 knowledge
You have covered Copilot in the IDE, the Copilot CLI, agent features, code review, Spaces, Spark and organization policies. Test whether you can pick the right feature for each scenario.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the GH-300 AI tutor Get any concept explained your way