GitHub Copilot (GH-300) Exam Questions

Domain 1: Use GitHub Copilot responsibly (15–20%)

Which of these is a limitation that GitHub documents for Copilot’s code suggestions?

⬜ Its suggestions can reflect biases that exist in its training data.
⬜ Its suggestions are inserted into your code automatically, without you accepting them.
⬜ Its content filtering guarantees that generated code has no security vulnerabilities.
⬜ It can generate suggestions only for JavaScript and Python.

What is a limitation of Copilot Chat when it works across different programming languages and coding styles?

⬜ Bias in its training data can favor some languages or styles, lowering suggestion quality for others.
⬜ Any supported language gets the same suggestion quality as every other supported language.
⬜ Using local code context removes the influence of training data from its suggestions.
⬜ Public-code matching decides whether a suggestion follows the project’s coding style.

What potential harm can come from accepting code snippets that GitHub Copilot suggests?

⬜ Copilot always follows ethical coding practices.
⬜ The suggested code might contain security vulnerabilities.
⬜ Copilot guarantees it never suggests copyrighted code.
⬜ Copilot makes sure all code is secure and free of bias.

When building AI-powered tools such as GitHub Copilot, which principle matters most for responsible AI?

⬜ Maximizing efficiency even if user privacy suffers.
⬜ Using AI only to automate repetitive tasks, without considering ethics.
⬜ Making sure the AI system puts fairness, reliability and transparency first.
⬜ Letting the AI make decisions without human oversight to speed up innovation.

Which steps reduce the risk of inaccurate or inappropriate code when you use Copilot Chat to generate code? (select three)

⬜ Review the generated code to confirm it fits the codebase’s architecture and style.
⬜ Trust the generated code once it compiles, because it is probably correct.
⬜ Check that the generated code follows best practices and established design patterns.
⬜ Skip testing generated code for non-critical applications, because Copilot is highly accurate.
⬜ Always test and validate generated code, especially for critical or sensitive applications.

What does the accountability principle of responsible AI emphasize?

⬜ AI systems should be able to run independently without human oversight.
⬜ AI systems should put innovation ahead of safety and reliability.
⬜ AI systems must always be open source so they avoid errors.
⬜ The people who build AI systems are responsible for monitoring how they perform and reducing risks to prevent harm.

While reviewing a GitHub issue, a reviewer finds text telling Copilot cloud agent to ignore the requested bug fix and reveal private configuration data. Which risk is this text trying to exploit?

⬜ Prompt injection through the task content
⬜ Hallucination in generated source code
⬜ Public-code matching in a completion
⬜ A change to the model provider’s retention policy

A Copilot suggestion comes with a reference to matching public code. What helps the team decide whether its licensing policy allows them to use the suggestion?

⬜ Inspect the referenced source and its license information as part of the team’s review process.
⬜ Treat the presence of a code reference as proof that the suggestion carries no restrictions.
⬜ Accept the suggestion’s license terms based on how popular the referenced repository is.
⬜ Ask Copilot to rename the variables and consider the licensing concern resolved.

A repository requires an approving review before merging, and Copilot approvals are turned off. Copilot’s review overview says the pull request is ready to approve. How should the maintainer treat that assessment?

⬜ As review feedback that doesn’t meet the repository’s approval requirement.
⬜ As meeting the approval requirement once its review comments are resolved.
⬜ As meeting the approval requirement once the pull request’s checks pass.
⬜ As replacing the approval requirement when Copilot wrote the pull request.

A function’s documented contract says null input must be rejected with a validation error. Copilot generates a test that expects an empty result for null. The function raises the documented error, so the test fails. What should the developer change?

⬜ Fix the test so it expects the documented validation error for null input.
⬜ Change the function to return an empty result so it passes the generated test.
⬜ Delete the null test and treat the remaining passing tests as proof that validation is correct.
⬜ Ask Copilot to regenerate the function without giving it the documented null-input requirement.

Copilot explains why a generated calculation should return a certain value, but no code has been run. What does that explanation tell you?

⬜ It’s a proposed account of the logic that still has to be checked against actual execution and the requirements.
⬜ It’s a record of an execution trace showing the function returned the stated value.
⬜ It’s a test report confirming the function passed the project’s numerical checks.
⬜ It’s a benchmark comparing the generated function with the project’s previous implementation.

A bilingual team plans to prompt Copilot Chat both in English and in another natural language. Which expectation matches Copilot Chat’s documented language support?

⬜ Results can differ between languages, because Copilot Chat is optimized mainly for English.
⬜ The same model gives equally good answers in both prompt languages.
⬜ The selected programming language decides the natural language of each response.
⬜ Changing the editor’s display language confirms that translated responses are accurate.

A team uses Copilot to draft applicant-screening logic, then checks whether equally qualified applicants get different outcomes depending on their demographic group. Which responsible AI principle is the team mainly evaluating?

⬜ Fairness
⬜ Transparency
⬜ Privacy and security
⬜ Accountability

A team is applying the responsible AI principle of reliability and safety. Which measures specifically test how the system fails or limit the consequences of failure? (select two)

⬜ Test the system under expected and unexpected conditions to find its failure modes.
⬜ Define safe fallback behavior for when the system can’t complete a task reliably.
⬜ Publish a user-facing explanation of what the system can and can’t do.
⬜ Document which team is accountable for decisions made during deployment.
⬜ Offer accessible ways to interact for users with different abilities.

Copilot proposes a replacement loop and says it’s faster. The original and the new version give the same results in the existing tests. What evidence should a reviewer ask for before accepting the speed claim?

⬜ Measurements comparing both versions with representative input sizes and conditions.
⬜ A comparison showing that the new version has fewer lines of source code.
⬜ A second explanation from Copilot that uses more detailed performance terminology.
⬜ A larger number of passing correctness assertions for the new version.

A team uses Copilot to draft a user interface, then tests and revises it for keyboard navigation and screen-reader users. Which responsible AI principle most directly drives making the interface usable by people with different abilities?

⬜ Inclusiveness
⬜ Transparency
⬜ Accountability
⬜ Privacy and security

During a Copilot safety evaluation, testers deliberately use difficult prompts designed to provoke unsafe or policy-violating responses. What is the main purpose of this adversarial testing?

⬜ To find unsafe responses that can be used to improve safeguards.
⬜ To estimate how quickly routine prompts produce accepted code suggestions.
⬜ To rank supported programming languages by how much training data exists for them.
⬜ To measure the memory needed to process a typical code-completion request.

During a Copilot pilot, the team accepts more suggestions every week, but reviewers say they spend more time fixing the resulting code. Which evaluation best shows whether the pilot is improving delivery time and code quality?

⬜ Compare delivery time and quality against the baseline, including review and rework effort.
⬜ Compare the number of accepted suggestions with the number shown during the pilot.
⬜ Compare the number of generated lines with the number written without assistance.
⬜ Compare the number of active Copilot users with the number of assigned licenses.

Copilot drafts a database update endpoint that takes a record ID and a new value from the request. The team must prevent SQL injection and stop users from updating other users’ records. Which checks directly evaluate those risks? (select two)

⬜ Trace how request values reach the database and confirm the endpoint uses parameterized queries.
⬜ Test whether one authenticated user can update a record that belongs to another user.
⬜ Measure the endpoint’s response time with the expected number of concurrent users.
⬜ Run the project formatter and compare the result with the repository’s style rules.
⬜ Confirm that a successful update returns the documented JSON response structure.

A developer wants Copilot to investigate a parsing failure in exported support data that contains customer names, email addresses and account notes. A synthetic sample reproduces the same failure. Which input best follows the principle of data minimization?

⬜ The synthetic sample, the parser code and the relevant error details, with sensitive values removed.
⬜ The original export with customer names removed but email addresses and account notes kept.
⬜ The original export, together with a request that Copilot ignore its personal information.
⬜ The original export, after turning on blocking of suggestions that match public code.

An organization owner is enabling a custom model hosted by a provider. The provider can issue either a key with only the permissions needed to call that model, or a key with extra administrative permissions. Which choice follows GitHub’s guidance?

⬜ Use the key with the minimum permissions the configured model needs.
⬜ Use the broader key so Copilot can give more knowledgeable responses.
⬜ Use the broader key and rely on repository instructions to limit its permissions.
⬜ Use the broader key and rely on public-code filtering to limit what it can do at the provider.

A team is writing up its internal Copilot rollout. It wants developers to understand the tool’s limits and to have a way to raise concerns about harmful results. Which measures directly address those goals? (select two)

⬜ Explain the approved uses, known limitations and how developers should review generated output.
⬜ Provide a clear reporting process and name the team responsible for investigating concerns.
⬜ Use the number of accepted suggestions as evidence that the rollout is safe.
⬜ Treat the installation steps as the complete guidance for using Copilot responsibly.
⬜ Describe the enabled content filters as sufficient protection against harmful results.

A team working in an uncommon programming language keeps finding errors in Copilot’s suggestions, even after providing relevant examples. What is a responsible way to continue?

⬜ Use Copilot selectively, check its suggestions against documentation and tests, and write code by hand where its suggestions don’t fit.
⬜ Keep accepting suggestions so daily use trains a more accurate personal model for the team.
⬜ Treat code that looks like the supplied examples as validated, without running the relevant tests.
⬜ Switch the project to a more common language before looking into the errors in the suggestions.

A team uses Copilot to generate much of a new service. Several people review the code, but nobody is responsible for approving releases or responding to reported harm. Which change most directly closes this accountability gap?

⬜ Assign a human owner with authority over release approval and corrective action.
⬜ Record which Copilot model generated each change in the release notes.
⬜ Raise the number of automated tests required before a release can go ahead.
⬜ Publish the service’s limitations in a document for its intended users.

Copilot generates name-validation code for a service meant for users worldwide. The code rejects legitimate names that contain accented letters or non-Latin characters. Which actions directly address this unfair effect? (select two)

⬜ Test representative names from the intended user groups and compare how often each is rejected.
⬜ Revise the rule so it accepts legitimate names while keeping the service’s real constraints.
⬜ Apply the existing validation rule consistently in every deployment region.
⬜ Measure average validation speed on a larger sample of ASCII names.
⬜ Replace rejected names with randomly assigned labels in the user interface.

Copilot Chat states that a service rejects unauthenticated requests, but it gives no supporting code references or test results. A developer plans to rely on that claim while reviewing the service. What should happen next?

⬜ Check the authentication implementation and the relevant tests before relying on the claim.
⬜ Ask Copilot the same question again and treat a repeated answer as verification.
⬜ Ask another model to judge the statement from its wording alone and accept agreement as confirmation.
⬜ Turn on blocking of suggestions that match public code and treat the claim as verified.

Copilot code review recommends removing a validation check as redundant. The maintainer confirms an external caller can pass invalid input to the function, and a test fails when the check is removed. How should the maintainer handle the suggestion?

⬜ Keep the check and explain why the observed caller behavior and the failing test contradict the review comment.
⬜ Remove the check and change the test to accept the behavior the review suggests.
⬜ Remove the check once Copilot makes the same recommendation in another review.
⬜ Document valid input as a precondition and remove the check without updating the external caller.

A team is reviewing Copilot-generated code that routes support tickets. Tickets with the same urgency and support level should get the same priority whatever language they’re written in. Which use of Copilot most directly helps evaluate that requirement?

⬜ Draft paired test cases that change only the language while keeping urgency and support level the same.
⬜ Draft a benchmark that measures average routing time across the existing ticket sample.
⬜ Draft a report that calculates one overall accuracy score across the existing ticket sample.
⬜ Draft formatting rules that standardize the generated routing code across the project.

Copilot generates a sign-in handler from a prompt asking for secure code. Tests with valid credentials pass, but nobody has checked how the handler treats hostile input. Which next step closes that gap before release?

⬜ Review the generated input-handling logic and add tests for invalid or malicious input.
⬜ Ask Copilot to describe the handler’s security properties in comments beside the unchanged code.
⬜ Regenerate the handler with stronger security wording and rerun the existing valid-credential tests.
⬜ Ask Copilot to standardize formatting and use the resulting style checks as release evidence.

A team deploying a Copilot-assisted tool documents where AI contributes and what its limitations are. It also restricts access to submitted data and protects that data while it’s processed. Which responsible AI principles do these measures most directly address? (select two)

⬜ Transparency
⬜ Privacy and security
⬜ Fairness
⬜ Inclusiveness
⬜ Accountability

A developer has reviewed a Copilot suggestion, confirmed it meets the requirements, and run the team’s required tests and policy checks. No defects or required changes were found. Which approach is consistent with responsible use?

