GH-600 Sample Questions Answers

The selected location is appropriate when the planned developer changes concern repository-defined custom agents. Files under .github/agents/ define reusable agent roles that can be stored and reviewed alongside the application code. Their .agent.md format combines YAML configuration with Markdown instructions describing the agent’s responsibilities and expected behavior.

This arrangement allows the team to maintain specialized planning, implementation, and review roles consistently. Changes to an agent’s instructions or configuration can pass through the repository’s normal pull request process, providing a record of how the development workflow evolves.

The alternative locations serve different configuration purposes. .vscode/mcp.json configures MCP server connections for the workspace. .vscode/settings.json contains editor settings. Neither is the primary location for defining a repository’s custom agent profile.

The question’s planned changes are not reproduced in its supplied statement. Therefore, B is the source-selected answer under the custom-agent interpretation; a requirement specifically about MCP connectivity would require different configuration.

Study-guide topics: custom agent architecture, repository-scoped configuration, and version-controlled development workflows. Reference: VS Code—Custom agent file locations and structure .

===============

The tasks.md file is the execution-tracking document for the upgrade scenario. It records individual tasks, their validation criteria, and their completion status. Microsoft’s upgrade walkthrough specifically directs users to review this file when checking the status of every upgrade step.

A task can include several concrete verification activities, such as restoring dependencies, building the solution, correcting compilation errors, running the test suite, and rerunning tests after fixes. Reviewing these entries reveals whether implementation has merely been attempted or has satisfied the defined checks.

The assessment identifies upgrade issues and scope; it does not serve as the live record of completed work. A plan describes intended actions and ordering, which also differs from evidence that execution and testing succeeded.

The phrase “before App1 is upgraded” requires temporal care. Before execution, tasks.md identifies the steps and checks that must be performed. It cannot prove that future tests have already passed. Completion and test results become available as the agent executes and updates the tasks.

Study-guide topics: execution validation, task status, and acceptance criteria. Reference: Microsoft Learn—Execute and verify a Copilot upgrade .

===============

Target

Correct selection

Checkout ref

${{ github.sha }}

File checked by test -f

github/agents/rollout-bot.agent.md

Profile passed to the deployment script

github/agents/rollout-bot.agent.md

The workflow must deploy an agent profile from a specific repository snapshot. Setting the checkout reference to ${{ github.sha }} identifies the commit associated with the workflow event, rather than following a branch reference that might move as new commits arrive. The checkout action supports selecting a commit SHA through its ref input.

Both subsequent operations must use .github/agents/rollout-bot.agent.md. The existence check confirms that the expected profile is present in the checked-out revision, and the deployment script receives that same version-controlled file. Using a different path would break the relationship between the validated profile and the deployed profile.

Rollback requires one additional operational distinction: reverting a change creates a new commit containing the restored content. The deployment must run against that revert commit. Re-running the original failed workflow run retains its original SHA and does not automatically deploy the later revert.

This approach keeps agent behavior, repository history, and deployment provenance aligned, making the profile’s effective version identifiable and recoverable.

Relevant curriculum topics are durable state, controlled rollback, and continuity of agent configuration across executions.

In VS Code agent mode , GitHub Copilot can use built-in tools to perform actions required to complete and validate a development task. One of these capabilities is the terminal tool , which allows the agent to execute commands such as builds, linters, package-management operations, and test suites directly through VS Code ' s integrated terminal. The user can explicitly instruct the agent to make changes and then run a designated test command to verify the result.

The relevant control is the agent ' s tool and terminal invocation permissions . Depending on configured approval policies, Copilot can request authorization for a terminal command or execute approved commands as part of its iterative workflow. This allows validation to become part of the agent ' s task rather than requiring the developer to manually open the terminal after every modification. GitHub documentation specifically describes agent mode as capable of making edits, issuing terminal commands, observing results, and iterating when necessary.

Option A is unnecessary because running a local test suite does not require an MCP server. .copilotignore concerns context/access exclusions, while CODEOWNERS defines repository ownership and review responsibilities rather than agent execution capabilities.

