Claude Opus 4.7 Best Practices: Detailed Plans Win

Opus 4.7's biggest shift is not raw intelligence. It is literalism. The model does exactly what you tell it, which punishes vague prompts and rewards detailed plans. Boris Cherny from Anthropic put it plainly: "it took a few days for me to learn how to work with it effectively." Most users will notice the same thing. Prompts that produced clean output on 4.6 now generate narrower, more literal results unless you restructure how you brief the model.

This post pairs Anthropic's best-practices guidance for Opus 4.7 with the upgrades we shipped in ClaudeFast v5.2 this week. Most of the changes in the Code Kit pipeline were designed for exactly this kind of model, one that rewards explicit plans, clear acceptance criteria, and tight scoping.

What Actually Changed for Practitioners

The headline benchmark numbers for Opus 4.7 are useful, but four behavioral changes matter more for day-to-day Claude Code work:

Stricter instruction-following. Opus 4.7 interprets instructions more literally than 4.6. Notion found it was the first model to pass their implicit-need tests. The flip side is that prompts relying on the model to fill in context now underperform.

More selective subagent spawning. The default favors doing work in one response over fanning out. If you want parallelization, say so explicitly.

Adaptive thinking. Fixed thinking budgets are gone. The model decides how long to reason based on context. You influence it by prompting: "think carefully before responding" for more, "prioritize responding quickly" for less.

New xhigh default. The effort scale now runs low, medium, high, xhigh, max. Claude Code defaults to xhigh, which sits between high and max and gives most of the reasoning depth without the full cost of max.

Anthropic's framing: treat Claude like a capable engineer you are delegating to, not a pair programmer you are chatting with. Front-load intent, constraints, acceptance criteria, and file paths. Batch your questions. Every user turn adds reasoning overhead.

The Detailed Plan Is the New Prompt

The single biggest leverage point for 4.7 is a well-scoped plan. Anthropic is explicit about this: include intent, constraints, acceptance criteria, and relevant file paths in the first turn. Stricter instruction-following means a plan with 12 acceptance criteria produces 12 checked items. A plan with vague intent produces a vague implementation.

This is exactly what the /team-plan → /build pipeline in ClaudeFast v5.2 is built for. The pipeline auto-detects session type (Development, Debugging, Migration, Review, TDD, Research, Growth, Repo-Port) and loads the matching protocol with tailored quality gates. The output is a plan file in .claude/tasks/ that captures:

• Intent and scope boundaries
• Relevant files with line numbers
• Acceptance criteria per task
• Specialist agent assignments
• Verification steps before completion

Three v5.2 upgrades tighten this loop specifically for 4.7:

Mandatory plan reading. Every sub-agent dispatched by /build must read the full plan file as its first action. On 4.6 you could get away with agents working from a task summary. On 4.7, literal interpretation means sub-agents drift without the full context. Mandatory reading eliminates that drift.

Verification Before Completion. Sub-agents verify their work against acceptance criteria before marking tasks complete. This mirrors Opus 4.7's native self-verification behavior, which Intuit described as "catching its own logical faults during the planning phase." The plan file becomes the checklist the model verifies against.

Assumption surfacing. Moderate and complex tasks now state key assumptions before implementing. If multiple valid approaches exist, the model presents options rather than choosing silently. This matches 4.7's strictness, it will choose silently only when given permission to.

Large refactors get an additional hook. CodeStats, the new codebase intelligence CLI in v5.2, feeds dependency graphs, hotspot scores, and blast radius analysis into the plan before any code is written. The model now starts with structural context that used to require several exploratory turns. Combine this with ultraplan for architectural work and you have a briefing document that 4.7 can execute literally.

Effort Levels Are a Dial, Not a Default

Opus 4.7's effort levels respond to your task, not your session. Anthropic recommends xhigh as the starting point for most agentic coding but explicitly mentions toggling during a task to manage token usage.

A practical recipe for long development sessions:

Switch with /effort xhigh mid-session. Existing users without a manually set effort level were auto-upgraded to xhigh when 4.7 shipped.

