Understand GitHub Copilot data and architecture — GH-300 Practice Quiz

Question 1

A developer at a company using GitHub Copilot Business asks Copilot Chat a question in the IDE: 'Why is this function throwing a null reference?' while a file is open in the editor. The developer wants to understand what data actually leaves their machine to answer this. Which description best reflects how Copilot builds and transmits the prompt for this chat request?

Accepted Answer

Copilot assembles a prompt from the user's question plus relevant context (such as the open file and selected code), sends it over an encrypted connection to the model service, and returns a generated response without retaining the prompt for training under Business terms.

Answer

Copilot uploads the entire repository to GitHub's servers so the model can index all files before generating any chat response.

Answer

Copilot runs the language model entirely on the local machine, so no prompt data ever leaves the developer's device.

Answer

Copilot sends only the raw question text with no surrounding code context, because chat requests never include editor content.

Question 2

A developer notices that GitHub Copilot's inline completions in a very large file become slower and sometimes less relevant when they have dozens of unrelated tabs open. A teammate suggests that closing irrelevant tabs and keeping the cursor near related code helps. From an architecture standpoint, what best explains why the amount of context gathered on the client before a request is sent is deliberately bounded rather than including everything available?

Accepted Answer

The underlying LLM has a finite context window, so the client must select and prioritize a limited slice of surrounding code, open tabs, and cursor context to fit the prompt within model token limits.

Answer

The client uploads the entire repository to the proxy on each keystroke, so limiting context only reduces network bandwidth, not model behavior.

Answer

Copilot permanently stores all open-file context as training data, so bounding it exists solely to reduce the size of the training corpus.

Answer

The model retains memory of every prior file the developer edited during the session, so additional context is redundant and discarded at random.

Question 3

A backend team upgrades to a major new version of a popular web framework that was released two weeks ago. As they write new endpoints, GitHub Copilot repeatedly suggests method signatures and configuration patterns from the previous major version, even though the code compiles against the new one. What is the most accurate explanation of why this happens?

Accepted Answer

The underlying model was trained on data up to a fixed cutoff and has no inherent knowledge of a framework release that occurred after that point, so it reproduces patterns from versions it did see.

Answer

Copilot's proxy applies a duplicate-detection filter that strips out any code matching the newly released framework, forcing it to fall back on older patterns.

Answer

The organization's content exclusion settings are blocking the new framework's files from being sent as prompt context.

Answer

Copilot telemetry retention rules cause suggestions to expire after two weeks, reverting the model to its default behavior.

Question 4

A developer at a fintech company notices that when they ask GitHub Copilot's code completion to generate a function similar to one they wrote in a file they edited an hour ago (now closed), Copilot does not seem to 'remember' that earlier code and produces a structurally different result. They ask you why Copilot cannot recall their previous work session. Which explanation best describes this limitation of how Copilot completions work?

Accepted Answer

Copilot completions are stateless: each suggestion is generated from a prompt assembled at request time from currently available context, and the model retains no memory of prior sessions or closed files.

Answer

Copilot stores all prior prompts in a per-user vector database, but fintech content-exclusion rules automatically purge them after one hour.

Answer

Copilot fine-tunes a personalized model from your edits, but the retraining only occurs overnight, so earlier code is not yet reflected.

Answer

Copilot does remember prior sessions, but the proxy's toxicity filter blocked the earlier context from being reused in the new suggestion.

Question 5

A developer on a GitHub Copilot Business plan is writing a new function in `payment_service.py`. They have several other files open in tabs, including a utility module they just edited. They notice that suggestions sometimes incorporate patterns from those other open files, not just the current file. When they ask you to explain the ordering of data that Copilot uses to build the prompt for a completion, which statement most accurately describes how the context is assembled and prioritized before it is sent to the model?

Accepted Answer

Copilot assembles a prompt on the client from the code around the cursor plus relevant snippets from neighboring open tabs, prioritizing the most proximate and recently relevant context to fit the model's limited window.

Answer

Copilot indexes the entire repository into a persistent vector database and retrieves the most semantically relevant chunks across all files for every completion request.

Answer

