🤖 Copilot Fundamentals - GH-COPILOT Practice Questions

GH-COPILOT Fundamentals Question Bank (31 Questions)

Browse all 31 practice questions covering Copilot Fundamentals for the GH-COPILOT certification exam. Each question includes the full answer and a detailed explanation to help you understand the concepts.

1. Question 1Responsible AI

   What is a potential concern when GitHub Copilot generates code suggestions?

   ACopilot may only suggest code in Python regardless of language context

   BSuggestions may contain security vulnerabilities, bugs, or resemble training data✓

   CCopilot replaces the need for code review

   DCopilot cannot suggest code for private repositories
   Show Answer & Explanation

   Correct Answer: B

   Explanation:

   Copilot suggestions should always be reviewed. They can contain security flaws, incorrect logic, or rare cases resembling training data. Developers remain responsible.

2. Question 2Responsible AI

   What does the GitHub Copilot content exclusion feature allow administrators to do?

   ABlock specific programming languages from Copilot suggestions

   BExclude specific files or repositories from being used as context for Copilot✓

   CPrevent Copilot from suggesting test code

   DDisable Copilot for specific users in an organization
   Show Answer & Explanation

   Correct Answer: B

   Explanation:

   Content exclusion lets admins configure paths (e.g., sensitive config files) that Copilot will not send to the service or use as context.

3. Question 3Responsible AI

   According to responsible AI principles, who is ultimately responsible for code generated with GitHub Copilot?

   AGitHub, because Copilot generated the code

   BThe developer who accepted and committed the suggestion✓

   CThe organization's security team after code review

   DShared equally between GitHub and the developer
   Show Answer & Explanation

   Correct Answer: B

   Explanation:

   The developer who accepts and commits a Copilot suggestion is responsible for that code, just as they would be for any code they write.

4. Question 4GitHub Copilot Plans and Features

   In which editors is GitHub Copilot code completion natively available?

   AOnly Visual Studio Code

   BVS Code, Visual Studio, JetBrains IDEs, Vim/Neovim, and others✓

   CVS Code and GitHub Codespaces only

   DAny editor supporting the Language Server Protocol
   Show Answer & Explanation

   Correct Answer: B

   Explanation:

   GitHub Copilot officially supports VS Code, Visual Studio, JetBrains IDEs, Vim/Neovim, Azure Data Studio, and Eclipse (via plugin).

5. Question 5Responsible AI and Limitations

   What is GitHub's approach to responsible AI in Copilot?

   ANo responsibility framework

   BMulti-layered: input filtering, output filtering (toxic content, vulnerabilities), public code filter, privacy controls (no training on Business/Enterprise code), transparency, and user control over features✓

   COnly content filtering

   DOnly privacy
   Show Answer & Explanation

   Correct Answer: B

   Explanation:

   Responsible AI pillars: 1) Accountability (clear terms of service, liability guidelines), 2) Transparency (how it works, training data disclosure), 3) Privacy (Business/Enterprise: no code retention for training), 4) Fairness (bias monitoring in training data), 5) Safety (content filters for harmful output), 6) Security (vulnerability pattern detection in output). User controls: enable/disable per language, public code filter toggle, telemetry opt-out (Individual plan), and content exclusions (Business/Enterprise). Feedback: thumbs up/down on suggestions for improvement.

6. Question 6GitHub Copilot Plans and Features

   What technology powers GitHub Copilot's code suggestions?

   AA rule-based code template engine

   BA large language model (LLM) trained on publicly available code✓

   CA database of Stack Overflow answers

   DGitHub's internal code search index
   Show Answer & Explanation

   Correct Answer: B

   Explanation:

   GitHub Copilot is powered by large language models (originally OpenAI Codex, now GPT-4 based models) trained on publicly available code.