⬜ Keep the suggestion unchanged and follow the team’s normal approval process.
⬜ Require a cosmetic rewrite so the accepted code differs from Copilot’s output.
⬜ Discard the checked suggestion and ask for a new one because it was AI-generated.
⬜ Require a second model to produce identical code before accepting it.

A Copilot-generated test runs every line of a function but never checks the return value. The requirement specifies the expected result for the test input. Which change makes the test actually check that requirement?

⬜ Add an assertion that compares the returned value with the result the requirement specifies.
⬜ Run the unchanged test repeatedly to confirm its line coverage stays the same.
⬜ Rename the test to include the expected result but leave its body unchanged.
⬜ Add more calls with the same input without checking what they return.

A team is writing guidance on appropriate requests for GitHub Copilot Chat. Which request fits its documented purpose of helping with coding and related technology tasks?

⬜ Explain how this application’s database connection pool handles concurrent requests.
⬜ Choose a restaurant for a team lunch based on everyone’s favorite cuisines.
⬜ Plan a sightseeing itinerary for the team’s weekend trip to a nearby city.
⬜ Recommend a weekly exercise schedule based on the team’s sporting interests.

A developer removes all demographic references from a prompt before asking Copilot to draft a decision-making function. Why should the generated logic still be reviewed for unfair outcomes?

⬜ Patterns the model learned, or patterns in the supplied examples, can still shape the generated logic.
⬜ Public-code matching checks licensing and also certifies that allowed suggestions are fair.
⬜ Using a private repository makes the model’s decisions independent of its training patterns.
⬜ Choosing a different Chat model removes the need to evaluate the decision criteria.

A team validated a reusable Copilot Chat prompt with one model and now plans to use it with a different model. Which approach gives evidence that the prompt still meets the team’s requirements?

⬜ Evaluate representative outputs against the same acceptance criteria and revise the prompt where it fails.
⬜ Reuse the first model’s passing results as the evaluation record for the second model.
⬜ Pick the model with the larger context window and treat the extra capacity as proof of correctness.
⬜ Ask the second model to rate its own answers and replace the acceptance checks with that rating.

A Copilot-generated diagnostic function logs complete request headers, including authentication tokens. It passes its tests, but team policy forbids storing those tokens in logs. Which follow-up request directly fixes the policy violation?

⬜ Revise the logging code to leave out authentication tokens, keep useful diagnostics, and test that tokens don’t appear in logs.
⬜ Move the same logging statement into a separate helper function and rerun the existing tests.
⬜ Log less often so fewer requests write their complete headers to the log.
⬜ Add comments explaining why headers help with debugging and keep the current logging.

A developer needs a reproducible total from a local CSV file. Copilot is available in VS Code with approved terminal tools. Which workflow gives the strongest basis for checking the number?

⬜ Have Copilot write and run a calculation script, then inspect the input handling, logic and execution result.
⬜ Ask Copilot to state the total in Chat along with a confidence percentage.
⬜ Repeat the same Chat request several times and take the most common total.
⬜ Choose a model with a larger context window and accept its total without running anything.

Copilot Chat generates employee test records that keep pairing leadership roles with one gender. The dataset must represent genders across all job levels. Which workflow most directly addresses this pattern?

⬜ Provide representative examples and distribution requirements, regenerate the records, and check how genders are spread across job levels.
⬜ Generate a larger dataset with the same prompt, then check its record count and field types.
⬜ Remove the gender field from the existing data, then check that employee IDs are unique.
⬜ Ask Copilot to justify the role assignments and use that as evidence of representative coverage.

Domain 2: Use GitHub Copilot features (25–30%)

A developer is setting up a Copilot Space to give Copilot the right context for a project. What can a Space contain?

⬜ Repositories, individual files, issues, pull requests and free-text content such as notes or transcripts.
⬜ Only one repository, which Copilot loads into context in full for every question.
⬜ Only Markdown documentation collected from one or more repositories.
⬜ Only source code files; issues, pull requests and free-text notes aren’t supported.

An organization wants to connect a fine-tuned model, hosted by a provider, to Copilot Chat using its own API key. Which statements should guide the setup? (select three)

⬜ Connecting the model to Copilot moves its inference into GitHub’s hosting environment.
⬜ The organization should review the provider’s privacy and data-retention terms.
⬜ An administrator makes the model available by configuring the API key for a supported provider.
⬜ Fine-tuning can adapt the model to the organization’s coding conventions, but its output still needs evaluating.

A developer has Node.js 22 installed and wants to install GitHub Copilot CLI for the first time. Which command should they run?

⬜ npm install -g @github/copilot
⬜ copilot update
⬜ copilot completion zsh
⬜ copilot login

In Visual Studio Code with the default keyboard shortcuts, a developer wants to open editor inline chat inside the active file. The file isn’t part of an active chat editing session. What should they do?

⬜ Choose Quick Chat from the Chat menu in the title bar.
⬜ Focus the integrated terminal and start Terminal Inline Chat from the Command Palette.
⬜ Choose Open Chat from the Copilot Chat menu to show the Chat view.
⬜ Focus the editor and press Ctrl+I on Windows or Cmd+I on macOS.

An organization on Copilot Business wants to review the actions a particular user has taken, including who changed a Copilot setting. How can an owner find this?

⬜ Search the organization’s audit log using action:copilot together with an actor: qualifier for the user’s username.
⬜ Audit logs aren’t directly available, so submit a support request to get up to 180 days of logs.
⬜ Download the logs from the Copilot section of the organization settings.
⬜ Copilot setting changes aren’t in the audit log; only interactions with Copilot are recorded.

A developer with a personal GitHub account wants to use Copilot Free in VS Code. Which statement about getting access is correct?

⬜ They must join a GitHub Team organization to turn on Copilot Free.
⬜ They can turn on Copilot Free directly on their personal account.
⬜ They must be given a Copilot Enterprise seat to turn on Copilot Free.
⬜ They must start a Copilot Pro trial before Copilot Free can be enabled.

An organization wants to export Copilot engagement data, such as active users and usage broken down by feature and IDE, for an adoption review. Which API fits?

⬜ The Copilot usage metrics REST API
⬜ The Copilot user management REST API
⬜ The organization audit log REST API
⬜ The GitHub Actions workflow runs REST API

A platform team keeps answering the same questions about its service architecture, coding standards and deployment process. It wants Copilot to give teammates consistent answers grounded in the team’s own documentation and code. Which Copilot capability fits best?

⬜ Add a custom model trained on the team’s codebase to improve inline completions.
⬜ Create a Copilot Space with the relevant repositories, docs and notes, and share it with the team so Copilot grounds its answers in that context.
⬜ Assign the recurring questions to Copilot cloud agent so it researches the repository and opens a pull request.
⬜ Turn on content exclusion so Copilot reads only the team’s approved files.

Which descriptions of built-in slash commands in Copilot Chat for Visual Studio are correct? (select four)

⬜ /doc opens GitHub’s reference documentation in a browser.
⬜ /help gives a quick reference for using Copilot.
⬜ /optimize switches Copilot to a faster model to cut response time.
⬜ /tests generates unit tests for the selected code.
⬜ /fix suggests fixes for problems in the selected code.
⬜ /explain describes how the code in the active editor works.

Which capability does Copilot Business offer that Copilot Pro doesn’t?

⬜ Inline code suggestions
⬜ Organization-wide policy management
⬜ Chat
⬜ Copilot CLI access

In VS Code, a developer wants to rate a particular Copilot Chat response as helpful or unhelpful. How do they do that?

⬜ Post about it on social media to start a discussion.
⬜ Email GitHub Support for feedback from the support team.
⬜ Click the thumbs up or thumbs down icon next to the response.
⬜ Post in a community forum for Copilot feature requests.

An organization buys GitHub Copilot directly from GitHub under a volume licensing agreement covered by the GitHub Generative AI Services Terms. How do those terms handle defense against third-party claims involving generated output?

⬜ An existing defense provision in the organization’s Agreement also covers its use of Copilot, including the output it generates.
⬜ The defense provision covers the Copilot service but not the output the service generates.
⬜ Buying a paid Copilot plan creates defense coverage even if the Agreement has no defense provision.
⬜ The defense provision covers generated output only after the organization moves to Copilot Enterprise.

Which two GitHub Copilot plans are designed for organizations and enterprises?

⬜ Copilot Pro and Copilot Pro+
⬜ Copilot Student and Copilot Business
⬜ Copilot Pro and Copilot Enterprise
⬜ Copilot Business and Copilot Enterprise

In a short Copilot Chat conversation, a developer shares a small self-contained function and asks for an explanation. Copilot describes behavior that the function doesn’t have. Which limitation explains this best?

⬜ Copilot can misread code and produce an explanation that sounds plausible but is wrong.
⬜ Some Copilot features are available in some IDEs but not in others.
⬜ Copilot has a limited context window for the information in a request.
⬜ The model’s training may not include recently released libraries and frameworks.

While typing in VS Code, a developer sees dimmed code proposed at the cursor position. Which Copilot feature is this?

⬜ Copilot pull request summaries
⬜ Copilot code review
⬜ Copilot agent mode
⬜ Inline code suggestions (code completion)

What does a Copilot pull request summary give you?

⬜ The version history of staged code waiting to be pushed to the repository
⬜ A line-by-line diff of every committed file
⬜ An overview of the proposed changes and why they were made
⬜ Feedback from team members on the code in the pull request

In VS Code you want to save a repeatable code-generation task, together with its instructions and context, so you can run it in Copilot Chat whenever you need it. Which feature does this?

⬜ Code snippets, such as a .code-snippets file
⬜ Prompt files, such as a .prompt.md file
⬜ Repository instructions in .github/copilot-instructions.md
⬜ Workspace settings in .vscode/settings.json

A maintainer wants Copilot to implement a well-defined repository issue in the background on GitHub and open a pull request for review. Which workflow fits?

⬜ Assign the issue, with clear acceptance criteria, to Copilot cloud agent.
⬜ Use agent mode in the IDE to do the work in the maintainer’s local workspace.
⬜ Ask Copilot code review to examine an existing pull request for the issue.
⬜ Create a Copilot Space containing the issue and ask Copilot to explain it.

A developer saves release-check.prompt.md as a VS Code user prompt. After cloning the repository, teammates can’t find it. The team uses local agents with prompt-file support and default discovery settings. What change shares the prompt with the team?

⬜ Commit the prompt file to the repository’s .github/prompts folder.
⬜ Turn on Settings Sync for prompt files in the author’s VS Code profile.
⬜ Add the prompt’s name to the repository’s .github/copilot-instructions.md file.
⬜ Set the user prompt’s name field to a shared command name.

Copilot cloud agent has opened a pull request, but its implementation misses some acceptance criteria. A maintainer with write access wants the agent to revise that pull request. What should the maintainer do?

⬜ Mention @copilot in a review comment that describes the missing behavior and the change needed.
⬜ Generate a new pull request summary that describes how the implementation should behave.
⬜ Request Copilot code review and treat its comments as changes to the implementation.
⬜ Add the acceptance criterion to the issue title and treat the pull request as updated.

A developer has set up the remote GitHub MCP server in VS Code, but its tool list has no tools for Copilot Spaces. What should the developer check?

⬜ Whether the copilot_spaces toolset is enabled for the remote GitHub MCP server
⬜ Whether a different language model is selected for Chat responses
⬜ Whether the Space’s source files have been added to a content exclusion policy
⬜ Whether a prompt file has been added to the current Chat request

A team wants GitHub Copilot CLI to call tools provided by an external issue-tracking service. What configuration adds that capability?

⬜ Register the service’s Model Context Protocol (MCP) server with /mcp add.
⬜ Add custom instructions that describe how the team uses the issue tracker.
⬜ Set up content exclusions for files that contain issue-tracker credentials.
⬜ Run /review to analyze local code changes related to issue tracking.

A developer wants to see which commands are available in the current VS Code Copilot Chat session. What opens the command list?

⬜ Type / in the chat input.
⬜ Open the # context picker.
⬜ Open the @ participant picker.
⬜ Open the chat model picker.

An administrator who has permission to view an organization’s Copilot metrics wants to compare daily and weekly active-user trends in GitHub’s web interface. Which view should they use?

⬜ The organization’s Copilot usage metrics dashboard
⬜ The organization’s audit log filtered for Copilot events
⬜ The organization’s list of assigned Copilot seats
⬜ A repository’s GitHub Actions workflow run history

A team wants Copilot Chat to receive the same repository-specific coding conventions in every new conversation, in editors that support it. Which approach fits?