Copilot sends only the exact line the cursor is on, and the model infers everything else from its pre-trained knowledge of common coding patterns.

Answer

Copilot uploads all open files in full to the server, where the model reads every byte before generating a suggestion with no truncation.

Question 6

A developer notices that when they add a helper function at the very top of a large file, GitHub Copilot's inline completions further down the file don't seem to consistently use it, even though the function is clearly visible in the same file. They ask you why Copilot doesn't always incorporate every piece of code in the open file into its suggestions. Which explanation best describes how Copilot's prompt-building process handles this situation?

Accepted Answer

Copilot assembles a prompt within a limited token budget, selecting and prioritizing context by estimated relevance to the cursor rather than including the entire file verbatim, so distant code may be truncated or deprioritized.

Answer

Copilot always sends the complete contents of every open file to the model, so any inconsistency must be caused by a network error dropping part of the request.

Answer

Copilot permanently memorizes functions it has seen earlier in the session and reuses them from that memory, so the helper should have been remembered regardless of position.

Answer

Copilot only reads the 15 lines immediately above and below the cursor and ignores all other content in the file entirely.

Question 7

A developer working in a large monorepo asks why GitHub Copilot sometimes suggests a function signature that doesn't match a utility defined in a completely separate module that is not currently open in the editor. As the Copilot administrator explaining how completion prompts are built, which statement best describes the underlying cause?

Accepted Answer

Copilot builds the prompt primarily from the current file and a limited set of related context such as open tabs, so a closed, unrelated module is unlikely to be included in the prompt sent to the model.

Answer

Copilot indexes and reads the entire repository from disk for every completion request, so the closed module must have been corrupted or excluded by a content-exclusion rule.

Answer

Copilot stores all previously accepted suggestions in a persistent per-user database and reuses them, so the mismatch is caused by a stale cached suggestion.

Answer

Copilot sends the developer's full local file system tree to the model on each keystroke, so the model always has every module available and the mismatch indicates a proxy filtering error.

Question 8

A developer on your team is frustrated that GitHub Copilot's inline code completions sometimes suggest calls to functions that don't exist anywhere in their large monorepo, even though a correctly named helper function is defined in a file three directories away. They ask you why Copilot can't just reference every function in the entire repository when generating a suggestion. Which explanation best describes the underlying limitation of how Copilot builds its prompt for code completion?

Accepted Answer

Copilot assembles a limited-size context from the current file and related signals (such as open tabs and neighboring snippets) rather than indexing the whole repository, so functions outside that context can be hallucinated.

Answer

Copilot uploads the full repository to the model on every keystroke, but the model randomly ignores files to save processing time.

Answer

Copilot only ever sees the exact line the cursor is on, so it can never use any surrounding code or other files as context.

Answer

Copilot maintains a permanent server-side index of every function in the repository, so missing functions indicate the index is corrupted.

Question 9

A company is evaluating whether to purchase Copilot Business seats or let developers keep their Individual subscriptions. The security team's main concern is what happens to the code snippets sent as prompts for inline completions. Which statement accurately describes how prompt data is retained for Copilot Business compared to Copilot Individual?

Accepted Answer

For Copilot Business, prompts and suggestions are not retained after the completion is returned, whereas Copilot Individual may retain prompts to help improve the model unless the user opts out.

Answer

Both Copilot Business and Copilot Individual permanently store all prompts on GitHub servers for auditing, regardless of any settings.

Answer

Copilot Business retains prompts for 30 days for billing verification, while Copilot Individual discards them immediately.

Answer

Neither plan sends prompt data to GitHub servers; all completion processing happens entirely on the developer's local machine.

Question 10

A developer at a startup creates a brand-new, completely empty Python file and immediately begins typing the first line of code. They notice that Copilot's initial suggestions are generic and less tailored than what they normally receive when editing files in the middle of an established project. From an architecture and data-flow perspective, what best explains this difference in suggestion quality?

Accepted Answer

The prompt assembled for the request has little surrounding code and few contextual signals to draw from, so the model relies more heavily on its general training knowledge.

Answer

Copilot's model must be individually retrained on each new file before it can produce project-specific suggestions.