7. Question 7GitHub Copilot Features and Setup

   What data does GitHub Copilot use to generate suggestions?

   AOnly the current file

   BContext from open files, comments, function names, and the broader codebase to generate contextual suggestions✓

   CA fixed database of code snippets

   DOnly Stack Overflow answers
   Show Answer & Explanation

   Correct Answer: B

   Explanation:

   Copilot analyzes context from the current file, open tabs, comments, function signatures, and surrounding code to generate relevant, contextual code suggestions.

8. Question 8Using Copilot Effectively

   What is the best practice for getting accurate Copilot suggestions?

   AWrite no comments

   BProvide clear, descriptive comments and function names that describe the intended behavior✓

   CUse single-letter variable names

   DAvoid any context
   Show Answer & Explanation

   Correct Answer: B

   Explanation:

   Clear comments, descriptive function names, and well-structured code provide Copilot with better context, resulting in more accurate and relevant code suggestions.

9. Question 9Using Copilot Effectively

   How do you cycle through multiple Copilot suggestions?

   AYou can't — only one suggestion is shown

   BUse keyboard shortcuts (Alt+] / Alt+[) to cycle through alternative suggestions✓

   CRefresh the page

   DClose and reopen the file
   Show Answer & Explanation

   Correct Answer: B

   Explanation:

   Copilot often generates multiple alternative suggestions. Alt+] (next) and Alt+[ (previous) cycle through alternatives, allowing you to choose the best fit.

10. Question 10Using Copilot Effectively

    How do you provide context to Copilot for better suggestions?

    ACopilot doesn't use context

    BOpen relevant files, write descriptive comments, use meaningful variable names, include type annotations, and reference file content with #file in chat✓

    CClose all files

    DUse random variable names
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Context strategies: open related files (Copilot reads open tabs), write clear comments describing intent, use descriptive names, add type annotations, reference files in chat (#file:path), and use @workspace for codebase-wide context.

11. Question 11Responsible AI and Limitations

    How does Copilot handle security vulnerabilities in suggestions?

    ANo security filtering

    BCopilot includes AI-based vulnerability filtering that attempts to block insecure patterns (SQL injection, hardcoded credentials, path traversal), though human review remains essential✓

    CGuarantees secure code

    DOnly flags after commit
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Security filtering: blocks common insecure patterns (hardcoded secrets, SQL injection, XSS). Also: Copilot vulnerability filter for real-time blocking. Limitations: not comprehensive, novel attack patterns may pass through. Best practice: always review suggestions, use code scanning (CodeQL) as safety net.

12. Question 12Responsible AI and Limitations

    What data does GitHub Copilot use for suggestions?

    AOnly your private code

    BCopilot is trained on public code and natural language. For suggestions: uses context from your current file and open tabs. Business/Enterprise: prompts and suggestions are NOT used for training.✓

    CAll user code for training

    DOnly documentation
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Training: public code on GitHub (before Copilot launch). Real-time context: current file, open tabs, imports. Privacy: Business/Enterprise — code snippets sent for completion are NOT retained or used for training. Individual: telemetry opt-out available. Content exclusions: org admins can exclude repos/paths.

13. Question 13Using Copilot Effectively

    How do you accept partial Copilot suggestions?

    AMust accept all or nothing

    BUse Ctrl+Right Arrow (Word) or Tab for full acceptance. In VS Code, use Ctrl+Right to accept word by word, allowing you to take only the useful part of a suggestion.✓

    CCannot accept partially

    DOnly accept full lines
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Partial acceptance: Ctrl+Right Arrow (accept next word), Tab (accept entire suggestion). In VS Code: Cmd/Ctrl+Right for word-by-word. Workflow: see suggestion → accept useful part word by word → continue typing to get a new suggestion for the rest. Efficient for iterating on suggestions.

14. Question 14GitHub Copilot Features and Setup

    What is Copilot code completions vs Copilot Chat?

    ASame feature

    BCompletions: inline suggestions as you type (ghost text). Chat: conversational AI for explaining code, generating code from descriptions, fixing errors, and answering questions.✓

    CCompletions is better

    DChat replaces completions
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Completions: real-time, inline ghost text as you type. Accept with Tab. Context: current file + open tabs. Chat: conversational interface (sidebar or inline). Commands: /explain, /fix, /tests, /doc. Context: @workspace, #file, selected code. Both complement each other — completions for flow, Chat for complex tasks.

15. Question 15Using Copilot Effectively

    What is the role of comments in Copilot suggestions?

    ANo effect on suggestions

    BComments serve as natural language prompts that guide Copilot's code generation — writing descriptive comments before code significantly improves suggestion relevance and accuracy✓

    CCopilot ignores comments

    DComments slow down Copilot
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Comments as prompts: write intent in comment → Copilot generates matching code. Examples: '// function to validate email using regex' → generates implementation. Best practices: be specific ('sort array descending by price' not 'sort array'), include edge cases, use function-level docstrings for complete implementations. Multiple comment lines provide more context for complex logic.

16. Question 16Using Copilot Effectively

    How do you get better Copilot suggestions?

    ANo way to improve

    BProvide clear context: descriptive variable/function names, relevant comments, keep related files open, write function signatures before body, and break complex tasks into smaller functions✓

    CAlways accept first suggestion

    DCopilot cannot be improved
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Best practices: descriptive names (calculateMonthlyPayment vs calc), comment intent before code, keep related files in tabs (Copilot uses open files as context), start with function signature/types, examples in comments (input → output), consistent coding style, and iterate (reject → modify prompt → try again). Context is king: more relevant context = better suggestions.

17. Question 17GitHub Copilot Features and Setup

    What are Copilot's inline suggestions and how do they work?

    AManual code generation

    BReal-time ghost text suggestions that appear as you type, generated from your current file context, open tabs, and adjacent code, accepted with Tab and cycled with Alt+]/Alt+[✓

    COnly on-demand suggestions

    DOnly chat-based
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Inline suggestions: triggered automatically as you type (or manually with Alt+\). Displayed as: gray ghost text after cursor. Accept: Tab (full), Ctrl+Right (word by word). Navigate: Alt+] (next suggestion), Alt+[ (previous). Dismiss: Esc or keep typing. Context sources: current file (highest priority), open tabs, imported modules. Quality improves with: clear variable names, comments, and type annotations.

18. Question 18Using Copilot Effectively

    What context does Copilot use to generate suggestions?

    AOnly the current line

    BCurrent file content (highest priority), open tabs in the IDE, imported/referenced files, file path and language, and recent edits — combined to understand intent and generate contextual code✓

    COnly the entire codebase

    DNo context used
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Context hierarchy: current file (most weight — surrounding code, imports, comments), neighboring tabs (open files in IDE provide additional context), file metadata (language, path suggest domain), and recent edits (recent changes influence suggestions). Tips: keep related files open, use descriptive file names, maintain consistent style, and close irrelevant tabs. Limitations: context window has a token limit — very large files may be truncated.

19. Question 19Responsible AI and Limitations

    How does GitHub Copilot handle sensitive data in suggestions?

    ANo handling

    BCopilot is designed not to generate common secret patterns (API keys, passwords), but cannot guarantee it won't suggest code that handles sensitive data carelessly — human review is essential✓

    CPerfect security

    DBlocks all secrets
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Sensitive data: Copilot trained to avoid generating real secrets, but may suggest insecure patterns (hardcoded strings, logging sensitive data). Mitigations: content exclusions (exclude .env files from context), organization policies (block suggestions matching public code), and code review (human verification). Best practice: never put secrets in code regardless of source, use secret scanning as safety net, and educate developers that AI suggestions require the same security review as human code.

20. Question 20Using Copilot Effectively

    What is context management for better Copilot suggestions?

    ANo control over context

    BKeep relevant files open, write descriptive comments, use meaningful variable names, provide example inputs/outputs, and structure code logically — Copilot uses these signals for more accurate suggestions✓

    COnly the current file matters

    DOnly comments matter
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Context sources: current file (strongest signal), open tabs (related files), file name (infers purpose), comments (natural language intent), variable/function names (semantic meaning), and imports (framework context). Tips: 1) Open related files in tabs, 2) Write comment describing desired function before generation, 3) Provide type signatures, 4) Include example in comment, 5) Name variables descriptively, and 6) Follow consistent patterns (Copilot continues patterns). @workspace in chat: explicitly include codebase context.