⬜ Put the conventions in .github/copilot-instructions.md in the repository.
⬜ Put the conventions in a .prompt.md task file and assume it runs in every conversation.
⬜ Describe the conventions in one developer’s chat and rely on its history for the whole team.
⬜ Pick a shared language model and treat that choice as the repository’s coding conventions.

In VS Code, the review criteria exist only in the main Copilot conversation. The agent delegates a review to a subagent with the task prompt “Review this module for issues,” and the subagent ignores those criteria. What change directly fixes the missing context?

⬜ Include the agreed criteria explicitly in the task prompt sent to the subagent.
⬜ Repeat the criteria in the main conversation and resend the same subagent task prompt.
⬜ Use the same model for both agents and resend the same subagent task prompt.
⬜ Compact the main conversation to keep its decisions and resend the same subagent task prompt.

A developer has started an interactive GitHub Copilot CLI session and needs to sign in. Which slash command starts authentication?

⬜ /login
⬜ /help
⬜ /model
⬜ /usage

A team is reviewing an app built with GitHub Spark, which has since been retired. Which description matches how Spark originally built and published apps?

⬜ It generated a full-stack web app from a prompt, with data storage and hosting included.
⬜ It generated a static front end, with app data handled by services the developer set up separately.
⬜ It opened a pull request in an existing repository, with publishing handled by that repository’s deployment pipeline.
⬜ It generated source files in a local editor, with previews and hosting provided by the developer’s own environment.

A pull request author generates a Copilot summary and then pushes substantial code changes. What should the author do before relying on that summary for review?

⬜ Regenerate or edit the summary and check it against the updated diff.
⬜ Keep the summary, because new commits refresh its contents automatically.
⬜ Replace the diff review with the code references linked in the original summary.
⬜ Use the original summary as evidence that the new commits meet the issue’s requirements.

A developer on macOS already has Homebrew installed, but GitHub Copilot CLI isn’t installed yet. Which command installs the standalone CLI?

⬜ brew install --cask copilot-cli
⬜ copilot update
⬜ copilot init
⬜ copilot completion zsh

An organization owner is automating Copilot seat assignment for an existing team. Which GitHub REST API capability is meant for this?

⬜ Copilot user management endpoints that add teams to the organization’s Copilot subscription
⬜ Copilot usage metrics endpoints that export the organization’s adoption reports
⬜ Organization audit log endpoints that retrieve recorded Copilot access changes
⬜ Repository collaborator endpoints that give the team’s members repository access

Which built-in enterprise role can set enterprise-wide Copilot feature policies without needing an extra custom permission?

⬜ Enterprise owner
⬜ Enterprise billing manager
⬜ Enterprise member
⬜ Organization owner

A developer with a personal Copilot Pro subscription is assigned a Copilot Business license by an organization. What happens to the personal subscription?

⬜ The personal Copilot plan is canceled when the Business license is assigned.
⬜ The personal plan stays active and keeps being billed separately.
⬜ The personal plan stays active, but future charges move to the organization.
⬜ The personal plan stays active until the end of its current billing period.

In a VS Code Copilot session with checkpoints turned on, which statements correctly distinguish restoring a checkpoint from editing an earlier request? (select two)

⬜ Restoring a checkpoint rolls file changes back to that point without changing the request.
⬜ Editing an earlier request undoes its changes and all later ones, then resends the revised request.
⬜ Restoring a checkpoint reruns the earlier request with the currently selected model.
⬜ Editing an earlier request changes its text but keeps the later file changes as they are.
⬜ Restoring a checkpoint resets files to the latest Git commit instead of the saved request state.

A team wants a reusable Copilot specialist with security-review instructions and a deliberately limited set of tools. Which customization defines that role and its tools?

⬜ A custom agent profile
⬜ A repository semantic index
⬜ A Copilot Space
⬜ A completion model selection

Under usage-based billing for Copilot Business and Copilot Enterprise, which activity is included without being charged in GitHub AI Credits?

⬜ Getting inline code completions in the editor
⬜ Asking a coding question in Copilot Chat
⬜ Running a coding task with Copilot CLI
⬜ Asking a question grounded in a Copilot Space

A developer wants to pause Copilot inline suggestions in VS Code for a short time, while keeping the extension installed and Chat available. Which control fits?

⬜ Snooze inline suggestions from the Copilot menu.
⬜ Disable the Copilot extension for the workspace.
⬜ Change the language model used for Chat responses.
⬜ Sign out of the GitHub account that Copilot uses.

On GitHub.com, a maintainer describes three unrelated bugs in one prompt and asks Copilot to create a separate issue for each. What can Copilot provide in that conversation?

⬜ Three separate issue drafts for the maintainer to review before they’re created
⬜ One combined issue draft, because each conversation is limited to one issue
⬜ Three published issues that skip the draft review and creation step
⬜ Three pull request drafts in place of the requested issue descriptions

After a developer changes a function signature in VS Code, an arrow appears in the editor gutter pointing to a suggested follow-up edit, and pressing Tab jumps to it. Which Copilot capability is this?

⬜ Next edit suggestions
⬜ Ghost-text completion at the current cursor
⬜ Rename Symbol refactoring
⬜ Copilot code review

Which pairs of command and effect correctly describe controls in an interactive GitHub Copilot CLI session? (select two)

⬜ Use /model to change the model for the current session.
⬜ Use /theme to change the CLI’s color theme.
⬜ Use /usage to grant tool permissions for the current session.
⬜ Use /compact to start a new conversation with empty history.
⬜ Use /diff to discard uncommitted changes in the current directory.

A developer wants Copilot in VS Code to find the files needed for a validation change, edit them and run the relevant tests with permitted tools. Which workflow fits?

⬜ Agent mode, with the needed editing and terminal tools available
⬜ Plan mode, to produce an implementation plan for the task
⬜ Ask mode, to discuss the change and suggest code
⬜ Inline completions, to suggest code while the developer types

A pull request author explains a deployment decision in the description, then uses Copilot’s Summary action on GitHub.com. The generated summary leaves that explanation out. What should the author do before publishing the summary?

⬜ Review the summary and add the confirmed reason for the deployment decision as extra context.
⬜ Regenerate the summary and rely on it to merge the existing description with the code changes.
⬜ Turn on automatic Copilot reviews so the Summary action starts including the existing description.
⬜ Use Copilot’s code review findings as the reason for the deployment decision without checking the author’s intent.

Which statements reflect realistic expectations for code generated by GitHub Copilot Chat? (select two)

⬜ Code that looks syntactically valid may still implement the wrong behavior.
⬜ Patterns in the training data can influence which coding styles the suggestions favor.
⬜ Repository custom instructions verify that generated code meets each requirement.
⬜ Switching to another supported model guarantees that the next response will be accurate.
⬜ A detailed prompt removes the need to review the generated implementation.

An organization on Copilot Business uses usage-based billing. A developer asks questions in an existing Copilot Space. How is this usage billed?

⬜ Each question consumes AI credits from the shared pool, based on the model and tokens processed.
⬜ The questions draw on a separate fixed allowance assigned to each Space when it’s created.
⬜ The questions are covered by the paid plan’s unlimited code-completion benefit.
⬜ Credits are consumed when the Space’s sources change, not when questions are asked.

A Copilot agent in VS Code needs to investigate security and performance separately before changing code. Which subagent capabilities support these investigations without adding all the intermediate steps to the main conversation? (select two)

⬜ Subagents can run the independent investigations in parallel.
⬜ Each subagent returns a focused result from its own separate context.
⬜ Each subagent writes its research steps directly into the main conversation as it works.
⬜ The main agent has to finish one investigation before it can delegate the other.
⬜ A subagent takes over the main session instead of returning its findings.

A team creates a Copilot Space for a large repository. One small design document should be considered with every question, while implementation details only need to be retrieved when relevant. Which source setup best meets these needs?

⬜ Attach the design document as an individual file and add the repository as a source.
⬜ Add the repository as a source and rely on retrieval to include the design document every time.
⬜ Put the design document’s file name in the Space description and add the repository as a source.
⬜ Attach implementation files individually and leave the design document in the repository source.

An organization owner manages Copilot Business licenses. The enterprise lets the organization choose which Chat models to allow, but it has explicitly disabled Copilot code review for this organization. Which actions can the owner take? (select two)

⬜ Use Copilot > Models in the organization settings to manage the model choices the enterprise allows.
⬜ Use Copilot > Policies to manage feature settings within the enterprise’s restrictions.
⬜ Use a developer’s personal Copilot settings to turn on the code review the enterprise disabled.
⬜ Use Copilot > Policies to override the enforced enterprise restriction with an organization preference.
⬜ Use the IDE model picker to change which Chat models are available to the organization.

The organization allows Model Context Protocol (MCP) in VS Code, and a developer has installed a trusted MCP server for an internal service. Copilot’s agent still can’t use the expected tool. Which checks directly confirm whether that tool is available to the agent? (select two)

⬜ Check that the MCP server is enabled and starts successfully.
⬜ Check that the tool is selected in the chat input’s Configure Tools control.
⬜ Set the entry for the current file’s language to true in github.copilot.enable.
⬜ Add the service URL to .github/copilot-instructions.md instead of checking the MCP configuration.
⬜ Run /tests to make the service tool appear in the tool list.

In VS Code, the first line of a Copilot inline suggestion is useful but the remaining lines aren’t. Which action keeps the first line without inserting the unwanted lines first?

⬜ Accept the next line of the suggestion, then dismiss the rest.
⬜ Accept the whole suggestion, then ask Chat to remove the unsuitable lines.
⬜ Dismiss the suggestion and expect the first line to stay in the file.
⬜ Cycle to another suggestion so it appends the first line from the current one.

In VS Code, a developer can reliably reproduce a defect in the Copilot Chat interface itself. The problem isn’t the quality of a specific answer. How should they report it?

⬜ Open a GitHub issue for the VS Code Copilot Chat extension, including the steps to reproduce the defect.
⬜ Use the thumbs-down control on the chat response shown when the defect happens.
⬜ Use the Send Feedback button in Visual Studio for the VS Code extension defect.
⬜ Post the reproduction steps in a pull request review in the application’s repository.

A company keeps its repositories outside GitHub and wants centrally managed Copilot Business access. Its standard GitHub enterprise account has no organizations. Which approach supports this without adding organization memberships?

⬜ Invite users to the enterprise and assign Copilot Business licenses directly or through enterprise teams.
⬜ Assign GitHub Enterprise Cloud licenses and treat them as Copilot Business access.
⬜ Have users sign in through enterprise SSO and treat a successful sign-in as their Copilot license.
⬜ Have users buy personal Copilot subscriptions and manage them through enterprise team membership.

An enterprise owner is looking into new Copilot license assignments in the audit log. Which documented filter limits the results to new license-assignment events?

⬜ action:copilot.cfb_seat_assignment_created
⬜ action:copilot, to include all Copilot plan events
⬜ actor:Copilot, to include the agent’s activity
⬜ actor:octocat, to include that account’s activity

An organization owner uses the Copilot REST API to remove a directly assigned user from the organization’s subscription. The seat is marked as pending cancellation, and the user has no other source of Copilot access. When does their access end?

⬜ At the end of the current billing cycle
⬜ As soon as the API returns a successful response
⬜ The next time the user signs in from the IDE
⬜ When the user is removed from the organization

A developer has installed and signed in to GitHub Copilot CLI. From the project directory, how do they start an interactive conversation about a coding task?

⬜ Run copilot, then type the task as a prompt in the session.
⬜ Run copilot -p followed by the task description in quotes.
⬜ Run copilot help commands, then type the task at the shell prompt.
⬜ Run copilot completion zsh, then type the task at the shell prompt.

A repository uses .github/copilot-instructions.md for general guidance. In VS Code, the team also wants test-writing instructions to apply automatically to matching test files. Which setup does this?

⬜ Keep the general file and add a .instructions.md file under .github/instructions with an applyTo pattern for test files.
⬜ Move the general file into a test folder and keep the name copilot-instructions.md.
⬜ Put the test rules in a .prompt.md file and expect them to apply automatically to matching paths.
⬜ Put the test rules in the general file and rely on their position to decide which paths they match.

Under standard usage-based billing, with no temporary promotions, how do the monthly AI credits included with Copilot Business and Copilot Enterprise compare?

⬜ An Enterprise seat adds more included credits to the shared pool than a Business seat.
⬜ A Business seat adds no included credits, while an Enterprise seat adds a monthly amount.
⬜ Both seats add the same amount, but Enterprise lets unused credits roll over.
⬜ Business uses a shared pool, while Enterprise reserves each seat’s credits for that person.