Answer

Copilot disables its post-processing proxy filters for empty files, which lowers the confidence of returned suggestions.

Answer

An empty file causes the client to skip the encryption-in-transit step, forcing the server to return only cached generic completions.

Question 11

A developer is editing a partially written function in the IDE. Their cursor sits in the middle of the function body, with meaningful code both above and below the cursor. They notice that Copilot's inline suggestions seem to account for the lines that come after the cursor, not just the lines before it. When the Copilot client assembles the prompt for this completion request, how does it incorporate the code surrounding the cursor?

Accepted Answer

It uses both the code before the cursor (prefix) and the code after the cursor (suffix) via a fill-in-the-middle technique so the model can generate contextually consistent completions.

Answer

It sends only the text before the cursor, because language models can generate tokens exclusively from left-to-right preceding context.

Answer

It ignores the current file entirely and relies only on neighboring open tabs to infer what belongs at the cursor position.

Answer

It sends the entire repository as context so the model always has full visibility into every file when completing at the cursor.

Question 12

A security engineer at a fintech company is documenting how source code from developers' IDEs reaches the GitHub Copilot model when an inline completion is triggered. They need to confirm how the prompt data is protected while it moves between the editor and the Copilot backend. Which statement accurately describes the handling of this input data in transit?

Accepted Answer

The prompt is transmitted over an encrypted TLS connection to the Copilot proxy, which relays it to the model; it is not persisted as training data for Business/Enterprise plans.

Answer

The prompt is stored in plaintext on the local disk and synced to GitHub servers on a nightly batch job before being sent to the model.

Answer

The prompt is always retained indefinitely and used to train the base foundation model regardless of the customer's plan.

Answer

The prompt bypasses the Copilot proxy entirely and connects the IDE directly to the model provider's public API without any GitHub-managed intermediary.

Question 13

A backend engineer notices that GitHub Copilot completions feel slower when working inside a very large monolithic file compared to smaller files. A teammate suggests this is because Copilot is 'sending the whole repository to be analyzed on every keystroke.' Which explanation most accurately describes what actually happens in the code-suggestion lifecycle?

Accepted Answer

The IDE extension assembles a bounded prompt from local context (cursor surroundings, neighboring open files, and relevant snippets), which is truncated to fit the model's context window before being sent through the proxy.

Answer

Copilot uploads the entire repository index to the model server, and larger repos always increase latency proportionally to total lines of code.

Answer

Copilot streams every open file in full to the proxy, where a post-processing filter decides which lines are relevant before forwarding to the model.

Answer

The model persistently caches the full file contents server-side between requests, so latency reflects the size of that stored cache.

Question 14

A team lead notices that when two developers type the exact same function signature and comment in identical files, GitHub Copilot sometimes offers different code completions to each of them. One developer insists this is a bug that should be reported, arguing that identical inputs must always produce identical outputs. How should you best explain this behavior when educating the team about Copilot's underlying architecture and limitations?

Accepted Answer

It is expected behavior because the underlying LLM is probabilistic and uses sampling, so identical prompts can yield different valid completions rather than deterministic output.

Answer

It is a defect in the proxy filtering layer that is randomly rejecting suggestions before they reach the client and must be reported to GitHub Support.

Answer

It happens because each developer's suggestions are cached locally and the differences reflect stale cache entries that will resolve after restarting the IDE.

Answer

It occurs because Copilot trains a personalized model per user in real time, so each developer receives outputs tuned exclusively to their own coding history.

Question 15

A developer on the GitHub Copilot Free/Individual plan asks how their code prompts are treated by the service during a completion request. Assuming they have NOT changed any privacy settings, which statement most accurately describes how the prompt data is handled once the suggestion is returned?

Accepted Answer

The prompt is discarded transiently after generating the suggestion, but by default the prompt and suggestion may be retained and used to improve the model unless the developer opts out.

Answer

The prompt is permanently stored and always used to train the foundation model, with no option to change this behavior on any plan.

Answer

The prompt never leaves the local machine because completions on individual plans are generated entirely on-device.

Answer

