GH-300 domain - 18% of the exam

Use GitHub Copilot responsibly

Use GitHub Copilot responsibly is 18% of the GH-300 exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

50
Practice questions
3
Objectives
17
Easy
33
Medium

Where people go wrong

  • Treating built-in filters as a security check

    The wrong answers hand the job of catching insecure code to a Copilot control: the proxy filters, content exclusions, or duplication detection. Each control has a narrower scope. The proxy screens content, duplication detection blocks suggestions that match public code, and content exclusions only stop named files being used as context. None of them judges whether code is secure, so a person checking the code and security scanning still apply.

    See it in a sample question
  • Expecting a higher plan to validate the output

    The wrong answers offer a move to Copilot Enterprise, or a change of plan tier, as the fix for unchecked output. A plan adds organisation features, policies and administration. It does not scan each suggestion for vulnerabilities, supply a live feed of recent facts, or grant a licence for third-party snippets. Accountability for correctness, security and licensing stays with the developer on every plan.

    See it in a sample question
  • Reading a confident answer as an accurate one

    The wrong answers take fluent, specific output as evidence that it is right: a quoted figure, a configuration flag, or a Chat review that finds no issues. Copilot predicts likely-sounding text, so a confident tone says nothing about truth. Agreement between two model answers is not independent verification either. Specifics need checking against authoritative documentation, and Chat's review of sensitive code is one input beside a developer's own check and security checks.

    See it in a sample question
  • Moving accountability to the vendor or the administrator

    The wrong answers place responsibility for accepted code on someone other than the developer who commits it: the provider that trains the model, GitHub once the public-code filter is on, or the administrator who configured that policy. Copilot is an assistant, and the filter reduces matches without clearing a licence. Committing code is a deliberate human act, so the author remains accountable for its correctness, security and licensing.

    See it in a sample question

Objectives in this domain

Sample questions from this domain

Free sampleUse GitHub Copilot responsiblymedium

A developer accepts a Copilot suggestion that builds a SQL query by concatenating user input directly into the statement. Which statement best describes the responsible way to handle the risk that Copilot can produce insecure code?

  • ACopilot guarantees the suggestion is safe because its proxy filters block insecure patterns, so the developer can merge the concatenated query without further checks.
  • BEnabling content exclusions on the repository will rewrite the unsafe query into a parameterised statement automatically before the suggestion is ever shown.
  • CSwitching the request to Copilot Chat instead of inline completions removes the vulnerability, because Chat validates all generated code against security benchmarks.
  • DSuggestions can contain vulnerabilities such as injection flaws, so the developer remains accountable for reviewing the code and running security tooling before merging it. Correct
Understand that Copilot can emit insecure code and the developer must review and scan output before merging it. Copilot suggestions reflect patterns in training data and can include vulnerabilities such as SQL injection; no built-in filter certifies security, so responsible use means the developer reviews the code and applies security tooling before the change is merged.

Why A is wrong: The proxy filters target things like matching public code, not every vulnerability, so trusting it to certify security lets an injection-prone query through unchecked.

Why B is wrong: Content exclusions only stop named files being used as context and never rewrite suggestions, so they cannot turn an unsafe query into a parameterised one.

Why C is wrong: Chat is a different surface, not a security gate, and it does not certify code against benchmarks, so the injection risk would persist regardless of the surface used.

Why D is correct: Copilot can reproduce insecure patterns, and responsible use keeps the developer accountable for review and security scanning, which would catch the unsafe concatenation here.

Free sampleUse GitHub Copilot responsiblymedium

A developer asks GitHub Copilot Chat to summarise a recent regulatory change affecting their payment flow, and Chat returns a confident, specific answer citing a clause and an effective date. The change happened after the model's training data was collected. What is the responsible way to treat this answer?

  • AAccept the answer because Chat grounds responses in the open files and repository context, which keeps regulatory facts current and trustworthy.
  • BAccept the answer if the team is on Copilot Enterprise, since the enterprise tier connects Chat to live regulatory feeds that keep such facts up to date.
  • CAccept the answer because the proxy post-processes responses and would have filtered out a clause or date that was factually incorrect.
  • DTreat the clause and date as unverified, because the model can state recent facts fluently yet wrongly, and confirm them against the authoritative regulatory source before acting. Correct