A developer uses GitHub Copilot in Eclipse on Windows with the default key bindings. Which shortcut requests an inline suggestion?

⬜ Ctrl+Alt+/
⬜ Tab
⬜ Ctrl+Right Arrow
⬜ Esc

A maintainer creates a Copilot Space for database migrations. Chat should act as a migration reviewer, focus on rollback plans and avoid suggesting unrelated schema changes. Which Space field is designed for this?

⬜ Instructions, which define the role and scope of the assistance
⬜ Description, which explains the Space to potential collaborators
⬜ Name, which identifies the Space in the list of Spaces
⬜ Visibility, which controls who can find and open the Space

A developer wants automatic suggestions while typing unit tests, and afterwards a conversation weighing the pros and cons of two refactoring approaches. Which pair of Copilot experiences matches these, in order?

⬜ Inline suggestions first, then Copilot Chat
⬜ Copilot Chat first, then inline suggestions
⬜ Inline suggestions for both
⬜ Copilot Chat for both

An administrator is analyzing code_acceptance_activity_count in a per-user Copilot usage report. Which statements describe how this metric counts acceptance actions? (select two)

⬜ Using the built-in Copy button on generated code counts as an acceptance action.
⬜ Each acceptance action adds one to the count, however many code blocks were generated.
⬜ Copying selected text with the operating system’s Ctrl+C shortcut counts as an acceptance action.
⬜ Each code block in a response adds to the count before the user does anything.
⬜ Each acceptance adds to the count only after the copied code passes its automated tests.

Which built-in organization role can view the organization audit log by default, without an extra delegated role?

⬜ Organization owner
⬜ Organization member
⬜ Organization billing manager
⬜ Repository administrator

In Visual Studio Code on Windows with Copilot enabled and default shortcuts, which shortcut opens Quick Chat, the lightweight panel at the top of the editor?

⬜ Ctrl+Shift+Alt+L
⬜ Ctrl+I
⬜ Ctrl+Alt+I
⬜ Ctrl+Shift+P

A repository has .github/copilot-instructions.md and .github/instructions/typescript.instructions.md. The second file’s applyTo pattern matches the TypeScript file being edited. In VS Code, custom instructions are enabled and the two files don’t conflict. Which instructions apply when Copilot works on that file?

⬜ The repository-wide instructions and the matching path-specific instructions are combined.
⬜ The path-specific instructions replace the repository-wide instructions.
⬜ The repository-wide instructions apply and the path-specific file is skipped.
⬜ The developer has to attach both instruction files manually to every Chat request.

An organization gives Copilot access to selected members. An owner with the right API authorization wants to grant access to specific users. Which REST request does that?

⬜ POST /orgs/{org}/copilot/billing/selected_users with a selected_usernames array in the body
⬜ DELETE /orgs/{org}/copilot/billing/selected_users with a selected_usernames array in the body
⬜ POST /orgs/{org}/copilot/billing/selected_teams with a selected_teams array in the body
⬜ GET /orgs/{org}/copilot/billing/seats with pagination parameters to list assigned seats

An issue on GitHub.com contains conflicting reports about which release introduced a bug. A maintainer wants Copilot Chat to summarize them without presenting unverified claims as facts. Which request fits best?

⬜ Summarize the conflicting reports, separate observations from guesses, and list what still needs verifying.
⬜ Use the newest comment to identify the affected release and present its explanation as the conclusion.
⬜ Pick the release mentioned by the most commenters and summarize it as the one that introduced the bug.
⬜ Merge the reported explanations into one root cause and leave the disagreements out.

A developer wants to compare two models for inline completions (ghost text) in a Go project. VS Code and the Copilot extension are up to date, and an alternative completion model is available. Which workflow selects that model and gives a fair comparison?

⬜ Run GitHub Copilot: Change Completions Model, then test comparable tasks with the same context and checks.
⬜ Change the model in Copilot Chat, then test ghost-text completions with the same context and checks.
⬜ Turn on next edit suggestions, then test ghost-text completions with the same context and checks.
⬜ Add model-selection instructions in source comments, then test ghost-text completions with the same context and checks.

A developer has several saved GitHub Copilot CLI sessions. From the interactive interface, which command lists them so they can switch back to an earlier debugging session?

⬜ /resume
⬜ /compact
⬜ /clear
⬜ /context

A public Copilot Space includes a source linked from a private GitHub repository. A viewer can open the Space but doesn’t have access to that repository. What can the viewer access from that linked source?

⬜ Access to the Space doesn’t give them access to the private repository source.
⬜ The Space’s public visibility gives them Read access to the source repository.
⬜ A Copilot Enterprise subscription gives them access to private sources in public Spaces.
⬜ Opening the source in a Space conversation copies the owner’s repository permissions to them.

Copilot has finished reviewing a pull request on GitHub.com. The author then pushes more commits, and automatic Copilot reviews are turned off. How can the author request another review of the updated code without changing repository policy?

⬜ Request a re-review using the button next to Copilot in the Reviewers menu.
⬜ Reply to an existing Copilot review comment asking it to review the new commits.
⬜ Resolve the earlier Copilot review conversations after pushing the new commits.
⬜ Generate an updated Copilot pull request summary describing the new commits.

A company needs organization-wide Copilot policies, usage reporting and content exclusions for inline suggestions in supported IDEs. Which plan meets these needs at the lowest base price per seat?

⬜ GitHub Copilot Business
⬜ GitHub Copilot Free
⬜ GitHub Copilot Pro+
⬜ GitHub Copilot Enterprise

An organization grants Copilot access through a team. Adding someone to that team creates a copilot.cfb_seat_added event whose actor is the person who originally enabled Copilot for the team. How should an auditor find who actually added the member?

⬜ Look at the matching team.add_member or org.add_member membership event.
⬜ Treat the actor in copilot.cfb_seat_added as the person who changed the team membership.
⬜ Use the last_activity_at value on the member’s Copilot seat record.
⬜ Use the organization’s aggregate Copilot acceptance metrics.

A pull request changes one source file by 450 lines, counting additions and deletions together. The author generates a Copilot pull request summary. How does Copilot handle that file?

⬜ It leaves the file out of the summary.
⬜ It summarizes only the first 400 changed lines.
⬜ It writes separate summaries for the additions and the deletions.
⬜ It refuses to generate a summary for the whole pull request.

A developer owns a personal Copilot Space and wants to share it with a specific GitHub user who isn’t in the developer’s organization. Which approach is supported?

⬜ Invite that user through the Space’s sharing controls and choose a role for them.
⬜ Create an organization-owned Space, because only organizations can invite people.
⬜ Make the Space public, because personal Spaces can’t invite individual users.
⬜ Add the user to the organization, because personal Space invitations are limited to organization members.

A developer wants GitHub Copilot CLI to explain a shell command and then exit straight away. Which command-line option should accompany the request text?

⬜ --prompt
⬜ --interactive
⬜ --resume
⬜ --silent

With default VS Code shortcuts, a developer sees an unwanted Copilot inline suggestion (ghost text). Which action dismisses it without inserting code or turning off future suggestions?

⬜ Press Esc while the suggestion is showing.
⬜ Press Tab while the suggestion is showing.
⬜ Use the Accept Word action on the suggestion.
⬜ Turn off inline completions for the current language.

An organization is the only source of its members’ Copilot Business licenses and can manage its own feature policies. It wants to disable MCP in the Copilot experiences where MCP support is generally available, while keeping other Copilot features on. Which organization setting does this?

⬜ Under Copilot > Policies, set MCP servers in Copilot to Disabled.
⬜ Under Copilot > Policies, set Copilot can search the web to Disabled.
⬜ Under Copilot > Models, turn off the alternative Chat models.
⬜ Under Copilot > Policies, set Copilot cloud agent to Disabled.

Domain 3: Understand GitHub Copilot data and architecture (10–15%)

Which statements describe what content filtering does in Copilot Chat? (select three)

⬜ It checks generated code against the application’s functional requirements before showing it.
⬜ It can check the prompt before the model generates a response.
⬜ It can check the generated response before the developer sees it.
⬜ It helps catch harmful or offensive content, while code review remains the developer’s job.

For Copilot Business and Copilot Enterprise, what is GitHub’s default retention for prompts and suggestions from code completion and chat in the IDE?

⬜ They are kept for 28 days.
⬜ They are kept for two years.
⬜ They are kept until the user turns off telemetry.
⬜ They are not retained under the default policy.

How does GitHub Copilot find code that matches public repositories?

⬜ By comparing suggestions with any private repositories the developer can access
⬜ By comparing suggestions and surrounding code with an index of public GitHub repositories
⬜ By comparing suggestions with an index of repositories hosted outside GitHub
⬜ By scanning the live contents of public repositories for every suggestion

When Copilot builds a prompt for a code suggestion, what is the correct order of the inbound data flow?

⬜ IDE → proxy → toxicity filter → LLM
⬜ Proxy → IDE → LLM
⬜ IDE → toxicity filter → LLM → proxy
⬜ IDE → security scan → LLM → toxicity filter

Which privacy assurances apply to customer code and prompt data for Copilot Business and Copilot Enterprise? (select two)

⬜ Copilot keeps all prompt data for the lifetime of the subscription for auditing.
⬜ GitHub does not use Business or Enterprise customer data to train its models.
⬜ Copilot connects to GitHub’s servers over a secure HTTPS connection by default.
⬜ Prompt and suggestion data are kept for 12 months for AI training.

Which statements correctly describe GitHub Copilot’s privacy protections and what remains the developer’s responsibility? (select three)

⬜ Blocking suggestions that match public code strips sensitive values from prompts before they reach the model.
⬜ Opting out of model training also opts the account out of operational data retention.
⬜ GitHub doesn’t use Business or Enterprise customer data for model training without the customer’s authorization.
⬜ Copilot Pro subscribers can turn off the use of their data for AI model training in their Copilot settings.
⬜ Copilot’s content filters mean developers can rely on confidential data being removed from their prompts automatically.
⬜ Developers still need to check Copilot output for sensitive information before sharing or merging it.

A Copilot Enterprise user works with Copilot Chat on GitHub.com. Which statement correctly separates keeping the conversation from using it for model training?

⬜ Keeping the conversation for continuity also allows GitHub to use it for model training.
⬜ Blocking suggestions that match public code also stops GitHub from keeping the conversation.
⬜ GitHub can keep conversation data to provide the service without using it to train AI models.
⬜ The restriction on model training means GitHub must discard the conversation after each response.

How does Copilot Chat handle a user’s input before it generates a response?

⬜ It pre-processes the input, adds context such as open files and the repository name, and sends it to a large language model.
⬜ It accepts only natural-language questions and ignores code snippets so the model isn’t overloaded.
⬜ It analyzes the input and runs any code snippets to test their behavior before replying.
⬜ It sends the raw input straight to the model with no context or pre-processing, to avoid misunderstanding the user.

Which checks can be applied to Copilot inline suggestions before they reach the developer? (select two)

⬜ A check for matches with public code, depending on the configured matching policy
⬜ Running the repository’s test suite against each suggestion
⬜ A check for harmful content and potentially insecure code
⬜ Comparing each suggestion with every acceptance criterion in the issue tracker
⬜ Deploying the suggestion to a test environment to validate it

What information can GitHub Copilot use to gather context and build a prompt? (select four)

⬜ Earlier questions and responses in the conversation
⬜ Relevant files open in editor tabs
⬜ Code you’ve highlighted
⬜ Code in every GitHub repository in your organization
⬜ The code before and after your cursor

Which statement correctly describes where the AI models used by GitHub Copilot are hosted?

⬜ It depends on the selected model and the hosting arrangements GitHub uses with providers.
⬜ Each model is hosted directly by the company that built it.
⬜ The IDE extension downloads the selected model to the developer’s machine.
⬜ Every model runs in the same GitHub-owned Azure environment as the Copilot API.

Copilot offers two different inline implementations for the same comment. Which statements help a developer evaluate them? (select two)

⬜ Generative output can produce different suggestions for the same task.
⬜ Both suggestions should be checked against the same behavioral requirements.
⬜ The first suggestion’s position shows that it passed the project’s tests.
⬜ The shorter suggestion has already been chosen through runtime benchmarking.
⬜ The alternative suggestion changes the acceptance criteria set by the comment.

During a Copilot CLI session, an MCP tool fetches an issue’s current description. How does that tool result help the agent’s next response?

⬜ It gives the model task context it can use when generating the response.
⬜ It updates the model’s trained parameters with the issue’s current description.
⬜ It swaps the selected model for one trained by the issue-tracking service.
⬜ It proves that proposed code changes meet the issue’s acceptance criteria.

