Claude Opus 4.7 Best Practices: How to Actually Get the Most Out of the Upgrade

Claude Opus 4.7 shipped on April 16, 2026 with the same price tag as Opus 4.6 and a noticeably better profile on hard software-engineering tasks. The launch covered the what -- xhigh effort, ultrareview, auto mode for Max users, vision up to 2,576 pixels, the first cyber safeguards tier. This guide covers the how. Specifically: how to actually rework your Claude Code workflow to get the gains, grounded in Anthropic's day-of-launch best-practices post, the closest thing to an official playbook, and in what Boris Cherny, the creator of Claude Code at Anthropic, said about learning to work with the model.

The honest framing from Boris himself: "Opus 4.7 feels more intelligent, agentic, and precise than 4.6. It took a few days for me to learn how to work with it effectively." That sentence is the whole article in one line. The model is better, but the workflow needs an upgrade to match.

Key Takeaways

• Detailed plans win. Opus 4.7 follows instructions literally, which means specific plans get specific results.
• Default to xhigh effort in Claude Code. The cost-quality math is meaningfully better than Opus 4.6 at the same effort level.
• Use auto mode + /fewer-permission-prompts together to cut interruption fatigue without losing the safety net.
• Request recaps as the session progresses to keep context clean.
• Focus mode scopes what Claude attends to -- use it for big refactors and complex investigations.
• Make Claude verify its own work. A test command, a build, a check. Opus 4.7 is genuinely better at self-verification than 4.6 was.
• Re-tune your prompts. Anything that worked on 4.6 by being fuzzy may surface edges on 4.7.

The One Thing That Changed Most: Literal Instruction Following

If you only internalize one thing about Opus 4.7, internalize this: Opus 4.7 takes your instructions more literally than Opus 4.6 did. Anthropic flagged this in the launch post, its best-practices post says a few prompt and harness tweaks make a big difference when replacing 4.6, and every team that has spent a few days with the model has noticed it.

Concrete example. A common Opus 4.6 prompt was something like "go through the auth module and clean it up". On 4.6, Claude would interpret "clean it up" charitably -- improve naming, factor common helpers, add tests where missing. On 4.7, "clean it up" is parsed more narrowly: it might rename a few variables and stop, because that is what the literal phrase asks for. The fuzziness that masked sloppy prompting on 4.6 is gone on 4.7.

The practical fix is not to write longer prompts -- it is to write more specific ones. "Go through the auth module and: rename single-letter variables to descriptive names, factor any duplicated session-validation logic into a single helper, and add tests for any function with no existing test." That is the same intent, made literal. Opus 4.7 will execute it cleanly.

This is also why detailed plans win on Opus 4.7. The claudefa.st guide on Opus 4.7 best practices puts it bluntly in its title: "Detailed Plans Win". The pattern Anthropic's post recommends (specify the task up front, with intent, constraints, acceptance criteria, and file locations) -- and that the strongest teams have converged on -- is to spend an extra two minutes writing a multi-step plan up front, hand it to Claude, and watch it execute the plan reliably. That trade is wildly favorable: a few extra minutes of planning replaces twenty minutes of corrections.

How to actually write a detailed plan

A plan that works for Opus 4.7 reads like a set of acceptance criteria, not a set of feelings. The structure that has emerged:

1. State the goal in one sentence. "Refactor the auth module so that all session validation goes through a single validateSession helper."
2. List the files that should change (or "find them yourself", with a rule for what makes a file in scope).
3. List the constraints. "Do not touch the JWT signing logic. Do not change any public API surface. Run npm test after each file change and revert if a test fails."
4. Specify the verification step. "When done, run npm test, paste the output, and confirm all auth tests pass."
5. State the failure mode. "If you cannot complete the refactor without breaking a test, stop and explain what blocked you."

That structure takes maybe two minutes to write. Opus 4.7 will execute it cleanly because there is no ambiguity to interpret. Opus 4.6 would have done the same work but with more drift; Opus 4.7 does it without drift, which is the point.

Pick the Right Effort Level (and Default to xhigh)