Treat confident Copilot answers about post-cut-off external facts as unverified and confirm them against authoritative sources before acting. Large language models generate fluent answers even for events after their training cut-off, with no guarantee of accuracy. Recent external facts such as regulatory clauses must be verified against the authoritative source, because no Copilot plan, grounding, or filter validates them.

Why A is wrong: Repository grounding is real but applies to code context, not external regulatory facts, so it does not make the cited clause or date reliable.

Why B is wrong: This is tempting because Enterprise adds capabilities, but no plan gives Chat a live regulatory feed, so the tier does not make recent external facts trustworthy.

Why C is wrong: The proxy screens for unsafe content, not factual accuracy, so it cannot validate a regulatory clause or effective date.

Why D is correct: Models present plausible answers about events after their cut-off without genuine knowledge, so the fluent specifics must be verified against the authoritative source before they are relied upon.

Free sampleUse GitHub Copilot responsiblyeasy

A developer asks GitHub Copilot Chat for the current version of a library and the precise rate limit of an external API, then plans to quote those numbers in a status report. What is the responsible way to treat those specific figures?

  • AVerify the figures against the official documentation first, because the model can produce plausible but outdated or fabricated specifics that need confirming. Correct
  • BQuote the figures directly in the report, because Copilot Chat retrieves live values from the library registry and the API provider on each request.
  • CTreat the figures as authoritative once Copilot states them confidently, since a confident answer indicates the model has verified the values it returns.
  • DDiscard the figures entirely and omit any numbers, because a generative model is never able to surface a factual specific that turns out to be accurate.
Verify factual specifics from Copilot against authoritative sources because generative models can produce plausible but inaccurate details. A language model predicts likely text rather than guaranteeing live, accurate facts, so version numbers and rate limits it states can be outdated or fabricated, which is why responsible use means confirming such specifics against official documentation before relying on them.

Why A is correct: Models can hallucinate plausible but wrong specifics, so confirming version numbers and limits against authoritative sources is the responsible step before quoting them.

Why B is wrong: Copilot Chat does not guarantee live lookups for such facts, so quoting the figures as authoritative without checking risks repeating an outdated or invented value.

Why C is wrong: Confidence is not verification, since the model can state a fabricated number just as fluently, so confidence alone is no basis for trusting the figures.

Why D is wrong: Refusing all figures overcorrects, since the responsible action is to verify the specifics rather than assume every generated number is wrong.

Free sampleUse GitHub Copilot responsiblymedium

A developer accepts a long GitHub Copilot suggestion in an organisation that has the policy blocking suggestions matching public code switched on, yet the snippet still resembles a copyleft project the developer recognises. Operating responsibly, who carries the duty to confirm the licence position before the code ships?

  • AThe developer who accepts and commits the suggestion, because the public-code filter reduces but cannot eliminate matches, and the accountable author must confirm the licence position. Correct
  • BGitHub, because once the public-code filter is enabled the platform assumes the licensing responsibility for any suggestion that the filter still allowed through to the developer.
  • CThe organisation administrator who enabled the policy, since turning on the public-code filter makes that administrator the accountable party for the licence of every accepted suggestion.
  • DNo one needs to act, because a snippet that the public-code filter permitted to appear has by definition been cleared of any copyleft licensing concern before it reached the editor.
Understand that the public-code filter reduces but does not remove matches, so the committing developer stays accountable for licence checks. The policy that blocks suggestions matching public code lowers but cannot eliminate the chance of a resembling snippet, so the developer who accepts and commits the code remains the accountable author who must confirm its licence rather than assuming the filter or an administrator did so.

Why A is correct: The public-code filter lowers the chance of a match but does not guarantee none, so the developer who commits the code remains accountable for confirming its licence.

Why B is wrong: Enabling the filter does not transfer licensing responsibility to GitHub, so assuming the platform now owns the licence position leaves a real copyleft obligation unaddressed.

Why C is wrong: Configuring a policy is an operational control, not authorship, so accountability for the licence of accepted code does not shift onto the administrator who enabled the filter.

Why D is wrong: The filter does not clear licence concerns and can still let resembling code through, so treating its silence as a licence clearance is unsafe and misunderstands the control.

Other domains in this exam

See also the GH-300 cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by GitHub. Original, blueprint-aligned practice material only.