A developer is changing an invoice calculator. An inline suggestion completes the next line, Chat explains the existing rounding logic, and an agent proposes edits across three modules. These are different degrees of assistance and different risks. For a two-line formatting fix, automatic multi-file changes may add unnecessary review work. For a coordinated interface migration, accepting isolated suggestions without considering callers can leave a broken repository. Choosing the right Copilot surface is an architectural judgment about scope, context, and the evidence needed to accept a change.
The current GH-300 exam scope explicitly covers inline suggestions, chat, Copilot Edits and agent mode. A feature’s name and availability can vary by IDE, version, organization policy, and plan; the core distinctions are more durable than button locations. Study how a developer keeps control of context and changed files instead of assuming an agent’s wider scope automatically makes it a better programmer.
Use inline suggestions for bounded local intentions
Inline suggestions work well when the intended code shape is already clear: a small conditional, repetitive mapping, or conventional invocation. The developer sees the suggested continuation in the surrounding file and decides whether to accept it. A suggestion can be syntactically plausible yet semantically wrong, especially when the nearby code hides an important invariant or authorization rule.
For an invoice calculation, inspect currency precision, negative values, tax exemptions, and rounding at line-item versus order total level. Accepting a neat-looking calculation without checking those constraints could silently change invoices. The fastest workflow is often to accept only the useful fragment, add a focused test, and avoid promoting autocomplete into proof of correctness.
Ask Chat for reasoning that you can verify
Chat can explain unfamiliar code, suggest an implementation plan, help interpret error messages, and compare alternatives. Effective questions include the relevant function, expected behavior, restrictions, and a request for assumptions. If the assistant describes a database transaction as atomic, confirm that claim against the actual driver, isolation mode, and surrounding application code. A conversation is not a substitute for observing runtime behavior.
A useful comparison asks Chat to produce two candidate approaches and list when each fails. For example, should the invoice service round values on the server or trust a client-supplied total? The reviewer can test both against the signed contract. This uses AI to expose trade-offs while retaining a human source of authority.
Give agent mode a constrained, reviewable task
IDE agent mode can inspect project files, plan changes, and use supported tools. That broader reach is appropriate when a refactor requires updates to implementation, callers, documentation, and tests. Begin with the precise target, prohibited directories, required interfaces, and how success will be assessed. Ask it to show intended edits before making broad changes when the environment supports that workflow.
For an invoice-module rename, first inspect which services call the old interface. Specify that database migrations and production configuration are out of scope. Review the resulting diff for unrelated formatting churn, renamed public exports, or unintentionally weakened tests. The GitHub Copilot cloud-agent workflow addresses an adjacent but distinct setting: delegated work on a repository branch, rather than edits occurring directly in the local IDE.
Separate working-directory trust from content trust
A tool's permission to read a workspace does not mean every README, dependency file, or generated comment is trustworthy instruction. Repository content may include stale directions, malicious prompt injection, or examples containing secrets. A developer should preserve the user’s original request as the governing goal and critically inspect lower-trust material encountered during tool use.
Suppose an agent reads a vendor file that says “disable static analysis to finish faster.” That instruction is not an approved project requirement. Keep test and security gates independent of text encountered in the repository. The broader prompt-injection threat model explains why content entering an AI workflow should not automatically gain authority over tools or data.
Understand context windows and changed-file scope
An assistant sees only the context made available to it: selected code, relevant open files, search results, history, and permitted tool output. If a requirement is stored in a file the assistant has not read, the response can be incomplete. Instead of demanding a perfect answer from vague context, include representative tests, public interfaces, code conventions, and the particular error that needs explanation.
Context should also be minimized. Sending an entire proprietary repository to answer a narrow serialization question may be inappropriate, and large unrelated context can obscure the main constraint. A good agent prompt identifies the expected files and tells the assistant which conclusions require searching rather than assumption. The context-engineering article develops that technique with concrete prompts.
Control the quality of generated changes
Do not treat a visually convincing diff as completed engineering. Validate compile or type-check results, unit tests, dependency compatibility, security scans, and representative negative paths. Ensure that generated tests assert business behavior rather than simply mirror the implementation. If the assistant modifies both a defective function and its tests in the same incorrect way, green tests may provide false confidence.
A practical exercise starts with a known defect, asks Chat to identify it, then lets an IDE agent propose a fix. Compare the proposed diff with an independent regression case prepared before the fix. Measure correctness and review scope, not number of generated lines. The developer remains accountable for accepting or rejecting every change.
Choose the simplest tool for the next action
If the developer already knows the change, inline completion may be fastest. If the developer needs an explanation, Chat can help narrow the uncertainty. If the task requires coordinated edits with tests, agent mode may reduce manual search and editing effort. If the work needs isolated execution against an issue and a pull-request review, a cloud agent may fit better. These are selection criteria, not a universal progression from less to more powerful automation.
GH-300 candidates should practice explaining the failure modes of each surface. A tiny edit that unexpectedly touches twenty files is review debt; a large migration attempted through one-line autocomplete can miss dependency changes. Use the tool that matches the task boundary, retain control of approvals, and demand evidence that the resulting software still meets its contract.