A developer asks where a repository validates customer requests, without knowing any function names. What does Copilot’s semantic repository index do to help answer that?

⬜ It helps find repository code that’s relevant to the meaning of the question.
⬜ It updates the model’s trained parameters to match the repository’s code.
⬜ It runs the repository’s validation functions to collect runtime results.
⬜ It certifies that the matching functions satisfy the application’s validation rules.

GitHub Copilot suggests a Python API that’s obsolete in the dependency version the project uses. Which statement correctly describes how Copilot produces suggestions in this situation?

⬜ Suggestions come from learned patterns and the available context, which can still lead to obsolete API usage.
⬜ An up-to-date repository index guarantees suggestions match the installed dependency versions.
⬜ Including current release notes in a prompt retrains the model before it generates suggestions.
⬜ Recent commits automatically fine-tune a separate model for each repository’s dependency versions.

A security engineer reviews the data commitments for a model offered in GitHub Copilot. The provider promises not to use prompts or outputs for model training. What does that promise tell you about data retention?

⬜ The provider may still keep data for purposes its retention terms allow.
⬜ The provider must delete prompts and outputs as soon as each response is returned.
⬜ If the provider kept a prompt, that would mean it’s using it to train the model.
⬜ The promise means there’s zero retention for every other model in Copilot too.

A Copilot Business organization uses VS Code with repositories hosted outside GitHub. Its policy for semantic indexing of non-GitHub repositories is set to Unconfigured. What has to happen before members can use that indexing?

⬜ An enterprise or organization owner must explicitly enable the policy.
⬜ A repository administrator must add the repository to a content exclusion rule.
⬜ Each developer must stage the workspace files so indexing turns on automatically.
⬜ Each developer must start a new chat conversation to override the policy.

A developer attaches many large files to a Copilot Chat request. Which statement correctly describes the model’s context window?

⬜ The prompt, instructions, conversation history, files and tool results all share a limited input capacity.
⬜ Each attached file gets its own full context window within the same request.
⬜ Repository indexing enlarges the context window to fit the whole repository.
⬜ Giving the editor more memory raises the remote model’s context-window limit.

Copilot shows an inline suggestion as proposed code that looks visibly different from the existing code. What is the role of this output-formatting stage?

⬜ To present the generated response so the developer can inspect and accept it.
⬜ To select the editor context that will be sent to the language model.
⬜ To check the proposed code against the repository’s full acceptance-test suite.
⬜ To decide whether the generated response contains harmful or insecure content.

A long Copilot Chat session in VS Code is compacted as its context window fills up. What does compaction do for later requests?

⬜ It summarizes earlier conversation history to make room for more context.
⬜ It increases the selected model’s maximum context-window size.
⬜ It stores the earlier discussion in the model’s weights instead of the prompt.
⬜ It deletes older source files from the workspace to shrink the request.

A Copilot inline completion closely matches an existing public implementation. Which explanation fits how the underlying model generates code?

⬜ Probabilistic generation can produce code that matches material in the training data.
⬜ The model returns a stored function picked by an exact match with the prompt.
⬜ The model runs candidate implementations and returns the fastest one that passes.
⬜ The model searches public repositories for each completion and copies the newest matching code.

Which statements correctly distinguish retrieval-augmented generation (RAG) from fine-tuning in an AI coding workflow such as Copilot? (select two)

⬜ Retrieval can add relevant repository information to a prompt without changing the model’s weights.
⬜ Fine-tuning adjusts the model’s weights, which is a different process from supplying retrieved context.
⬜ Retrieving a repository file updates the model’s weights with that file’s contents.
⬜ Retrieval only works if the repository’s code was part of the model’s original training data.
⬜ Fine-tuning requires the application to retrieve the original training examples for every response.

A privacy reviewer compares the rolling 90-day window in the Copilot activity report with GitHub’s default retention policy for Business and Enterprise data. Which conclusions are supported? (select two)

⬜ A missing last_activity_at value doesn’t prove the user has never used Copilot.
⬜ The report’s window doesn’t replace the separate two-year retention period for user engagement data.
⬜ The report’s window sets the deletion deadline for prompts from every Copilot access method.
⬜ A missing last_activity_at value shows that the user’s Copilot seat was canceled.
⬜ Feedback submitted with a Copilot response expires after the same 90-day window.

A team needs AI chat in an air-gapped VS Code environment (cut off from external networks). A compatible local model and client are already installed, and local BYOK (bring your own key) is allowed. Which setup avoids relying on GitHub’s Copilot API for model requests?

⬜ Configure local BYOK to use the model running inside the isolated environment.
⬜ Configure enterprise BYOK centrally and use its model through the Copilot API.
⬜ Configure local BYOK with a provider endpoint on the public internet.
⬜ Select a GitHub-hosted model after signing in, before the workstation is disconnected.

A Copilot inline suggestion calls an internal exportReport helper, but the context Copilot had didn’t include the helper’s implementation. A later review finds the helper exports restricted fields. Why can this risk get past suggestion filtering?

⬜ Filters can’t verify the safety of code whose implementation isn’t in the supplied context.
⬜ The defect proves that filtering was turned off when the helper call was suggested.
⬜ The helper’s descriptive name proves it applies the project’s field restrictions.
⬜ Accepting the suggestion changed which fields the helper was configured to export.

A Copilot Space uses a runbook stored on GitHub as context. The runbook changes often, and the team wants the Space to pick up those changes without repeated manual copying. Which approach does this?

⬜ Add the GitHub file as a source so that updates to it stay in sync.
⬜ Paste the runbook into the Space’s text content and rely on the original file to update that copy.
⬜ Upload a downloaded copy of the runbook and rely on later GitHub edits to replace the upload.
⬜ Put the runbook’s URL in the Space description and rely on it to supply up-to-date context.

A team is documenting the HTTPS connection Copilot uses between an IDE and GitHub. What protection does encrypting this connection provide?

⬜ It protects prompt and response content while it travels over that connection.
⬜ It deletes prompt and response content when the conversation ends.
⬜ It keeps prompt and response content out of AI model training.
⬜ It limits prompt and response processing to memory, with no disk storage.

Copilot confidently recommends a library function. The developer checks the installed package and its current official API reference and finds that the function doesn’t exist. Which limitation does this show?

⬜ A generated response can sound plausible while referring to an API that isn’t real.
⬜ A repository index can’t retrieve code until the repository is public.
⬜ A public-code matching filter turns private library functions into public API names.
⬜ A model-training setting decides which installed package versions an IDE can import.

In Copilot’s conceptual processing flow, what does the language model do with the prompt and supplied context to produce a response?

⬜ It uses patterns learned during training to predict the text of the response.
⬜ It searches the repository index and returns the top-ranked existing file unchanged.
⬜ It runs each proposed implementation and picks the one with the best test result.
⬜ It compares the prompt with public code and returns a list of license matches.

A repository has been indexed for Copilot Chat on GitHub.com. The team also uses Copilot Chat in VS Code and Copilot cloud agent with it. How can those experiences use the existing index?

⬜ Both VS Code Chat and cloud agent can use the repository index.
⬜ VS Code Chat can use the index, but cloud agent relies on text search instead.
⬜ Cloud agent can use the index, but VS Code Chat relies on open files instead.
⬜ Both need their own indexes, because the existing one only works for Chat on GitHub.com.

A VS Code workspace has a file matched by .gitignore, and no Copilot content exclusion applies to it. How can that file affect Copilot’s workspace context? (select two)

⬜ Ignored files are normally left out of workspace text search and semantic indexing.
⬜ An ignored file can still provide context when it’s open in the editor or its text is selected.
⬜ The ignore rule becomes an organization-wide Copilot policy for every licensed developer.
⬜ The ignore rule removes information about the file from the model’s training data.
⬜ The ignore rule stops the file from providing context even when its text is explicitly selected.

Two prompts have the same number of characters but use different words, punctuation and code identifiers. Why can they use different numbers of tokens with the same model?

⬜ Token boundaries depend on the text and the tokenizer, so a token can cover different amounts of text.
⬜ Every token holds a fixed number of characters, and extra tokens mean a network retransmission.
⬜ Every line of source code counts as one token, and punctuation changes the line count.
⬜ Every whole word is one token, and punctuation and partial words aren’t tokenized.

A Copilot Chat response in VS Code appears gradually as text becomes available. What does streaming mean here?

⬜ Delivering the response in fragments as they’re ready, instead of waiting for the full response.
⬜ Retraining the model step by step on each fragment shown in the conversation.
⬜ Searching a repository step by step while hiding the response until the search finishes.
⬜ Saving the full response to chat history before showing it as one message.

In the conceptual GitHub Copilot prompt-processing flow, the language model has produced a candidate response. Which stage applies output checks before the suggestion reaches the developer?

⬜ Post-processing and response validation
⬜ Prompt construction and context gathering
⬜ Inbound proxy filtering of the prompt
⬜ Code generation by the language model

Domain 4: Apply prompt engineering and context crafting (10–15%)

What is one way to get better results from Copilot Chat?

⬜ Avoid giving direct feedback on suggested code in the chat.
⬜ Give detailed context in your prompt about the kind of suggestion you want.
⬜ Use complicated queries that relate to your request.
⬜ Keep your input to one line so requests stay generic.

You want a function that converts temperatures between Celsius and Fahrenheit. You write only a comment describing what you need, with no examples, and Copilot generates the code from its training. What is this kind of prompting called?

⬜ Few-shot prompting
⬜ One-shot prompting
⬜ Chain-of-thought prompting
⬜ Zero-shot prompting

In VS Code Copilot Chat, a developer asks “How do I implement user authentication?” and then follows up with “What about password hashing?” without repeating any context. The second answer builds correctly on the first. Which Copilot Chat behavior makes this work?

⬜ The IDE saves every chat to local storage and uses it in future sessions.
⬜ The developer’s open files give Copilot enough context to understand the follow-up.
⬜ Copilot Chat searches the whole codebase to work out the context of follow-up questions.
⬜ Copilot Chat supports multi-turn conversations and uses the chat history as context for the current prompt.

A developer asks Copilot to generate a function that processes user input, but the suggestions are too generic because the prompt doesn’t say what the inputs or outputs are. Which change supplies the missing information?

⬜ Add comments above the code that describe the expected input and the desired result.
⬜ Shorten the function name.
⬜ Give the file a more descriptive name.
⬜ Turn Copilot off and on again to refresh the session.

What role do a user’s preferences play in GitHub Copilot’s suggestions?

⬜ They affect only the speed of suggestions.
⬜ They restrict suggestions to a single language.
⬜ They have no effect on suggestions.
⬜ They help tailor suggestions to the user’s coding style.

Which are the four S’s of prompt engineering with Copilot? (select four)

⬜ Standardization
⬜ Single
⬜ Saturate
⬜ Specific
⬜ Short
⬜ Surround

What is the main difference between one-shot and few-shot prompting with GitHub Copilot or other large language models?

⬜ One-shot prompting gives one example, while few-shot prompting gives several examples to guide the response.
⬜ One-shot prompting uses a complete dataset, while few-shot prompting uses a minimal one.
⬜ One-shot prompting is less secure than few-shot prompting because it reuses more tokens.
⬜ One-shot prompting needs Copilot Chat, while few-shot prompting works only in the code editor.

Which sources can provide context for Copilot inline code completions in an IDE? (select two)

⬜ The current file, such as the code around the cursor
⬜ Relevant code from files open in nearby editor tabs
⬜ The Copilot plan you’re subscribed to
⬜ The history of a separate, unrelated Copilot Chat session

A Copilot Chat conversation holds useful design decisions, but an earlier request still asks for XML even though the team has switched the requirement to JSON. What best keeps the useful context while fixing the outdated requirement?

⬜ Edit or remove the outdated request and state the JSON requirement explicitly.
⬜ Keep the XML request and ask for the same implementation in fewer words.
⬜ Change the response language and keep both conflicting format requirements.
⬜ Attach the project’s README without saying which format requirement changed.

A developer asks Copilot Chat in VS Code to compare retry behavior in two implementations that live in different files. Which actions make the comparison more precise? (select two)

⬜ Attach both implementation files as explicit context for the request.
⬜ Name the two functions and say which retry conditions to compare.
⬜ Attach a file from an older branch in place of the second current implementation.
⬜ Ask for a general explanation of retries without pointing to either implementation.
⬜ Select the first function and assume the second file is included because it exists locally.

Copilot keeps proposing calls from a public package while helping with a similarly named internal Python library. The prompt already names the internal library and describes the task. Which extra context would best correct its API usage?