Opus 4.7 introduces xhigh, a new effort level that sits between high and max. Claude Code defaults to xhigh on all plans now, which is significant -- the previous default was high. Anthropic's recommendation, and the consensus from the first week of usage:

• Default to xhigh for coding and agentic work. The token cost is meaningfully higher than high but the quality improvement is sharp.
• Reach for max only when the problem warrants it (the hardest debugging sessions, the gnarliest refactors). The cost jump from xhigh to max is real and most tasks do not need it.
• Drop to high or medium for trivial work where you do not need extended thinking (renaming variables, applying a known transformation, documenting an existing function).

The non-obvious move is to be deliberate about effort selection per turn. The default is fine for most, but a power user who flips between effort levels based on the task will get more out of the model than someone who picks once and never adjusts. Effort is the parameter, not a setting.

A working rule of thumb:

Auto Mode + /fewer-permission-prompts: The Real Productivity Combo

Auto mode is the headline change for permission management. It is the difference between "Claude asks you before every action" and "Claude decides which actions are safe to run without asking". With Opus 4.7, auto mode is now available to Max users (it was previously gated higher), which is the meaningful access change.

Auto mode is not zero-permission. It uses Claude's judgment about which actions are clearly safe (read-only operations, file edits inside the project, running tests) versus which need a check (deleting files, running external commands, hitting the network). The result for most users is a session that runs three to five times faster because you are no longer clicking "yes" on every read.

The companion is /fewer-permission-prompts, a Claude Code skill that further trims prompts on actions Claude assesses as low-risk. Together they produce a noticeable change in how a session feels:

• A typical Opus 4.6 session with default settings might prompt 30 times across a 30-minute task.
• The same task on Opus 4.7 with auto mode + /fewer-permission-prompts prompts maybe 5 times -- and only on actions that genuinely deserve a check.

The trade-off is that you are trusting Claude's judgment more. Pair it with two safeguards:

1. Always work in a clean git state. If something goes wrong, git stash or git reset is your undo button. Do not run auto mode on top of uncommitted work you cannot afford to lose.
2. Read the action log periodically. Claude Code shows you what it did. Skim the log every few minutes, especially the first week. If something looks off, that is the moment to dial back.

For most teams, the right configuration after a week of practice is auto mode + /fewer-permission-prompts as the default, with explicit --ask for sensitive workflows.

Recaps: The Underused Context Discipline

A recap is a turn where you ask Claude to summarize what it has done so far in the session. Anthropic's best-practices post does not cover recaps; we recommend them as a regular discipline, and the Claude Code context management guide covers the underlying mechanics.

The pattern: every 10-15 turns, or after any significant chunk of work, ask Claude:

Recap what we have done in this session, what is currently in progress, and what is left to do.

What that produces:

• A clean summary of the work, written by the model that did it (often catching things you would forget).
• An anchor point for /compact -- the recap can be the input to a deliberate compaction.
• A natural decision point: continue in this session, or /clear and start fresh with the recap as the brief.

Recaps are valuable specifically because Opus 4.7 is better at long-running work. The 1M context window means sessions can run for hours; the recap discipline keeps that long context coherent rather than letting it rot.

Focus Mode: Scope What Claude Attends To

Focus mode tells Claude to concentrate on a specific subset of files or a specific task, ignoring the rest of the context. This is the right tool for big refactors where the wider codebase context would otherwise pollute attention.

The prompt pattern:

Enter focus mode for the auth module: src/auth/, tests/auth/, and docs/auth.md. Ignore all other files for the rest of this session unless I explicitly mention them.

Why it matters: even with 1M context, attention is not uniform. A model "looking at" a million tokens does not weight all of them equally. Focus mode is a way to tell the model what to weight heavily and what to ignore. For tasks that span 5-10 files, focus mode produces measurably tighter results than the same task without scoping.

Make Claude Verify Its Own Work