21. Question 21Using Copilot Effectively

    What are Copilot code completions and how to accept them?

    AOnly full line completions

    BGhost text suggestions that appear as you type: Tab to accept full suggestion, Ctrl+Right to accept word-by-word, or continue typing to refine. Alt+] / Alt+[ to cycle through alternative suggestions.✓

    COnly function-level

    DManual trigger only
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Completions: inline ghost text (gray text after cursor). Accept: Tab (full suggestion), Ctrl+→ (word by word), continue typing (narrow suggestion). Navigate: Alt+] (next suggestion), Alt+[ (previous). Trigger: automatic as you type, or open completions panel (Ctrl+Enter) for multiple options. Types: single-line, multi-line, and full function body. Quality: improves with context (good comments, open related files, meaningful names). Dismiss: Esc or keep typing different code.

22. Question 22Using Copilot Effectively

    What strategies help when Copilot gives incorrect suggestions?

    AAccept and move on

    BIterate: rephrase the prompt, add more context, break the problem into smaller parts, provide examples, or use a different approach — treat Copilot as a pair programmer that needs guidance✓

    CAlways write code manually

    DReport every error
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Strategies: 1) Rephrase prompt (different wording may trigger better suggestion), 2) Add context (open related files, add comments), 3) Break down (ask for smaller pieces instead of full solution), 4) Provide example (show input/output in comment), 5) Be more specific (technology, constraints, edge cases), 6) Use slash commands (/fix for bugs, /tests for test generation), 7) Try inline chat vs. sidebar chat (different interaction modes), and 8) Start typing the solution (Copilot completes better with a starting point). Key: AI augments, doesn't replace developer judgment.