⬜ The internal library’s import statement and a short documented example of the API the task needs.
⬜ The project’s full dependency list and an explanation of why the team chose the internal library.
⬜ The calling function’s type annotations and examples of data it receives from other components.
⬜ A working example from the similarly named public package, with instructions to adapt it to the internal library.

A local build fails during compilation right after a change to the compiler configuration. Tests and deployment haven’t run. Which context would best help Copilot Chat investigate? (select two)

⬜ The exact compiler error and the build command that produced it
⬜ The compiler configuration change and the relevant project configuration
⬜ A runtime exception from the last released version of the application
⬜ A failed test assertion recorded before the configuration change
⬜ A successful deployment log from the previous release

A Python game runs this code:

score = 5
print('Score: ' + score)

The print line raises TypeError: can only concatenate str (not "int") to str. The intended output is Score: 5, and score must stay numeric for later calculations. Which prompt gives Copilot the clearest debugging task? ⬜ Explain this TypeError and fix the code shown so it prints Score: 5 while keeping score numeric.
⬜ Explain this TypeError and change score to a string everywhere in the program so concatenation works.
⬜ Explain how Python prints strings and suggest a new display system that doesn’t use the failing statement.
⬜ Explain how to catch this TypeError and suppress the failing output so the program keeps running.

A Copilot Chat conversation covers both parseRequest and parseResponse. The developer wants input validation added to parseRequest but writes “Add validation to it,” and Copilot changes parseResponse. Which revision best removes the ambiguity?

⬜ Name parseRequest explicitly and say which input condition it should validate.
⬜ Attach both functions again without saying which one should change.
⬜ Ask for a longer explanation but keep the same vague reference to the function.
⬜ Switch the chat model but keep the same vague reference to the function.

A developer gives Copilot several input/output examples for a date formatter. Some outputs use YYYY-MM-DD and others use DD/MM/YYYY, but the required format is YYYY-MM-DD. What best improves these few-shot examples?

⬜ Make every example output use YYYY-MM-DD and state that it’s the required format.
⬜ Add more examples in both formats so Copilot can follow whichever appears more often.
⬜ Keep the examples as they are and ask Copilot for a shorter implementation.
⬜ Keep the examples as they are and ask Copilot to use a different programming language.

A developer gets an unhelpful Copilot Chat response in VS Code. They want to report the problem and also get a better answer in the same conversation. Which actions serve those two purposes? (select two)

⬜ Use the thumbs-down control on the response to mark it as unhelpful.
⬜ Send a follow-up that names the missing requirement and asks for a specific revision.
⬜ Treat negative feedback as a command that rewrites the response in the conversation straight away.
⬜ Switch to another model without describing the missing requirement.
⬜ Start a new conversation and send the same request again.

A developer wants to use few-shot prompting to help Copilot implement a custom text transformation whose behavior has already been agreed. Which additions provide useful worked examples of that behavior? (select two)

⬜ Several representative input strings, each paired with its approved output.
⬜ Reviewed unit tests that pair more inputs with their expected results.
⬜ A long list of input strings without the expected outputs.
⬜ Several implementations of unrelated formatting tasks from the same repository.
⬜ Repeated copies of the task description without any completed transformation.

A developer mentions a constraint in a Copilot Chat conversation but doesn’t add it to the source file. An inline completion in that file then differs from a follow-up Chat response. What best explains the difference?

⬜ The two requests can use different context, and only the Chat request includes the constraint from the conversation.
⬜ An inline completion and a Chat response must use an identical prompt because they’re in the same IDE.
⬜ The Chat conversation permanently changed the model that produces later inline completions.
⬜ Moving the request into Chat guarantees the constraint will be implemented correctly.

A developer exploring an unfamiliar VS Code workspace doesn’t know which files implement request validation. What can they add to a Copilot Chat prompt to explicitly ask for context from across the codebase?

⬜ Include #codebase with the question about request validation.
⬜ Include #fetch with the question about request validation.
⬜ Address @terminal with the question about request validation.
⬜ Address @vscode with the question about request validation.

A Python file still has a comment asking for account names to be sorted. The current requirement is to keep only active accounts without changing their order, but Copilot keeps suggesting a sort. Which change most directly fixes the conflicting guidance?

⬜ Update the comment to ask for filtering to active accounts while keeping their original order.
⬜ Repeat the sorting comment closer to the cursor to give it more weight.
⬜ Request another completion and leave the sorting comment as it is.
⬜ Rename the file but keep its existing comment and function body.

A Copilot prompt includes a detailed API contract needed for the task, plus several paragraphs about an unrelated team event. Which revision best improves the relevance of its context?

⬜ Keep the required contract details and remove the unrelated event narrative.
⬜ Replace the contract with just the API’s name and keep the event narrative.
⬜ Repeat the event narrative in the final sentence to highlight the available context.
⬜ Remove both sections to make the prompt as short as possible.

A developer finishes a database-debugging discussion in Copilot Chat and moves on to an unrelated task about a web page’s layout. Which workflow best avoids carrying irrelevant history into the new task?

⬜ Start a new chat and provide the layout task’s relevant files and requirements.
⬜ Continue the database discussion and repeat its earlier messages before describing the layout.
⬜ Switch the model in the same chat and rely on that to reset its history.
⬜ Rename the existing chat and rely on the new title to remove the database discussion.

A developer wants a single Python function that takes a list of labels and returns the non-empty labels in their original order. Which Copilot prompt describes the function most precisely?

⬜ Write a Python function that returns the non-empty labels from the given list, keeping their original order.
⬜ Write a Python function that returns the non-empty labels from the given list, sorted alphabetically.
⬜ Write Python code that processes a list of labels and arranges the results in any useful way.
⬜ Write a Python module that cleans labels, builds a search index and creates a command-line interface.

A developer asks Copilot Chat in VS Code about a utility module. Which control shows the source files Copilot lists as references for its answer?

⬜ Expand the Used references dropdown on the response.
⬜ Open the model picker used to choose the Chat model.
⬜ Open the tools picker used to enable tools for the conversation.
⬜ Open the agents dropdown used to choose Ask, Plan or Agent.

A Python team asks Copilot to refactor a loop that filters a list. The change must use a list comprehension and keep the filter condition and output order. Which comment describes the request clearly?

⬜ Replace this loop with a list comprehension that keeps the filter condition and output order.
⬜ Replace this loop with a generator expression that keeps the filter condition and output order.
⬜ Replace this loop with a dictionary comprehension that maps each kept value to its index.
⬜ Replace this loop with a set comprehension to remove duplicates, then sort the result.

A developer sends Copilot a zero-shot request for a custom identifier formatter. The output doesn’t follow the required conventions, which are hard to describe in words. Why might adding several representative input/output examples help the next request?

⬜ The examples demonstrate the required transformation patterns inside the prompt.
⬜ The examples update the model’s weights for future formatting requests.
⬜ The examples certify the generated formatter without running its tests.
⬜ The examples increase the model’s maximum context-window size.

One Copilot prompt asks for three related components: a parser, a validator that uses the parser’s output, and a report built from the validated data. Copilot keeps leaving out requirements. Which prompt changes would help manage these dependent tasks? (select two)

⬜ Ask for the parser first, then the validator, then the report, as separate focused steps.
⬜ Include the agreed output structure from each finished step in the next relevant prompt.
⬜ Put each subtask in a separate chat and leave the shared data structures unspecified.
⬜ Repeat the whole original request several times in one message without separating the steps.
⬜ Ask for the report first, then let later prompts change the data structure without updating the report.

In an ongoing Copilot Chat conversation, a generated export function produces the right columns in the right order but includes archived records. The developer wants archived records left out while keeping the existing design decisions. Which next step best adds the missing requirement?

⬜ Ask for a revision in the same conversation that excludes archived records and keeps the agreed columns and order.
⬜ Start a new conversation and ask for an exporter without restating the columns, order or archived-record rule.
⬜ Switch to another Chat model and repeat the original request without mentioning archived records.
⬜ Give the response a thumbs down and expect the rating to revise the function without a follow-up.

The VS Code prompt file review-migration.prompt.md is available and doesn’t set a custom name. Which methods can a developer use to run it? (select two)

⬜ Type /review-migration in Chat, optionally followed by task-specific details.
⬜ Open the prompt file and use the play button in its editor to run it in a chat session.
⬜ Copy its description field into .gitignore so VS Code runs it when a migration file opens.
⬜ Turn on Settings Sync for prompts so the file runs automatically after syncing.
⬜ Rename it to .github/copilot-instructions.md so it keeps /review-migration as its command.

Domain 5: Improve developer productivity with GitHub Copilot (10–15%)

A developer is using GitHub Copilot to migrate an application to a different programming language. What knowledge matters most for judging Copilot’s proposed translations?

⬜ Knowledge of the target language, using compiler results to check the translated behavior.
⬜ Knowledge of the source language, using generated explanations to validate unfamiliar target-language constructs.
⬜ Familiarity with the target framework, using its conventions to infer how the source application behaves.
⬜ A solid understanding of both the source and the target language.

You’re an experienced Python developer starting to learn Rust. What’s an effective way to use Copilot Chat to learn the basics?

⬜ Ask Copilot Chat to generate Python code and then translate it to Rust automatically.
⬜ Rely on Copilot’s autocomplete to rewrite all your Python scripts directly in Rust.
⬜ Ask Copilot Chat how to install Rust extensions in the IDE.
⬜ Ask Copilot Chat to explain how Rust differs from Python and which key language features to learn first.

You’re moving secrets from CyberArk to HashiCorp Vault and want Copilot Chat to draft a script for you to review, without running the migration. Which request best helps keep secrets out of files and logs?

⬜ Ask Copilot Chat to encrypt your environment variables during deployment on GitHub-hosted runners.
⬜ Ask Copilot Chat to fetch the credentials from CyberArk and inject them into Vault automatically.
⬜ Ask Copilot Chat to draft a migration script that never writes secret values to files or logs.
⬜ Ask Copilot Chat to start a secure CLI session that migrates the secrets between tools automatically.

A developer is building a prototype from a loosely defined user story with a few high-level requirements in plain language. The immediate goal is initial application code. How can Copilot help?

⬜ Copilot can help only after the requirements are converted into YAML.
⬜ Copilot can turn the requirements into an initial code structure, such as classes or functions.
⬜ Copilot automatically produces architecture diagrams from user stories.
⬜ Copilot can produce complete production code from user stories without developer input.

You’ve inherited a legacy Python codebase with unclear logic and need to modernize and refactor it. How can Copilot speed this up?

⬜ Copilot Chat can explain individual functions, suggest improvements and help rewrite outdated logic more cleanly.
⬜ Copilot can rewrite legacy code only after the whole project is converted to TypeScript.
⬜ Copilot’s suggested replacements for deprecated libraries don’t need a compatibility review.
⬜ Copilot can refactor and test an entire legacy project automatically and deliver completely bug-free results.

How does GitHub Copilot help developers who work in teams?

⬜ It supports collaborative coding and consistent practices.
⬜ It makes the code review process more complicated.
⬜ It enforces each individual’s own coding style.
⬜ It discourages feedback.

You’re building a REST API in Node.js and want to create boilerplate code and sample JSON responses for testing quickly. How can Copilot help?

⬜ Copilot can suggest complete test functions and sample data based on the surrounding code.
⬜ Copilot can generate test data only once the API is deployed and running in a test environment.
⬜ Copilot needs a separate plugin for each language before it can generate examples.
⬜ Copilot can only generate or comment on code; it can’t help with test data or boilerplate.

A developer finds that a fix proposed by Copilot still fails one of the project’s tests. What should they do next to help Copilot produce a better fix?

⬜ Update the Copilot extension and resend the original request with the same context.
⬜ Switch to another model and ask it to simplify the fix, without sharing the test failure.
⬜ Share the test failure and the expected behavior, ask for a revised fix, then run the tests again.
⬜ Ask for a second solution with the original prompt and pick the shorter implementation.

A developer needs to understand an unfamiliar function and add comments explaining what it does, without changing its implementation. How can Copilot Chat help?

⬜ Generate a pull request description summarizing recent changes to the function.
⬜ Explain the selected function, then draft documentation comments based on its current behavior.
⬜ Generate unit tests for the function, then summarize the behavior those tests cover.
⬜ Review the function for bugs, then suggest fixes for any issues found.

You’ve written a short JavaScript function that filters users above a certain age. You’re learning Go and want to see how the same logic works there. What’s the most effective way to learn with Copilot Chat?