The updated tokenizer is worth noting. The same input may map to roughly 1.0 to 1.35x more tokens than 4.6 depending on content type. Combined with deeper reasoning at higher effort, sessions run hotter. Task budgets (public beta) and conciseness prompting are the main controls.

Subagent Selectivity Is a Feature When Your Plan Is Explicit

4.7 spawns fewer subagents by default. Anthropic's framing: "Do not spawn a subagent for work you can complete directly in a single response. Spawn multiple subagents in the same turn when fanning out across items."

This matters for anyone using the Code Kit's 16 specialized agent teams. The v5.2 pipeline makes deployment explicit rather than implicit:

1. /team-plan outputs a plan file with specialist assignments per task
2. /build dispatches each specialist with mandatory plan reading
3. Each specialist reads the full plan, runs its scoped work, and uses TaskUpdate to mark completion
4. Quality-engineer validation fires sequentially against each build

The shift from "agent chooses when to spawn" to "plan specifies who runs what" is the right fit for 4.7. The model respects the plan. Specialists stay in their lanes. Parallel specialists run concurrently while validation gates sequentially through addBlockedBy dependencies.

If you want more subagents, say so. Positive framing outperforms negative on 4.7 per Anthropic's guidance: use positive examples of desired voice rather than negative don't-do-this instructions. A prompt like "spawn a specialist for each of: frontend, backend, database" outperforms "don't try to do this in one response." This applies to all sub-agent best practices with the new model.

Auto Mode + xhigh + team-build: The Long-Running Combo

Anthropic's recommendation for trusted long-running tasks is auto mode combined with xhigh. This is the golden path in v5.2 for multi-hour agentic sessions.

The supporting infrastructure in v5.2 was tuned for this exact workload:

• Early context backups. The Context Recovery Hook now fires its first backup at 50k tokens used, then every 10k after. On 1M context, this triggers long before percentage-based thresholds would.
• Backup compactor. After 14 days, individual session backups compact into 7-session summaries with claude --resume commands preserved. Subscription-only cost, no API charges.
• Peak/off-peak awareness. The StatusLine shows Off-peak (2d4h30m) in green or Peak (1h15m) in red with countdown. Anthropic confirmed peak hours (weekdays 8AM-2PM ET) drain sessions faster, valuable information when planning a long session.
• LibraryHook. Auto-syncs library-managed file edits back to your central library with a 180-second debounce. Detached workers survive session close, so long-running work does not lose config changes.

Practical rhythm: plan at xhigh, flip on auto mode, let the team build, check in at natural stopping points. Cognition (Devin) reports 4.7 "works coherently for hours, pushes through hard problems." That behavior only surfaces when you stop interrupting it mid-flow.

Migrating Prompts from 4.6

The specific updates that paid off when we retuned Code Kit for 4.7:

1. Convert implicit context to explicit. If a prompt worked because 4.6 inferred "obviously you also want tests," add tests to acceptance criteria for 4.7.
2. Replace don't-do-this with do-this. Negative instructions produce unreliable results. Positive examples match intent directly.
3. Be explicit about parallelism. If you want multiple agents, state the fan-out pattern. 4.7's default is single-response.
4. Batch questions into single turns. Every user turn adds reasoning overhead. Three related questions in one turn beats three sequential turns.
5. Front-load file paths. The model processes paths literally. Passing apps/web/src/app/(home)/page.tsx saves two tool calls versus "the homepage file."

For anyone running the ClaudeFast Code Kit or the Complete Kit, the v5.2 upgrade already applies these patterns in the planning pipeline. If you are building your own workflow, the core idea is simple: write the plan you wish the model would infer, then let the model execute it.

What's Next

4.7 rewards operators who invest in planning. The model does not need less guidance than 4.6, it needs better-scoped guidance. Every hour spent on a detailed /team-plan output pays back across the execution phase because the model holds the plan literally instead of loosely.

If you have not switched yet:

claude config set model claude-opus-4-7
/effort xhigh

Then point it at a plan and let it run.