23. Question 23Using Copilot Effectively

    What is the role of comments in getting better Copilot suggestions?

    AComments don't help

    BComments serve as natural language instructions: descriptive comments before functions guide Copilot's understanding of intent, constraints, and expected behavior, producing more accurate suggestions✓

    COnly for documentation

    DComments slow down Copilot
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Comment strategies: 1) Function-level intent ('// Calculate the total price with tax and discount'), 2) Step-by-step algorithm ('// 1. Validate input, 2. Query database, 3. Transform result'), 3) Constraints ('// Must handle null inputs, max 1000 items'), 4) Examples ('// Input: [1,2,3] → Output: 6'), 5) Technology ('// Using Express.js middleware pattern'), and 6) Edge cases ('// Handle empty array and negative values'). Quality: more specific comments → more accurate suggestions. Pattern: write comment → let Copilot generate → review and iterate.

24. Question 24Prompt Crafting and Developer Use Cases

    In GitHub Copilot Chat, what does the /explain slash command do?

    AGenerates a new unit test for selected code

    BProvides a natural language explanation of selected code✓

    CSuggests code improvements for readability

    DOpens the GitHub Copilot documentation
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    /explain generates a natural language description of selected code. Other commands: /tests (generate tests), /fix (suggest fixes), /doc (add docs).

25. Question 25How GitHub Copilot Works and Handles Data

    For GitHub Copilot Business, does GitHub retain code snippets (prompts) to train future models?

    AYes, all code is retained and used for training

    BNo, prompts and suggestions are not retained for training on Business and Enterprise plans✓

    CYes, but only for public repositories

    DOnly metadata is retained, not the code content
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    For Business and Enterprise plans, prompts and suggestions are not retained or used to train models. Individual users can opt out in settings.