⬜ Ask Copilot Chat to convert the JavaScript code to Go and explain each part of the translation.
⬜ Ask Copilot to run the JavaScript code and paste the output into a Go file to produce equivalent logic.
⬜ Ask Copilot Chat for only the Go version, with no explanation, and test it yourself later.
⬜ Ask Copilot Chat to rewrite the function in TypeScript first, because it’s closer to Go.

A repository has GitHub Secret Protection with push protection enabled, and the team also uses Copilot to examine code changes. Which statements correctly separate their roles? (select two)

⬜ Copilot can suggest changes to potentially insecure code for a developer to evaluate.
⬜ Push protection can block a push that contains a supported secret before it reaches the repository.
⬜ A Copilot review that finds no issues counts as a bypass approval for a blocked push.
⬜ A successful push-protection check confirms that Copilot’s proposed code has no vulnerabilities.
⬜ A Copilot content exclusion rule sets which secret patterns push protection detects.

A team wants Copilot to extend an existing unit and integration test suite using the same framework and fixtures. Which inputs best help it follow the project’s conventions and check the required behavior? (select two)

⬜ An existing test module that shows the framework, fixtures and assertion style
⬜ The expected behavior and the requirements for integration-test setup and cleanup
⬜ A request to pick a new framework before looking at the existing tests
⬜ A generated README summary used instead of the test framework’s configuration
⬜ A request to copy current return values into assertions without checking the contract

A team needs a README that tells another developer how to install, configure and run its application. Which request steers Copilot toward that documentation?

⬜ Use the setup files and configuration examples to draft installation and startup instructions.
⬜ Use the source files to draft an explanation of the internal algorithm in each function.
⬜ Use the recent commit history to draft release notes describing the latest changes.
⬜ Use the current tests to draft a report comparing unit-test coverage across modules.

A team asks Copilot to generate synthetic records for testing an import service. Which requirements make the data useful for validating the service? (select two)

⬜ Match the input schema and include the field combinations the service accepts.
⬜ Include labeled invalid and boundary cases with the expected validation results.
⬜ Copy production customer records so realistic values replace the synthetic examples.
⬜ Use the implementation’s current output as the expected result for every record.
⬜ Generate more ordinary records instead of specifying error cases.

A developer has staged changes for a commit and wants Copilot to draft the commit message in VS Code. Which action is meant for this?

⬜ Use Generate Commit Message in the Source Control view.
⬜ Use Explain from the Copilot actions for an editor selection.
⬜ Use Generate Tests from the Copilot actions for an editor selection.
⬜ Use the model picker in the Copilot Chat input.

When a program crashes, Copilot suggests a value is null, but the developer hasn’t inspected the running program. Which next step best tests that diagnosis?

⬜ Capture the value at the point of failure and compare it with Copilot’s proposed cause.
⬜ Ask Copilot to repeat the same diagnosis using more detailed terminology.
⬜ Use Copilot’s generated explanation as the expected result of the next test.
⬜ Accept a broader exception handler without checking which value caused the failure.

A legacy Bash script passes its regression tests. In response to a broad refactoring request, Copilot rewrites several processing stages at once, and the diff is hard to review. Which follow-up makes it easier to isolate a regression?

⬜ Ask Copilot to refactor one stage, then review its diff and run the regression tests before asking for the next stage.
⬜ Ask Copilot to finish the full rewrite, then use any failing regression tests to guide one combined repair.
⬜ Ask Copilot for several complete rewrites, then compare their regression-test results and pick one.
⬜ Ask Copilot to expand the regression suite, then repeat the request to refactor the whole script.

A private repository has GitHub Code Security with CodeQL analyzing pull requests, and Copilot code review is available. Which statements describe feedback from the two that complements each other? (select two)

⬜ CodeQL can report code scanning findings as pull request checks and annotations.
⬜ Copilot code review can comment on the diff and suggest changes for review.
⬜ Generating a Copilot pull request summary runs the repository’s CodeQL queries.
⬜ A clean Copilot review clears any outstanding CodeQL findings on the pull request.
⬜ A passing CodeQL check confirms that Copilot’s suggested changes meet the business requirements.

A JavaScript file repeats the same calculation in several functions. A developer wants Copilot to suggest a reusable implementation without changing any results. Which request in VS Code inline chat directly addresses this goal?

⬜ Refactor the selected code to share the calculation while preserving each function’s behavior.
⬜ Explain how each selected function currently performs the repeated calculation.
⬜ Generate unit tests that check the selected functions’ current results.
⬜ Add documentation comments describing the calculation in each selected function.

A developer needs to set up an environment for an unfamiliar programming language. The project specifies the required runtime version and dependencies. Which Copilot Chat requests support this setup? (select two)

⬜ Give the operating system and runtime version, then ask for installation and verification steps.
⬜ Attach the dependency manifest and ask how to install and manage the project’s packages.
⬜ Ask for setup commands based on the language’s latest release, without giving the project’s runtime version.
⬜ Ask Copilot to guess dependency versions from import statements instead of using the existing manifest.
⬜ Ask Copilot to reuse another operating system’s install commands because the runtime version matches.

A Python developer has to maintain an unfamiliar COBOL routine. Copilot’s first explanation uses terms the developer doesn’t understand. Which follow-up best uses what the developer already knows?

⬜ Ask Copilot to explain the COBOL routine with Python analogies and point out where those analogies differ from COBOL’s behavior.
⬜ Ask Copilot to repeat the COBOL terms in a shorter summary without comparisons.
⬜ Ask Copilot to rewrite the routine in Python before explaining the original behavior.
⬜ Ask Copilot for a project setup guide instead of an explanation of the routine.

A maintainer attaches a screenshot to Copilot Chat on GitHub.com and asks it to draft a bug report for a repository where they can create issues. The draft includes reproduction steps that haven’t been verified. What should the maintainer do before submitting the issue?

⬜ Review and correct the draft’s fields, using follow-up prompts if needed, then click Create.
⬜ Click Create, because image analysis proves the proposed reproduction steps are accurate.
⬜ Turn on automatic code review to certify the reproduction steps before clicking Create.
⬜ Check the title and labels, then submit the generated reproduction steps unchanged for triage.

A function must return zero for an empty list. Copilot generates two tests for this input: one expects zero and the other expects an exception. The first test fails because the implementation isn’t finished. Which actions are appropriate? (select two)

⬜ Keep the test that expects zero and ask Copilot to implement the missing behavior.
⬜ Ask Copilot to revise the exception test, because its expectation contradicts the contract.
⬜ Ask Copilot to change the zero test’s expected result to whatever the unfinished function returns now.
⬜ Keep the exception test, because a generated exception test overrides the written contract.
⬜ Ask Copilot to discard both tests until the function is fully implemented.

A frontend developer has an agreed API response schema, but the API isn’t deployed yet. Copilot suggests fetching live responses to build UI fixtures. Which follow-up lets frontend work continue while the API is unavailable?

⬜ Ask Copilot to generate local test data that matches the supplied schema, without calling the API.
⬜ Ask Copilot to retry the live request with a different model instead of using the schema.
⬜ Ask Copilot to replace the agreed schema with fields inferred from the screen labels.
⬜ Ask Copilot to use a public API’s responses as fixtures, even though their schema is different.

A team is preparing to modernize a working application whose dependencies and behavior are poorly documented. Which Copilot requests help establish a baseline before any code changes? (select two)

⬜ Ask Copilot to trace data flow between the supplied source files and explain how they relate.
⬜ Ask Copilot to draft a test plan for the existing behavior, then validate it with maintainers who know the system.
⬜ Ask Copilot to generate expected test results from the future rewrite instead of the current requirements.
⬜ Ask Copilot to optimize several modules straight away and document the original interactions afterwards.
⬜ Ask Copilot to use a dependency diagram as proof that the modernized application passes its tests.

Copilot generates tests for a service that writes to a database and calls a payment API, and the draft mocks both. Which assessments correctly describe how to use and extend these tests? (select two)

⬜ The mocks can help check the application’s database and payment API calls, including its error handling.
⬜ More tests that use the real database mapping are needed to confirm it works correctly.
⬜ Passing the mocked payment tests proves the deployed API credentials are valid.
⬜ Generating more mocked database responses proves the real schema migration succeeds.
⬜ Copilot-generated tests can skip review because mocks remove uncertainty about external dependencies.

A team is using Copilot Chat to migrate a PHP application to Python with Flask. One translated component fails a test, and another component’s behavior is unclear. Which actions use Copilot to investigate these problems before the migration continues? (select two)

⬜ Give Copilot Chat the test failure and the relevant code, then review and test the fix it proposes.
⬜ Select the unfamiliar original code and ask Copilot to explain its behavior before translating it.
⬜ Use Copilot’s high-level migration overview to confirm the translated component behaves like the original.
⬜ Ask Copilot to translate the next component and leave the investigation until both are converted.
⬜ Ask Copilot for a framework recommendation and treat the chosen framework as the fix for the failing test.

A profiler shows a service spends most of its time serializing responses. A broad Copilot Chat request instead produces suggestions about an unrelated loop. Which follow-up best focuses Copilot on the measured bottleneck?

⬜ Attach the serialization code and profiling results, then ask for optimizations that keep the serialized output the same.
⬜ Attach the unrelated loop again and ask for a shorter implementation with fewer lines.
⬜ Ask for general performance advice for the service’s language and framework.
⬜ Ask for a comparison of the serialization code and the loop based only on their line counts.

A developer uses Copilot Chat in VS Code to update a function’s reference documentation after its parameters and error behavior changed. The implementation is correct. Which requests directly produce the documentation updates? (select two)

⬜ Draft updated parameter, return-value and error descriptions from the current implementation.
⬜ Update the documented usage examples to match the function’s current signature and behavior.
⬜ Generate more unit tests for the function’s success and failure paths.
⬜ Suggest a new internal structure that splits the function into smaller helpers.
⬜ Summarize the project’s issue discussion about the next release date.

A Python developer is learning Rust with Copilot Chat. They want to understand short Rust examples and learn why errors happen in their own code. Which workflows directly support those goals? (select two)

⬜ Ask for a Rust version of a small, familiar function plus an explanation of the unfamiliar constructs.
⬜ Share a compiler error from their own code and ask Copilot to explain the cause and the fix.
⬜ Generate a complete application and judge learning by whether it starts.
⬜ Ask for replacement code for every error and move on without looking at why it changed.
⬜ Ask for formatting changes to the examples and treat consistent indentation as proof of understanding.

A Flask application reports TemplateNotFound when rendering a page. A developer wants Copilot Chat to check whether the template path matches the app’s configuration. Which context best supports that?

⬜ The exact error, the relevant rendering and configuration code, and the project’s template folder structure.
⬜ The page’s intended colors, font sizes and layout, along with its stylesheet.
⬜ The app’s average response times and memory use from a successful load test.
⬜ Code from an earlier version in another language, without the current file layout.

A Python function both cleans input records and builds a DataFrame from them. The developer wants each operation to be reusable on its own. With the function selected in VS Code, which inline chat request best states the refactoring goal?

⬜ Split this into one function that cleans the records and another that builds the DataFrame, keeping the existing behavior.
⬜ Rename this function and its local variables to clarify both jobs, keeping its current structure.
⬜ Move this function into a shared module, keeping cleaning and DataFrame creation in one function.
⬜ Add a docstring that explains both jobs, keeping the existing implementation.

A test passes locally but fails now and then in GitHub Actions. Copilot CLI has access to the repository and the required GitHub MCP tools. Which requests most directly help investigate and fix the failure? (select two)

⬜ Fetch the relevant passing and failing job logs and compare the evidence around the failing test.
⬜ Inspect the related local code and test, propose a fix for the observed failure, and list validation steps.
⬜ Rerun the failed job until it passes and use that run to explain the original failure.
⬜ Remove the failing assertion so the job finishes without checking the behavior.
⬜ Summarize the README and use its setup overview as the diagnosis.

A team has a working test command and wants Copilot’s help adding it to GitHub Actions. They need a draft workflow plus an explanation of its triggers and permissions. Which requests meet these needs? (select two)

⬜ Draft a workflow that installs the project’s dependencies and runs the supplied test command.
⬜ Explain when the draft workflow runs and why each configured permission is needed.
⬜ Draft a pull request summary of the application changes, without any workflow configuration.
⬜ Format the test source files to match the team’s indentation and naming conventions.
⬜ Generate a commit message for the application changes without looking at the workflow draft.

A developer gives Copilot versioned API contracts and working examples for two external services. The task is to draft adapter code and tests that handle timeouts and malformed responses. Which requests directly move that task forward? (select two)

