GitHub Copilot で /init したら追記しておくインストラクションHigh-autonomy models like Claude Opus 5 and GPT-5.6 in GitHub Copilot can…

GitHub Copilot users who adopt newer, higher-autonomy models such as Claude Opus 5 and GPT-5.6 are running into a subtle trade-off: the more independently these models operate, the more they can overthink. A recent Zenn blog post describes how these models, while more capable of acting on their own, tend to repeat many patterns of self-reflection, which can lead them to deliberate more than a task requires or to introduce inconsistencies. For developers who lean on Copilot throughout the day, that behavior can add friction and make outputs less predictable, which is why the author recommends codifying a few guardrails directly in the project's instruction file.

The root of the issue lies in how the latest reasoning models work. Rather than answering immediately, they plan, critique their own drafts, and revise before returning a result. On difficult problems this self-reflection generally improves quality, but on routine edits the same loops can become excessive. The blog notes that one lever for managing this is "thinking effort," a setting that governs how much internal reasoning a model performs. Turning it down can reduce over-deliberation, but deciding the right level ahead of time is difficult because the appropriate amount of reasoning varies from task to task. As a result, the author argues, the more practical fix is often to add explicit guidance to the prompt itself.

In GitHub Copilot, that guidance lives in .github/copilot-instructions.md, a repository-level file that Copilot reads to shape its responses across a project. Custom instructions of this kind let teams encode conventions, preferences, and constraints once, so they apply to every interaction rather than having to be repeated in each chat. Copilot also offers a /init command that inspects a repository and generates a starter instructions file automatically, giving developers a baseline to build on rather than starting from a blank document.

The blog's central recommendation is to treat that generated file as a starting point and append targeted instructions after running /init. By explicitly telling the model when to stop reflecting, how much to plan, or to avoid second-guessing straightforward changes, developers can rein in the over-reflection that high-autonomy models are prone to. This approach appears to be more reliable than tuning thinking effort alone, because written instructions travel with the repository and apply consistently regardless of which task or which team member invokes Copilot.

The broader context here is the rapid shift toward agentic coding assistants, where models are expected not just to autocomplete lines but to plan multi-step changes and verify their own work. Prompt engineering, and specifically the practice of maintaining instruction files, has become a key way to keep that autonomy aligned with a team's intentions. GitHub is not alone in this: instruction and context files have become common across competing tools, including Anthropic's own Claude-focused tooling and various editor integrations that read project-level configuration to steer behavior. The convergence on repository-scoped instruction files suggests the industry increasingly sees them as the natural place to encode how an assistant should behave.

For teams evaluating these newer models, the takeaway is pragmatic rather than alarming. Higher autonomy is broadly a benefit, and the over-reflection described is a tuning problem rather than a fundamental flaw. Because model behavior can change between versions, instructions that work today may need revisiting as Copilot and its underlying models are updated, so periodically reviewing the contents of copilot-instructions.md is likely to remain worthwhile. Still, the pattern the blog outlines—run /init, review the generated file, and layer in a small set of behavioral guardrails—is a low-cost habit that can make results from Claude Opus 5, GPT-5.6, and similar models noticeably more stable without sacrificing the autonomy that makes them useful in the first place.

For readers new to this workflow, it helps to remember that instruction files are not a replacement for good prompts in individual sessions; they establish defaults that a single request can still override when needed. Kept short and specific, they reduce repetitive typing and give collaborators a shared understanding of how the assistant is expected to work within a given codebase.