Skip to content

GH-600 gap notes ​

These are the six boundaries where plausible-sounding answers go wrong, plus the "choose two" traps. The consistent theme: the safe answer names a boundary, an artifact, or a gate.

1. MCP and tool boundary ​

MCP questions are usually permission questions wearing an integration costume.

Scenario signalCorrect move
Agent needs external API/dataAdd an MCP server only for that source
MCP server has many toolsAllow only required tools
MCP tool can write external stateGate or disable the write tool
Third-party MCP serverReview trust, data exposure, auth, logging, and owner
Agent cannot see expected toolCheck repository settings, agent profile, allow list, and auth
Agent made bad choices after adding MCPRemove noisy tools or improve routing instructions
External doc source is staleVerify source-of-truth and cache behavior

Eliminate options that:

  • enable all MCP tools
  • treat MCP as inherently trusted
  • fix every failure by broadening permissions
  • ignore auth, token scope, or write capability
  • skip logging and review for external systems

Fast drill: explain why a read-only GitHub MCP tool and a ticketing-system write tool require different review.

2. Environment and execution boundaries ​

GH-600 can make several GitHub controls sound interchangeable. They are not.

ControlUse it for
BranchIsolate code mutation
Pull requestReview and discuss code changes
Ruleset/branch protectionEnforce merge conditions
Required checksBlock merge until validation passes
CODEOWNERSRoute review for owned paths
Actions workflowRun automated jobs
RunnerProvide execution environment
EnvironmentGate deployment and secrets
Secrets/variablesStore sensitive or configurable values
Firewall/networkRestrict reachable endpoints
MCP allow listRestrict external agent tools

Eliminate options that:

  • use PR review as if it controls runtime network access
  • use runner configuration as if it approves deployment
  • release production secrets before approval
  • let the agent mutate default branch directly
  • bypass checks for agent-generated code

Fast drill: for any deployment question, say which control blocks the code, which control blocks the secret, and which artifact proves the run.

3. Memory, state, and secrets ​

This is the one actual miss. Lock it down.

NeedCorrect place
Stable coding preferenceScoped persistent memory
Temporary task detailsSession context
Long-running progressIssue, PR, plan, task board, session log
Shared multi-agent stateExternal store or explicit handoff artifact
Current source truthRepository files, branch state, checks, logs
Production tokenApproved secret storage

Eliminate options that:

  • store tokens, credentials, or production secrets in memory
  • rely on chat history as the only handoff
  • keep stale memory after architecture changes
  • let memory override repository instructions
  • share state informally across agents

Fast drill: if a memory answer sounds convenient, ask whether it is safe, scoped, current, inspectable, and resettable.

4. Evaluation and root cause ​

Do not tune before classification.

FailureEvidence firstLikely fix
Wrong API choicePlan/session logInstruction or context fix
Missing toolTool trace/settingsNarrow tool grant
Permission deniedToken/repo/env logsCorrect scope
Secret unavailableEnvironment/fork/secret logsSecret boundary fix
Runner-only failureRunner logsEnvironment fix
Repeated workHandoff/session stateDurable state fix
Security alertCodeQL/secret/dependency scanRemediate code or dependency
Conflicting patchesBranch diffsIsolation and aggregation fix

Eliminate options that:

  • start by disabling scans
  • restart without reading artifacts
  • add permissions without naming the missing permission
  • call every failure a reasoning error
  • call every failure a tool problem

Fast drill: classify ten failures without proposing a fix. Then add the smallest fix.

5. Multi-agent orchestration ​

Multi-agent is not a badge of seriousness. It is a coordination cost.

NeedPattern
One bounded taskSingle agent
Ordered dependencySequential
Independent slicesConcurrent
Specialist routingHandoff
Shared critiqueGroup chat
Broad open-ended programManager-led

Eliminate options that:

  • add agents without a decomposition reason
  • let agents edit overlapping files
  • skip branch or artifact isolation
  • let handoffs loop without routing metadata
  • aggregate by first response instead of evidence
  • restart all work when one lane fails

Fast drill: for any multi-agent answer, say the pattern, ownership boundary, state artifact, and recovery path.

6. Guardrails and accountability ​

Guardrails should match risk.

ActionGate
Draft plan or summarize issueLog, no heavy gate
Create branch and PRChecks and PR review
MergeRequired reviews and required checks
DeployEnvironment required reviewer
Change secrets or permissionsExplicit human approval and audit
Write external production systemNarrow tool plus approval
Delete or disable security controlsHigh-risk review, rollback, audit

Eliminate options that:

  • gate every tiny action equally
  • gate after the irreversible action
  • rely only on agent self-report
  • use broad tokens because the agent is trusted
  • hide the human initiator or session log

Fast drill: list the audit chain for a high-risk agent change without looking: human, session, branch, PR, checks, review, workflow logs, audit event, rollback.

Choose-two traps ​

When the question says "Choose two," expect one answer to be operationally useful but unsafe.

If one option says...Treatment
Store token in memoryEliminate
Disable scan/checkEliminate unless the task is explicitly to test scan config in a safe sandbox
Give org-wide accessEliminate unless the scenario truly needs org-wide read and has approval
Use durable artifactUsually strong
Narrow tool listUsually strong
Require approval before risky actionUsually strong
Classify failure from logsUsually strong
Reset/prune stale memoryUsually strong

Personal study notes written from official documentation. Not affiliated with Microsoft or GitHub. Contains no exam questions.