Opus 4.7 is genuinely better at self-verification than 4.6 was: the claudefa.st guide reports that Anthropic recommends stripping "double-check" scaffolding from prompts because 4.7 now self-verifies natively, and quotes Intuit describing the model "catching its own logical faults during the planning phase". Anthropic's own best-practices post does not spell out a verification step, so this is our recommendation: always give Claude a way to verify the work it just did. The structure:

1. State the work to be done.
2. State what success looks like.
3. State the verification step (a test command, a build, a check).
4. After the work, run the verification.
5. If it fails, fix and re-verify.

The verification step is what closes the loop. Without it, Claude finishes and you take its word for it. With it, Claude finishes and proves the work, then you trust the proof. The best practice is to bake verification into every non-trivial prompt:

Implement the new rate limiter as specified. Verification: npm test rate-limiter should pass with all tests green. After implementation, run the test, paste the output, and confirm the verification passes before declaring the task done.

This pattern works because Opus 4.7 is meaningfully better at staying honest about its own outputs than prior models were. It will run the test, see the failure, fix the cause, re-run. The trust loop is tight.

The complementary pattern is the ultrareview, which shipped alongside Opus 4.7. Updated August 15, 2026: the command is now /code-review ultra, with /ultrareview kept as an alias when the feature is available to your account. Two things about it matter more than the name, and neither was clear at launch. It is a research preview that runs in a cloud sandbox rather than in your local session -- a fleet of reviewer agents explores the change in parallel and independently reproduces each finding, which takes roughly 5 to 10 minutes. And it bills usage credits rather than counting toward your plan: Pro and Max accounts get three one-time free runs that do not refresh, Team and Enterprise accounts get none, and after that a review costs roughly $5 to $25 depending on the size of the change. It is also unavailable on Amazon Bedrock, Google Cloud's Agent Platform, and Microsoft Foundry, and to organizations with Zero Data Retention enabled, where /code-review ultra falls back to a local review.

The practical upshot: treat it as a deliberate pre-merge spend on a substantial change, not as a habit after every chunk of work. For the routine second opinion, the local /code-review counts toward normal usage, runs in seconds to a few minutes, and takes a working diff, a pull request, a branch, or a path. The subagent patterns guide covers when a custom reviewer definition beats either.

Your Migration Playbook From Opus 4.6

If you are coming from a working Opus 4.6 setup, the migration is small but worth doing deliberately. The five-step playbook:

1. Re-read your most-used prompts. Specifically the ones that worked on 4.6. Replace fuzzy language with specific language. "Clean it up" → "rename single-letter variables and factor common helpers". "Make it better" → "add unit tests for these three functions".
2. Switch to xhigh as the default. Claude Code does this automatically; if you have your own scripts that pin effort, update them.
3. Turn on auto mode + /fewer-permission-prompts for trusted workflows. Leave permission prompts on for anything sensitive.
4. Add verification steps to your common prompts. Pick the three or four prompts you use most and add the "verification: ..." line.
5. Adopt recaps as a discipline. Every 10-15 turns, ask for a recap. Use the output to decide whether to continue, compact, or clear.

That migration takes maybe an hour. The payoff is that the workflows you already have keep working, and the model improvements actually show up in your output rather than being silently absorbed by sloppy habits.

What This Looks Like in Your First Week

A realistic first week with Opus 4.7, day by day:

• Day 1. Update Claude Code, run a normal session, notice that defaults changed. Skim the launch post and Anthropic's best-practices post.
• Day 2. First time the model takes a prompt more literally than expected. Decide to start writing more specific plans.
• Day 3-4. Try auto mode on a low-stakes task. Notice the difference. Add /fewer-permission-prompts.
• Day 5. Add verification steps to your three most-used prompts. Watch them succeed cleanly.
• Day 7. Recaps become a habit. Sessions feel cleaner. You realize you have not had to "correct" Claude on the same issue twice in days.

By end of week two, the workflow is internalized. The model's improvements -- the tighter following, the longer agentic runs, the better self-verification -- are the things you noticed; the workflow upgrades are the things that let you actually feel them.

The full Opus 4.7 launch coverage is in our launch news article; for context-management specifics that pair with these practices, see our Claude Code context management guide.