Every time Anthropic releases a new model, I do what Dan Shipper calls a "vibe check" - I test it, break it, see what actually changed. This morning, Dan was doing his own live vibe check on Every with Alex Albert from Anthropic. I've been following Dan and Every for two years and doing mine at the same time felt pretty surreal.
I'm still reviewing Opus 4.7 and plan to keep testing over the next few days. But here's what I can tell so far.
It talks different now
The first thing you notice is the tone. Opus 4.7 is more direct. It skips the "Great question!" phrasing, the filler, the validation-forward warmth that Opus 4.6 had. It calibrates how much it says based on how complex the task actually is - short answers for simple lookups, longer ones for open-ended analysis.
It takes your instructions literally. If you tell it to do something specific, it does exactly that. No silent generalizing, no inferring requests you didn't make. For anyone running custom workflows with CLAUDE.md files or agent systems, this is a big deal.
It also spawns fewer subagents by default and reasons more on its own. The overall feeling? It behaves more like a senior engineer - less hand-holding, more execution.
It asks deeper questions now
Opus 4.7 is more contextual and more precise. It carries context across sessions better than 4.6 did.
The file-system memory improvement is real. It writes better notes to itself and - this is the important part - actually uses them next time. If you've built any kind of memory or scratchpad system, your agent should get noticeably better at leveraging it.
Less babysitting overall. You can hand off harder tasks and trust that it stays on track.
What I can do better now
Not the benchmark numbers - what the model actually lets you do differently in your work. I spent this morning testing Opus 4.7 on my actual setup (100+ MCP tools, 660+ memories in Supabase, custom skills) and these are the differences I felt.
Hand off harder tasks
Task budgets are new and genuinely useful. You can tell the model "you have 128k tokens for this entire agentic loop" and it self-paces. It sees a running countdown and uses it to prioritize work, then finishes gracefully as the budget runs out. Less micromanaging, more shipping.
This is not a hard cap - it's advisory. The model is aware of it and plans around it. Think of it as giving a contractor a budget instead of approving every purchase.
I tested this on a research task that would normally take multiple back-and-forth messages to scope. It managed its own depth instead of going too deep on the first subtask and running out of steam.
Catch bugs before they ship
/ultrareview is new and impressive. It sends a fleet of agents to review your code in parallel - each one looking from a different angle. The key insight: finding bugs and confirming bugs are two different tasks. Regular review bundles them together. Ultrareview separates them.
According to Anthropic's release data:
| Metric | Result |
|---|---|
| Large PRs (1000+ lines) with findings | 84% |
| Average issues found per large PR | 7.5 |
| False positive rate | Less than 1% |
| Average review time | ~20 minutes |
| Cost | $15-25 per review |
| Free trial | 3 reviews for Pro and Max |
Large PRs (1000+ lines) with findings
84%
Average issues found per large PR
7.5
False positive rate
Less than 1%
Average review time
~20 minutes
Cost
$15-25 per review
Free trial
3 reviews for Pro and Max
One example from their testing: a one-line change that would have broken authentication in production. That's the kind of thing human reviewers miss when the diff looks small.
Work beyond code
Alex Albert confirmed on the live vibe check: spreadsheets and presentations got a real upgrade. This isn't just about coding anymore.
The knowledge work improvements:
- .docx redlining and tracked changes
- .pptx editing and layout self-checking
- Chart and figure analysis with pixel-level data transcription
- Programmatic image processing with libraries like PIL
If you've been using Claude primarily for code, it might be time to test it on the rest of your workflow.
See more, read more
Opus 4.7 supports 3x the image resolution of previous models - 2576 pixels on the long edge, up from 1568. That's about 3.75 megapixels.
The practical impact: better screenshot understanding, better document analysis, better computer use. And coordinates returned by the model are now 1:1 with actual pixels - no more scale-factor math.
The trade-off: full-resolution images can use up to 3x more tokens per image (up to 4,784 tokens vs the previous ~1,600 cap). If you don't need the extra fidelity, downsample before sending.
The new effort levels
Opus 4.7 introduces xhigh - a new effort level between high and max. It's the new default for Claude Code across all plans.
Here's how to think about effort levels now:
| Level | Best for |
|---|---|
| max | Intelligence-demanding tasks (may overthink) |
| xhigh | Coding and agentic work (new sweet spot) |
| high | Balanced token usage and intelligence |
| medium | Cost-sensitive, trades off intelligence |
| low | Short scoped tasks, latency-sensitive |
max
Intelligence-demanding tasks (may overthink)
xhigh
Coding and agentic work (new sweet spot)
high
Balanced token usage and intelligence
medium
Cost-sensitive, trades off intelligence
low
Short scoped tasks, latency-sensitive
Effort matters more on this model than any previous Opus. At low effort, it scopes its work strictly to what was asked. At xhigh, it goes deeper and uses more tools. Experiment with it.
Things that will break your code
This is the section for anyone running Claude on the API. There are real breaking changes:
Extended thinking is gone. Setting thinking: {type: "enabled", budget_tokens: N} returns a 400 error. Switch to adaptive thinking and use the effort parameter instead.
Sampling parameters are gone. Setting temperature, top_p, or top_k to any non-default value returns a 400 error. Prompting is the only knob now.
Thinking content is hidden by default. Thinking blocks still appear in the stream, but their content is empty unless you opt in with display: "summarized". If your UI streams reasoning to users, the new default will look like a long pause.
New tokenizer. Same text can produce up to 35% more tokens. Re-benchmark your costs. Update your max_tokens parameters.
Prefill still gone. Carried over from 4.6.
The migration checklist from the docs is straightforward. But the real checklist? Test your prompts at xhigh effort before you swap the model ID. The literal instruction following means prompts that worked on 4.6 might behave differently.
The honest part
Every upgrade has trade-offs. Here are the ones worth knowing:
| What changed | Impact |
|---|---|
| New tokenizer | Same text costs up to 35% more tokens |
| High-res images | Up to 3x more image tokens per image |
| Literal instruction following | Old prompts might break |
| More direct tone | Re-tune your voice prompts |
| Cyber safeguards | Some security-related requests may get refused |
New tokenizer
Same text costs up to 35% more tokens
High-res images
Up to 3x more image tokens per image
Literal instruction following
Old prompts might break
More direct tone
Re-tune your voice prompts
Cyber safeguards
Some security-related requests may get refused
The tokenizer increase is the one to watch. If you're running heavy workloads on the API, re-benchmark before switching.
Worth it?
For builders, absolutely.
The combination of task budgets + literal instruction following + better memory means you can hand off genuinely hard work with less supervision. That's the real upgrade - not a benchmark number, but the feeling of trusting the model to stay on task.
I'll keep testing and share more as I go. If you're migrating, start with the effort parameter. That's where the biggest behavior differences live.