⬜ Generate adapter functions from the supplied API contracts, keeping service calls separate from business logic.
⬜ Generate tests that simulate timeouts and malformed responses and check the specified error behavior.
⬜ Generate adapters from remembered endpoint conventions, ignoring the supplied versioned contracts.
⬜ Generate tests with successful responses only and treat them as proof that failure handling works.
⬜ Generate a release-note summary of the services without any adapter code or tests.

Domain 6: Configure privacy, content exclusions, and safeguards (10–15%)

A developer uses GitHub Copilot to generate unit tests. Which actions directly add or request tests for missing edge cases and boundary conditions? (select two)

⬜ Review the generated test inputs and assertions, then add tests for any missing boundary conditions.
⬜ Rely on Copilot’s inline completions to optimize the performance of existing tests automatically.
⬜ Write explicit comments describing the edge cases and ask Copilot to generate tests for them.
⬜ Use /explain in Copilot Chat to summarize what the function does, without asking for tests.

A security team wants to keep proprietary files out of Copilot inline completions in VS Code for an organization on Copilot Business. What should it configure?

⬜ Security scanning
⬜ Content exclusion rules
⬜ The code-matching filter
⬜ A different model for inline suggestions

Which setting controls whether Copilot inline suggestions are turned on for specific programming languages in VS Code?

⬜ github.copilot.enable
⬜ editor.inlineSuggest.enabled
⬜ github.copilot.nextEditSuggestions.enabled
⬜ editor.formatOnSave

An organization wants to stop inline code suggestions that match public code on GitHub from appearing. Which organization-level Copilot policy should an administrator set?

⬜ Set Suggestions matching public code to Block in the organization’s Copilot policies.
⬜ Turn on the toxicity filter in the proxy service used for inbound prompts.
⬜ Send Copilot traffic through a private HTTP proxy so public-code matches are eliminated.
⬜ Use only a Claude model so that no matching public code is suggested.

Which mechanism does GitHub document for blocking insecure code patterns, such as hardcoded credentials or SQL injection, in Copilot’s generated suggestions?

⬜ Secret scanning validity checks with the credential provider
⬜ Copilot’s content filtering system, which detects and blocks insecure code in generated suggestions
⬜ Secret scanning push protection for changes pushed to a repository
⬜ CodeQL queries run against a database that represents the codebase

In GitHub secret scanning, what is the Generic category of alerts for?

⬜ Listing deprecated API tokens found in the codebase
⬜ Showing secrets found by generic patterns, such as private keys, and secrets found by AI, such as passwords
⬜ Grouping false-positive matches for partner and custom patterns
⬜ Highlighting secrets from public repositories only

An organization owner wants to set up content exclusions for Copilot inline completions in VS Code. Where are the excluded paths defined?

⬜ In the organization’s Copilot content exclusion settings
⬜ In a .gitignore file at the repository root
⬜ In the repository’s .github/copilot-instructions.md file
⬜ In the workspace’s .vscode/settings.json file

An organization excludes a source file with a Copilot content exclusion policy. Which effects apply to supported inline completions and to Copilot code review on GitHub.com? (select two)

⬜ Copilot doesn’t offer inline suggestions inside the excluded file.
⬜ Copilot code review leaves the excluded file out of its review.
⬜ GitHub removes the file from the repository’s commit history.
⬜ The policy removes repository read access from licensed developers.
⬜ The policy makes secret scanning search the excluded file.

An enterprise has several organizations that assign Copilot Business seats. Which statements correctly describe the scope of their content exclusion policies? (select two)

⬜ Rules set at the enterprise level apply to Copilot users across the enterprise.
⬜ Rules set at the organization level apply to users who get their seat from that organization.
⬜ A repository administrator can edit inherited organization rules from the repository page.
⬜ A language-specific completion setting in the IDE changes the enterprise’s exclusion rules.
⬜ A local .gitignore entry publishes an exclusion rule to the organization’s Copilot settings.

A team uses GitHub Copilot to generate code and wants to reduce the risk of exposing credentials. Which statements correctly describe the safeguards available and their limits? (select two)

⬜ AI-based generic secret detection is set up separately and doesn’t need a GitHub Copilot subscription.
⬜ Generated code still has to be reviewed for hardcoded credentials before it’s committed.
⬜ Blocking suggestions that match public code also catches credentials in suggestions that don’t match public code.
⬜ Content exclusions inspect generated suggestions for credentials, whichever files supplied the context.
⬜ Saving a credential as a GitHub Actions secret removes matching hardcoded values from repository files.

An administrator has just changed a Copilot content exclusion policy. A developer wants VS Code to pick up the change right away instead of waiting for it to propagate. Which action is documented for this?

⬜ Run Developer: Reload Window from the Command Palette.
⬜ Run Format Document on the file that should be excluded.
⬜ Start a new Copilot Chat conversation in the same window.
⬜ Stage the excluded file’s current changes in Source Control.

A Copilot CLI session is started with copilot --allow-all-tools --deny-tool='shell(git push)'. What effect does the explicit deny rule have on the shell’s git push command?

⬜ It blocks that command even though the session allows tools broadly.
⬜ It allows that command because the broad allow setting takes priority.
⬜ It turns that command into a preview and pushes after showing the diff.
⬜ It asks for approval for that command while keeping it available to run.

An organization wants a teammate to ask questions in a Copilot Space and update its instructions, but not change its sharing settings or delete it. Which Space role fits?

⬜ Editor
⬜ Viewer
⬜ Admin
⬜ No access

An organization on GitHub Enterprise Cloud assigns a developer a Copilot Business seat and blocks suggestions that match public code. What happens when Copilot detects a public-code match in an inline completion in a supported IDE?

⬜ The matching suggestion is suppressed under the organization’s policy.
⬜ The suggestion appears if the matching repository has a permissive license.
⬜ The developer can allow the suggestion through their personal account settings.
⬜ The suggestion appears with a reference to the matching public repository.

A developer sets up local BYOK (bring your own key) in VS Code with a remotely hosted model provider, and the API key is stored on the workstation. Which statement correctly describes the privacy implications for prompts sent to that model?

⬜ The remote provider receives the prompts, even though the key is stored locally.
⬜ The prompts stay on the workstation because the configuration uses local BYOK.
⬜ The provider receives the key, while VS Code generates the model’s responses locally.
⬜ The provider’s data policies stop applying once its model is selected through Copilot.

A Copilot Business administrator is checking policy support before a team changes its workflow. Which workflows are documented exceptions to content exclusion support? (select two)

⬜ Copilot Chat in VS Code in Edit mode
⬜ Copilot Chat in VS Code in Agent mode
⬜ Copilot Chat in VS Code in Ask mode
⬜ Copilot code review on the GitHub website
⬜ Copilot inline suggestions in VS Code

An organization uses Copilot Business. Which configurations let an authorized administrator exclude a file using Copilot’s content exclusion policy? (select two)

⬜ Add the file’s path to the path list in the repository’s Copilot Content exclusion settings.
⬜ Add the repository reference and the file’s path in the organization’s Copilot Content exclusion settings.
⬜ Add the file’s path to the repository’s .gitignore file and commit the rule.
⬜ Add a request to avoid the file in .github/copilot-instructions.md.
⬜ Set the file’s language to false in github.copilot.enable in the developer’s VS Code settings.

A company builds an application using Copilot bought directly from GitHub under a volume licensing agreement. Which statements match the GitHub Generative AI Services Terms (March 2026)? (select two)

⬜ GitHub doesn’t claim ownership of the inputs given to the service or the outputs it generates.
⬜ The company remains responsible for meeting the requirements that apply to the application it builds.
⬜ The company gets exclusive ownership of matching code that a third party already holds.
⬜ GitHub takes on the application’s licensing obligations when Copilot supplies its code.
⬜ The same terms module governs Copilot purchased through a Microsoft agreement.

An organization has set up content exclusions for employees with Copilot Business licenses. A developer starts using Copilot CLI. Which statement correctly describes the CLI’s support for these policies?

⬜ The CLI respects the applicable content exclusion policies under the Business license.
⬜ The CLI needs an Enterprise license before it can respect content exclusion policies.
⬜ The CLI follows IDE Agent mode’s exclusion limitations because both can carry out agent tasks.
⬜ The CLI applies content exclusions to suggestions but allows excluded content in chat.

In VS Code, the Copilot code-reference log lists a matching public file and reports its license as NOASSERTION. Which conclusions does this entry support? (select two)

⬜ Copilot found a public-code match but didn’t identify a license for it.
⬜ The file URL is a starting point for investigating the match through the team’s licensing process.
⬜ The matching code can be used as public-domain material.
⬜ The matching file’s license was found and prohibits use of the suggestion.
⬜ The matching code has passed the repository’s security and quality checks.

A Copilot Business exclusion rule has loaded in VS Code. Inline suggestions have stopped in the excluded file, but a suggestion in another file uses type information from the excluded file. Which documented limitation explains this?

⬜ The IDE can supply semantic information from an excluded file indirectly.
⬜ Opening another file temporarily suspends the repository’s exclusion policy.
⬜ Repository exclusions stop suggestions but allow the excluded file’s contents to be reused directly.
⬜ Exclusion rules apply to chat responses but not to inline completions.

VS Code loaded a repository’s Copilot content exclusion settings earlier in the day. An administrator has just saved a valid new exclusion, but inline suggestions still appear in the affected file. The environment supports exclusions. What documented behavior explains the delay?

⬜ An IDE that already loaded the previous settings can take up to 30 minutes to receive the change.
⬜ A repository exclusion takes effect only after the repository changes from private to public.
⬜ A repository exclusion takes effect only after every developer is given the Admin role.
⬜ An IDE receives repository exclusions when a new Copilot billing period starts.

Copilot cloud agent reports that its firewall blocked a download from an approved vendor URL, requested by a Bash command. The agent runs in GitHub’s hosted environment, and the repository’s custom allowlist can be changed. Which change allows the download while keeping the firewall on?

⬜ Add the URL to the cloud agent’s custom allowlist under Copilot > Internet access.
⬜ Add the URL to code review’s custom allowlist under Copilot > Internet access.
⬜ Turn off the cloud agent’s firewall but keep its recommended allowlist enabled.
⬜ Grant permission to download from the URL in .github/copilot-instructions.md.

A developer has the Maintain role on a repository in an organization with Copilot Business. They can view the repository’s content exclusions but have no other admin role. Which repository role allows editing the repository’s own exclusion rules?

⬜ Admin
⬜ Write
⬜ Triage
⬜ Read

A developer accepts a Copilot inline suggestion in VS Code, edits it and adds handwritten code. Suggestions matching public code are allowed. A reviewer proposes using the code-reference log as a complete licensing check for the finished file. Which conclusions are supported? (select two)

⬜ A reference logged when a suggestion was accepted doesn’t cover later edits to it.
⬜ Handwritten additions need their own review, because code referencing doesn’t check them.
⬜ An empty reference log proves the finished file has no public-code matches.
⬜ Switching the public-code policy to Block checks the finished file for matches after the fact.
⬜ A license recorded for one suggestion covers the handwritten code in the same file.

A Copilot Business content exclusion has loaded in VS Code and matches an ordinary local source file. The developer is using supported inline suggestions. Which effects apply directly to the excluded file? (select two)

⬜ Copilot stops offering inline completions while the developer edits that file.
⬜ The file’s content is left out of the direct context for inline suggestions in other files.
⬜ The IDE also withholds type information indirectly derived from symbols in that file.
⬜ Switching to Agent mode in VS Code Chat keeps the same content exclusion enforcement.
⬜ The exclusion also removes the affected code from the repository’s commit history.

A repository administrator sees an inherited organization-level rule for .env files in the repository’s Copilot Content exclusion settings. An approved change is needed to that rule. How is the inherited rule updated?

⬜ An organization owner edits the rule in the organization’s Copilot Content exclusion settings.
⬜ The repository administrator edits the inherited rule in the repository’s Content exclusion settings.
⬜ A developer updates the repository’s .gitignore patterns and reloads the editor.
⬜ A developer changes the file-handling guidance in .github/copilot-instructions.md.

An organization provides a developer’s Copilot Business seat. Inline suggestions work in VS Code, but the organization’s Copilot policies have Chat turned off. No enterprise policy overrides this, so an organization owner can change it. Which action turns on Copilot Chat?

⬜ The organization owner enables Chat in the organization’s Copilot policy settings.
⬜ The developer changes the setting for suggestions that match public code.
⬜ The developer opens more project files to give Copilot more context.
⬜ The developer reinstalls the Copilot extension while the policy stays disabled.