Study Guide Reference Topics: Implement Tool Use and Environment Interaction; terminal tools; agent permissions; automated validation; iterative tool execution.

Statement

Selection

The configuration of the planner agent explicitly prevents code changes from being produced in the same conversation.

Yes*

The planner agent is violating its allowed tools by attempting internet access, and removing search will resolve the issue.

No

Adding a repository-level .github/copilot-instructions.md file that requires the agent to run tests and linters will mitigate the stalled pull request that has a failing CI anti-pattern.

Yes

*Interpreting “code changes” as direct file modifications by the correctly loaded planner, not code suggestions printed in chat or changes after switching agents.

The intended first selection is Yes: the planner has a read-oriented tool set, explicit planning-only instructions, and a handoff that does not automatically submit the implementation prompt. When this profile is correctly loaded and enforced, the planner lacks an editing tool for direct file modification. However, this does not prevent it from displaying proposed code in a response, nor does it permanently restrict another agent subsequently selected in the conversation. Unexpected file edits warrant checking the active profile and actual tool availability.

The second selection is No. The configured fetch capability permits network retrieval, so an internet-access attempt does not itself demonstrate tool misuse. Furthermore, firewall failures in the GitHub coding agent environment must be investigated in that environment; removing local search capability does not address their cause.

The third selection is Yes because repository instructions can specify the commands and expectations for testing and linting, helping reduce pull requests that fail CI. This mitigation does not independently resolve blocked network dependencies.

Relevant curriculum topics are planning/execution boundaries and diagnosis of agent anti-patterns.

Unassigning and reassigning the issue is GitHub’s documented retry action for an issue-driven agent session that remains stuck and times out. The troubleshooting guidance states that a persistently stuck session times out after an hour. At 70 minutes with no continuing activity, the scenario therefore calls for a fresh execution trigger rather than indefinite waiting.

Reassignment reissues the task through its original issue context. This makes C the appropriate selection among the available actions. The issue should contain current requirements so that the retry begins with the intended scope rather than repeating an outdated assignment.

Option B is incorrect because a draft pull request should not be merged simply to restart implementation, and Copilot does not respond to new mentions on merged or closed pull requests. Option D authorizes repository workflow execution rather than restarting the agent.

For operational precision, reassignment is a documented retry mechanism, not a universal guarantee that every retry reuses the same pull request. Where preserving a particular pull-request branch is essential, an authorized @copilot comment on that open pull request directly targets it.

Relevant curriculum topics are timeout recovery, task reinitialization, and preserving execution continuity.

The correct command is /diff . GitHub Copilot CLI provides /diff specifically for reviewing code changes directly from the terminal. GitHub ' s current CLI command reference defines /diff as a command that reviews changes in the current directory and can automatically switch to a branch comparison when the working tree is clean. This makes it the appropriate command when validating an agent-generated change set before accepting or merging the work.

The other commands serve different purposes. /context displays context-window utilization, including token allocation and remaining context capacity; it does not show code modifications. /compact summarizes conversation history to reclaim context-window space during long-running sessions. /plan creates an implementation plan before coding and restricts normal project-file modifications while the plan is being prepared.

Using /diff supports an essential human-in-the-loop control in agentic software development: generated code should be inspected before it crosses a merge or deployment boundary. Reviewing the diff exposes additions, deletions, and modifications so that unintended or unsafe changes can be identified before integration.

Study Guide Reference Topics: Implement Tool Use and Environment Interaction; agent-generated code review; human-in-the-loop validation; controlled execution and change inspection.