26. Question 26Using Copilot Effectively

    What is the purpose of Copilot's slash commands in chat (e.g., /explain, /fix, /tests)?

    AFile management

    BProvide specific instruction shortcuts for common tasks like explaining code, fixing bugs, and generating tests✓

    CGit operations

    DDeployment commands
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Slash commands provide structured shortcuts: /explain describes selected code, /fix suggests bug fixes, /tests generates unit tests, and /doc generates documentation.

27. Question 27Responsible AI and Limitations

    What should developers understand about Copilot's training data?

    ATrained on private repos only

    BTrained on publicly available code and documentation; suggestions reflect patterns in training data which may include biases, outdated patterns, or errors✓

    CTrained on curated code only

    DUpdated in real-time
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Copilot's training data is public code/docs, meaning suggestions reflect: popular patterns (not always best), potentially outdated practices, varying quality, and possible biases — requiring critical evaluation.

28. Question 28GitHub Copilot Features and Setup

    What Copilot plans are available?

    AOnly free tier

    BCopilot Free (limited completions), Individual ($10/month), Business ($19/user/month with org controls), and Enterprise ($39/user/month with knowledge bases)✓

    COnly paid plans

    DOnly enterprise
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Plans: Free (limited suggestions per month), Individual ($10/mo, personal use), Business ($19/user/mo, org management, policy controls, audit logs), Enterprise ($39/user/mo, adds knowledge bases, fine-tuning, Bing integration).

29. Question 29Copilot Business and Enterprise

    What reporting and analytics are available for Copilot?

    ANo analytics

    BUsage API (REST) providing: active users over time, acceptance rates, languages used, and editor breakdown. Plus admin dashboard with seat utilization and adoption metrics.✓

    COnly user count

    DOnly billing amount
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Analytics: REST API (GET /orgs/{org}/copilot/usage). Metrics: total active users, total engaged users, acceptance rate (accepted/shown), acceptance count, lines suggested, lines accepted, breakdown by: language, editor, and day. Dashboard: org Settings > Copilot > seat management (active/inactive/pending users). Enterprise: cross-org analytics. Export: API → BI tools (Power BI, Tableau, Looker). Use for: ROI measurement (acceptance rate × lines → time saved), adoption tracking, and identifying teams needing training.

30. Question 30Responsible AI and Limitations

    What training data does Copilot use?

    AOnly private repos

    BTrained on publicly available code from GitHub and other public sources: public repositories with permissive and restrictive licenses, filtered for quality. Business/Enterprise code is never used for training.✓

    CAll GitHub code

    DOnly verified code
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Training data: publicly available code (GitHub public repos, StackOverflow, documentation). Includes: various open-source licenses (MIT, Apache, GPL, etc.). Filters: code quality, deduplication, and content filtering. Not included: private repos, Business/Enterprise customer code, and DMCA-removed content. Updates: model periodically retrained with newer code. Implications: may suggest patterns from any public code (including GPL-licensed — hence public code filter option), and knowledge cutoff (may not know very recent libraries/APIs). Transparency: GitHub discloses training approach in documentation.

31. Question 31Copilot Business and Enterprise

    What is Copilot's relationship with Azure OpenAI Service?

    ANo relationship

    BCopilot uses Azure OpenAI Service as its AI infrastructure: models hosted on Azure, enterprise-grade security and compliance, data processing within Azure's security boundary, and no data sharing with OpenAI✓

    CRuns on OpenAI directly

    DSelf-hosted by GitHub
    Show Answer & Explanation

    Correct Answer: B

    Explanation:

    Architecture: GitHub Copilot → Azure OpenAI Service (enterprise deployment). Benefits: Azure enterprise security controls, data processed within Azure boundary (not shared with OpenAI), compliance certifications (Azure SOC 2, ISO 27001), regional data processing, and Microsoft's AI safety framework. Key distinction: Copilot uses Azure OpenAI (Microsoft's enterprise AI service), not OpenAI's consumer API — different data handling, no training on inputs, and enterprise compliance. For procurement: cite Azure OpenAI's enterprise commitments and certifications.