The prompt is always excluded from any retention or model improvement, identical to the guarantees provided under Copilot Business and Enterprise.

Question 16

A developer at a company using GitHub Copilot Business is concerned that the private code snippets pulled from their open files to build completion prompts will be used to train the underlying model, potentially exposing proprietary logic to other customers. What is the accurate explanation of how prompt input is handled for Copilot Business?

Accepted Answer

Prompt context is transmitted to the model to generate a suggestion but is not retained or used to train the foundational model for Copilot Business.

Answer

Prompt context is stored indefinitely and aggregated into the next model training cycle for all Copilot tiers.

Answer

Prompt context is only protected if the organization enables a separate content exclusion policy for every repository.

Answer

Prompt context is never sent off the developer's machine because completions for Business are generated entirely by a local model.

Question 17

A privacy officer at a company using GitHub Copilot Business asks you to clarify what happens to the prompt data (surrounding code and context) that is sent to the model when a developer receives an inline code completion. Under the standard Copilot Business data handling model, how is this prompt data treated after a suggestion is generated?

Accepted Answer

The prompt is transmitted to generate the suggestion and then discarded; it is not retained or used to train the foundation models for Business customers.

Answer

The prompt is retained indefinitely and used to fine-tune the shared foundation model so future suggestions improve for all customers.

Answer

The prompt is stored locally on GitHub servers for 90 days and made available to organization admins for review in the audit log.

Answer

The prompt is never transmitted off the developer's machine; completions are produced entirely by a locally cached model.

Question 18

A developer at a fintech company types code in their IDE and receives a Copilot ghost-text completion. Their security lead asks you to explain, in order, what happens to the request from the moment the developer pauses typing until the suggestion is displayed. Which sequence correctly describes the GitHub Copilot code-suggestion lifecycle?

Accepted Answer

The IDE extension assembles a prompt from surrounding context, sends it through the Copilot proxy to the model, the proxy applies post-processing filters (such as duplication/public-code matching and toxicity checks), and the filtered completion is returned to the IDE for display.

Answer

The IDE sends raw source files to the model, the model stores them for retraining, generates a completion, and returns it directly to the IDE without any intermediate filtering.

Answer

The proxy builds the prompt on GitHub's servers by cloning the repository, the model generates a suggestion, and the IDE applies toxicity filtering locally before display.

Answer

The IDE queries a local cache of previously accepted suggestions first, and only contacts the model through the proxy when no cached match exists, bypassing post-processing entirely.

Question 19

A compliance officer at a company using GitHub Copilot Business asks you to explain what happens to the source code snippets sent as prompt context when a developer receives an inline completion. She specifically wants to know how the code is handled server-side after a suggestion is generated. Which statement most accurately describes the data flow for a Copilot Business subscription?

Accepted Answer

The prompt context is transmitted to the model, used transiently to generate the suggestion, and discarded without being retained or used to train the foundation model.

Answer

The prompt context is stored server-side for 30 days so the model can maintain conversational memory across the developer's editing session.

Answer

The prompt context is retained indefinitely and automatically added to the foundation model's training corpus to improve future suggestions for all users.

Answer

The prompt context is stored only if the developer accepts the suggestion, after which it is used to fine-tune an organization-specific model.

Question 20

A developer on a GitHub Copilot Business plan is working in VS Code. As they type, Copilot shows an inline ghost-text completion, but the developer keeps typing and never presses Tab to accept it. Their organization has data retention concerns and asks how this rejected suggestion is handled by Copilot's architecture. What is the correct description of what happens to that unaccepted inline suggestion?

Accepted Answer

For Copilot Business, the generated suggestion and the prompt are discarded and not retained after the suggestion is served; only the fact that a suggestion was shown may be captured as usage telemetry, not the code itself.

Answer

The suggestion is stored on GitHub's servers for 30 days regardless of plan so that Copilot can improve future suggestions in the same file.

Answer

Because the developer did not accept it, the suggestion is permanently saved and used to train the underlying foundation model on Business plans.

Answer

The rejected suggestion is written to the local IDE cache and synced to GitHub only when the developer next commits code.

More GH-300 practice