The correct solution combines a branch protection rule with a CODEOWNERS file . CODEOWNERS allows the repository to associate specific paths with designated users or teams. For example, entries can assign security or platform reviewers to .github/workflows/* and /infra/*. When a pull request modifies those paths, GitHub automatically identifies the corresponding code owners.

The enforcement mechanism comes from branch protection on main. Configure the protection rule to Require a pull request before merging and enable Require review from Code Owners . GitHub then blocks the merge until an applicable code owner approves the affected files. This converts CODEOWNERS from simple reviewer routing into an enforceable merge-control boundary.

agents.md and copilot-instructions.md provide behavioral guidance to AI agents; they do not enforce reviewer authorization. .copilotignore likewise does not establish mandatory merge approval. Although GitHub rulesets can also implement review controls, none of the ruleset choices provides the required CODEOWNERS pairing.

Study Guide Reference Topics: Implement Guardrails and Accountability; protected branches; required human review; CODEOWNERS; repository governance; approval gates.

Signal

Execution context

The eyes emoji reaction appears on the issue.

The agent acknowledges the assignment and will create the draft pull request.

The pull request timeline shows Copilot started work.

The agent session is actively running and generating live logs.

A draft pull request exists, but GitHub Actions checks are not running.

A human must manually approve and run the workflows.

The eyes reaction signals that Copilot has acknowledged the issue assignment. It is an early lifecycle indicator that the coding agent accepted the work and will begin its workflow.

A pull-request timeline event showing that Copilot started work indicates an active session. This is the appropriate place to observe ongoing status updates and session activity while the agent creates or revises the draft pull request.

When the draft pull request exists but its workflows have not started, the likely state is pending manual authorization. GitHub can require a user with write access to approve and run workflows associated with the pull request, especially where the workflow originates from an untrusted context or requires explicit approval.

These indicators are complementary: issue reactions establish acknowledgement, timeline events show active execution, and inactive checks can identify an approval gate rather than an agent failure.

Study-guide topics: asynchronous coding agents, execution signals, workflow approval, and pull-request observability.

===============

Target

Correct selection

apply_auto.if

${{ needs.plan.outputs.risk == ' low ' }}

The automatic execution job must explicitly require the low-risk classification. The expression ${{ needs.plan.outputs.risk == ' low ' }} reads the risk value published by the prerequisite plan job and permits automatic application only when that value matches low. Medium-risk and high-risk plans therefore cannot enter this automatic execution path.

The complementary reviewed path should handle non-low classifications and reference an environment configured with required reviewers. The condition routes work according to risk; the environment protection rule supplies the actual approval barrier. Merely naming a job “manual” or displaying an approval message does not require human authorization.

The alternatives always(), success(), and failure() describe execution status rather than the plan’s risk classification. Checking only for medium would also fail to cover high-risk changes. The plan-producing job must publish the risk as an output, and each execution job must obtain the corresponding plan artifact before applying it.

This design applies human intervention where the task’s operational impact warrants it while allowing routine low-risk work to proceed automatically.

Relevant curriculum topics are risk-based autonomy, explicit authorization, and controlled execution paths.

A is the intended answer among the supplied choices , because the required control is a Copilot-specific content exclusion mechanism rather than Git authorization or branch governance. The important technical concept is excluding the sensitive directory from Copilot ' s usable context and suggestions.

Current GitHub documentation implements this through Copilot Content exclusion settings at repository, organization, or enterprise scope. Administrators can specify exact files, directory paths, and patterns to exclude. For excluded content, GitHub states that inline suggestions are unavailable in the affected files, excluded file content does not inform suggestions elsewhere, and the files are excluded from supported Copilot responses and code review.

Neither CODEOWNERS nor branch protection prevents Copilot from reading or generating suggestions for a particular directory. CODEOWNERS establishes reviewers/ownership, while branch protections and rulesets govern repository operations such as pushes, merges, and review requirements. Those mechanisms operate too late in the lifecycle to satisfy a requirement concerning Copilot ' s access to sensitive file content.

For exam purposes, therefore, A maps to the content-exclusion concept . In current GitHub administration, implement the control through Settings → Copilot → Content exclusion and specify the sensitive directory path.

Study Guide Reference Topics: Implement Guardrails and Accountability; sensitive-context exclusion; least exposure; repository security boundaries.

Hook target

Value

Security-check command

preToolUse

Build-results logging command

postToolUse

Tool-usage logging command

postToolUse

preToolUse is the correct hook for evaluating proposed tool usage before it executes. A security-check command at this lifecycle point can inspect the tool request and permit, deny, or require approval before an effect occurs.

Both build-result logging and tool-usage logging occur after an operation has completed, so both use postToolUse. The hook can capture the result, exit status, and other relevant metadata for audit or diagnostic purposes.

A session-start or session-end hook is too broad because it runs at the boundary of the full session rather than around an individual tool invocation. An error-occurrence hook reacts to failures but does not provide routine after-execution logging for successful tool usage.

The same hook type can be used multiple times in a configuration. Each entry can call a different command for a distinct purpose, such as one record for build results and another for general tool-usage telemetry.

Study-guide topics: pre-execution controls, post-execution telemetry, hooks, and audit evidence.

===============

Requirement

Selection

When a previous prompt is no longer relevant

Start a new chat

To keep Copilot Chat focused in the IDE

Open related files and close unrelated files

Starting a new chat creates a separate conversational context and prevents unrelated earlier exchanges from continuing to shape the response. It is the direct way to remove irrelevant chat history from the active work item without altering the repository or other conversations.

Opening relevant files supplies useful workspace context, while closing unrelated files reduces incidental context available to the assistant. This does not replace a new conversation when earlier chat history is the problem, but it helps keep the subsequent interaction focused on the current implementation.

Increasing agent request limits affects execution capacity, not the relevance of prior discussion. Removing repository instructions would be inappropriate because those instructions may define required engineering standards and are not the same as unrelated chat history.

Study-guide topics: conversation context, context management, focused IDE workflows, and session isolation.

===============

Yes, Yes, Yes

Comprehensive and Detailed 150 to 250 words of Explanation From Agentic AI Developer/Course Guide/topics:

All three statements are supported by explicit operational signals in the supplied logs.

The first statement is Yes . Each relevant session records Passing 1 MCP server(s) to SDK: [github] followed by github: type=http. These entries show that the GitHub MCP server is being supplied to the agent session as an available remote MCP integration. The CLIMCPServerEnabled=false entry concerns the separate CLI MCP configuration flag and does not negate the subsequently logged GitHub server passed to the SDK.

The second statement is Yes . The logs explicitly state workspace isolation mode selected for session and indicate that worktree creation is skipped. Therefore, the selected session isolation mechanism is workspace isolation rather than a separate Git worktree.

The third statement is Yes . Two distinct entries identify new Copilot CLI sessions with isNewSession: true: one beginning with session ID de04f0fe... and another with 6852c5dc.... Later MCP/configuration events do not contain another isNewSession: true record, so the evidence shows exactly two newly started sessions.

This type of log interpretation directly maps to the GH-600 requirement to identify failures and execution characteristics by analyzing logs, traces, outputs, and workflow artifacts , and to use operational signals when evaluating multi-agent behavior.

Study Guide Reference Topics: Perform Evaluation, Error Analysis, and Tuning; log and trace analysis; execution-context evaluation; MCP observability; multi-agent session analysis.

Target

Selection

Dropdown 1

' search '

Dropdown 2

' read '

The visible configuration describes an implementation planner. Providing search and read supports the information-gathering work needed to produce a technically grounded plan: locating relevant code and inspecting its contents. The listed documentation tools supplement repository context with external technical reference material.

This tool selection also establishes a practical boundary between planning and implementation. A planner can explain proposed changes and produce Markdown in its response without needing permission to modify repository files. Granting editing or command-execution capabilities would expand its authority beyond the visible planning role.

The distinction between generating Markdown and saving a Markdown file is important. The selected tools support producing a plan in conversation. If the requirements instead demanded that the planner write that plan directly into the repository, an appropriate file-writing capability or a separate persistence step would be necessary.

Tool names must also resolve to capabilities available in the configured environment. Merely listing a documentation tool does not install or authenticate its MCP server.

Study-guide topics: tool selection, least-privilege planning, and environment capabilities. Reference: VS Code—Use tools with agents .

Statement

Answer

The .github/upgrades folder contains all the required reports.

Yes*

The tasks.md file contains all the changes and their implementation status.

Yes

The assessment.md file lists all the breaking changes and their implementation status.

No

*For the standard upgrade-generated reports, including their scenario subfolder.

GitHub Copilot upgrade stores its generated workflow state under .github/upgrades/{scenarioId}. This includes the assessment, plan, task tracking, and related scenario records. Consequently, the parent .github/upgrades folder contains the standard upgrade reports through its scenario subdirectories. The PDF’s marked “No” for the first statement conflicts with that documented storage structure unless an additional, unstated reporting requirement applies.

The tasks.md file tracks execution progress. It identifies the upgrade tasks and records their implementation status as work proceeds. In this context, “all the changes” means the tracked upgrade tasks, rather than a complete line-by-line replacement for the Git diff.

The assessment has a different purpose. It describes the application’s compatibility issues, breaking changes, dependencies, and upgrade scope. It is not the authoritative execution-status record. Identifying a breaking change in an assessment does not establish that its remediation has been implemented or validated.

These files collectively separate the original findings, planned response, and execution progress, making the upgrade reviewable across sessions.

Study-guide topics: durable workflow state, progress tracking, and generated artifacts. Reference: Microsoft Learn—GitHub Copilot upgrade state management .

===============

Copilot memory is an organization-level capability. Configuring it through the organization’s Copilot settings establishes the governance boundary, availability, and policy controls consistently for the developers and repositories covered by that organization.

Personal settings are unsuitable because they create inconsistent behavior between developers and do not provide centralized administration. A repository-level configuration can supply repository instructions and scoped context, but it does not replace the organization-level control that enables and governs the memory capability. An individual agent profile defines role behavior, tool access, prompts, and delegation settings; it is not the tenant-level location for enabling Copilot memory.

Organization configuration is particularly important when agents must retain approved context, recurring preferences, and workflow guidance across sessions without each developer configuring behavior independently. Central governance also allows administrators to maintain predictable controls over which organizational information is available to Copilot.

Study-guide topics: organizational governance, persistent context, and centralized agent configuration.

Separate branches isolate each agent’s proposed changes and allow the team to inspect them independently. Adding a required status check for file-level overlap detects conflicting modifications before either pull request is merged, preventing one agent’s work from silently overwriting another’s changes.

A read-only tool configuration prevents both agents from making required changes, so it avoids conflict by eliminating implementation capability rather than controlling it. CODEOWNERS approval adds review accountability for a specific file but does not automatically detect overlap between independent agent outputs. A single concurrency group serializes entire workflows and reduces throughput even where the agents work on unrelated files.

The selected solution maintains parallel development while creating a merge-time control for the actual risk: overlapping file changes. It also produces reviewable evidence of the overlap check in pull request status results.

Branch isolation does not eliminate semantic conflicts, such as incompatible API assumptions. Teams should therefore combine overlap detection with normal pull request review and integration testing.

Study-guide topics: parallel agent coordination, branch isolation, merge controls, and conflict detection.

A fine-grained PAT restricted to product-api provides an enforceable repository-level authorization boundary for agent1. GitHub fine-grained personal access tokens can be limited to selected repositories and assigned only the repository permissions required by the workload. Consequently, even if agent1 attempts to access billing-service or infra-terraform, the credential does not authorize access to those repositories. GitHub specifically recommends fine-grained PATs when repository access must be restricted to particular repositories.

This directly aligns with the GH-600 objective to configure an agent ' s scope to a specific repository and define execution boundaries through repository context and permissions. Microsoft Learn defines execution context as including the repository an agent can access and emphasizes that repository scope is the first boundary limiting agent behavior.

Option A provides behavioral guidance but is not a security authorization boundary. Option B controls the permissions available to the workflow token but does not, by itself, establish the required cross-repository credential restriction. Option D only prevents certain push operations; it does not stop agent1 from reading or otherwise accessing the other repositories.

Study Guide Reference Topics: Implement Tool Use and Environment Interaction → execution context and boundaries; repository-specific agent scope; tool permissions; least-privilege authentication.