Claude Opus 4.7 Just Shipped. Here's the Read.

I have been using Claude every day for 18 months. I built Orbyt with it. Two hundred sixty thousand lines of code. One person. Today Anthropic shipped Opus 4.7. Here is what I noticed in the first 8 hours, what is actually different, and what it means if you build software with AI as your primary tool.

This is not a benchmarks roundup. The leaderboards will catch up over the next 48 hours and I will not pretend to have numbers I do not have yet. This is a working engineer's day-one read on the model that is sitting in my IDE right now. The article you are reading was written and shipped using Opus 4.7. That is not a flex. That is the actual context for everything I am about to say.

What we know on day one

The verifiable facts as of today:

• Opus 4.7 is Anthropic's new flagship model, replacing Opus 4.6 at the top of the lineup
• The model identifier is claude-opus-4-7 in the Anthropic API
• It ships with a 1M token context window (the runtime metadata literally exposes claude-opus-4-7[1m])
• It runs in Claude Code (the CLI), claude.ai (web and desktop apps), and the Anthropic API
• Knowledge cutoff is January 2026

I am not going to claim a specific benchmark improvement. I do not have those numbers and I will not invent them. The leaderboards will land soon. What I have is one full day of building production code with the model, which is a different kind of evidence.

What changed in my workflow today

The single most useful change is not raw intelligence. It is the response shape.

Opus 4.7 stays on task longer.

When I hand it a 12-step refactor across 8 files, it executes the whole thing without checking in 4 times asking if I want to proceed. That is not a small thing. The cost of every "do you want me to continue?" interaction is at least 30 seconds of my time, a lost prompt cache, and a refresh of context I had already loaded. Cumulative across a day, that is real money.

It asks for the right files.

When I describe a bug in vague language, Opus 4.7 does not guess. It opens 3 files I would have opened myself, then makes the fix. That used to take 3 turns of back-and-forth where I was naming files and the model was reading them. Now it just goes.

It pushes back. Once. Then it does what I asked.

When I ask for something the model considers wrong (a fragile abstraction, a duplicated component, a security hole, a regex I am about to regret), it says so in one sentence. Then it asks me to confirm. If I confirm, it builds what I asked for. If I take its suggestion, it builds the better thing. The ratio is right. Pre-4.7, that exchange could turn into a 5-message back-and-forth where the model kept hedging.

It writes shorter code review comments and longer code.

This sounds backwards. It is not. Pre-4.7 the response would often be: 200 words explaining the change + 30 lines of code. Now it is: 30 words explaining + 200 lines of code. That ratio matches how I want to work. Tell me what you did, then show me. Skip the philosophy.

The 1M context window. What it really unlocks.

The 1M context number sounds like a marketing point. In daily use it is the difference between "Claude understands the file" and "Claude understands the codebase."

Three things I do today that I could not do well before 1M:

1. Cross-file architectural reasoning in one prompt.

I can drop the entire blog post series (10 posts, ~80,000 words) into context and ask "which post is closest in tone to this draft." It answers in seconds with line-level citations. Pre-1M, this required either summarization steps that lost detail or RAG infrastructure that was overkill for a one-time question.

2. Whole-feature refactors without context juggling.

I paste my 800-line salary calculator + the 600-line FAQ + the 12 related component files and refactor the entire flow in one pass. The model sees the relationships between files because they are all loaded at once. Pre-1M, this had to be split into sub-prompts, and each split was a chance for the model to lose the thread.

3. Schema + routes + tests + migration in one shot.

I hand it the database schema, 4 API route files, the test suite, and the migration file. I ask "what breaks if I add a non-null column to the jobs table." It walks the dependency graph in one response and produces a migration plan that includes the safe-write order, the rollback step, and the test changes I need.

Token math, since people ask: on Opus 4.7's new tokenizer, a 1M context window is roughly 555,000 words of natural language (older Claude models fit about 750,000 words in the same window). Still enough to hold an entire mid-sized codebase in working memory. That is enough to hold an entire mid-sized codebase in working memory.

Where Opus 4.7 fits in the lineup

Anthropic ships three tiers: Opus, Sonnet, Haiku. Each has a job. Here is how I think about model routing today.

The upgrade pattern in my own work has not changed: Sonnet drafts, Opus reviews and refactors, Haiku handles the parsing layer. What changed today is that Opus does more in fewer turns, which means I can hand it bigger chunks of work without breaking them down first.

If you are running an agent stack, today is the day to revisit your model routing logic. The bar for "when to use Opus" moved down because the per-task cost in human attention dropped.

How I am changing my prompts today

Three small shifts that paid off in the first 4 hours.

Less hand-holding.

Pre-4.7, my prompt template was: "first read these three files, then summarize what you see, then propose a plan, then if I approve, make the changes." Five turns minimum. Now I say: "fix this bug, here are the symptoms, here is the file." Opus 4.7 does the right multi-step on its own. One turn.

Bigger context drops.

I used to be careful about how much I pasted because every token I sent was a token of cache I lost when the conversation rolled over. With 1M, I can drop a whole feature folder and let the model reason about it. The cache strategy is different now. The new rule is: load the relevant subsystem in one paste, then iterate on it over many short turns inside the same context window.

Trust the verdict.

When Opus 4.7 says "this approach is fragile, here is a better one," I take it more seriously. Pre-4.7, I would push back almost reflexively because the model was sometimes wrong about my codebase patterns. The hit rate today is higher. I read the alternative first, push back only when I disagree.

A concrete example from this morning

Here is a real workflow I would not have attempted on Opus 4.6.

I had a sitemap drift problem. The marketing site has 14 free tools, each with its own page. The footer has a "Free Tools" column that needs to stay in sync with the sitemap and with the IndexNow ping list. Today I added a new tool (the unemployment calculator we built earlier this week). The footer was missing it. So was the IndexNow registration. So was the sitemap entry.

Pre-4.7 prompt: "Find every place in the codebase where free tools are listed. Show me each list. Tell me which ones are missing the unemployment calculator."

Pre-4.7 response: it would open one file, ask me about another, and we would be at turn 4 before any code changed.

Today's prompt: "Add the unemployment calculator to every place in this codebase where free tools are listed. Use the existing pattern. Make a single coherent commit."

Today's response: Opus 4.7 grepped for the relevant patterns, opened 4 files (footer, sitemap, indexnow route, the /orbyt-jobs/free-tools hub page), made the same kind of edit in all 4, ran a typecheck, and reported back. One turn. About 40 seconds. The code was correct.

That is the new bar.

The cost question, honestly

I do not have official Opus 4.7 pricing in front of me as of this writing. What I know is that on Claude Code, Opus 4.7 access is tied to the Anthropic Pro and Max subscriptions and to API direct billing. If you are doing real engineering work daily, the subscription pays for itself in saved hours within the first week. I am paying for both, because the API rate limits matter when you have agents running.

If you are price-sensitive, the right play is the same as before: drafts in Sonnet, finishes in Opus, parsing in Haiku. The difference today is that more of your "finishes" can stay in Opus because Opus 4.7 takes fewer turns to land.

What this means if you are applying for AI engineering jobs

This part is not optional reading.

Hiring managers in 2026 are not asking "do you know how to use AI." They are asking "what is the highest-leverage thing you have built with AI." If your answer is "I prompt ChatGPT to help me debug," you are below the bar.

The 2026 bar:

• You can drive a flagship model (Opus 4.7, GPT-5, Gemini 2.5) through a multi-file refactor without losing the thread.
• You know which model to pick for which task without having to look it up.
• You can quote at least one architectural decision you made because of how a model behaved (or failed to behave).
• You know what 1M context unlocks and what it does not.
• You have shipped something an LLM helped you build that an experienced engineer respects on inspection.

If that list feels far away, take the AI Skills Assessment to see where you stand against the 4 tiers (Foundations, Practitioner, Builder, Architect). Then start working through the AI Skills Lab modules from your tier up.

If you are sitting at "Practitioner" or "Builder," the new opportunity is real. Companies are hiring AI-fluent engineers faster than they are hiring traditional generalists. The salary delta in our Skills Impact data shows AI-specific skills near the top of the premium ranking.

How to start using Opus 4.7 today

Three steps:

1. In Claude Code (CLI).

If you have Claude Code installed, run claude --model claude-opus-4-7 to pin the new model for a session. The default routing in Claude Code will start using Opus 4.7 on its own within the next few days as Anthropic rolls it out. If you want it now, pin it explicitly.

2. In claude.ai (web and desktop).

It is in the model picker for Pro and Max accounts. Pick it manually for any task that would benefit from longer context, harder reasoning, or multi-file work. It will appear at the top of the model list as "Claude Opus 4.7."

3. In the Anthropic API.

Use model ID claude-opus-4-7 directly in your client. The 1M context is on by default. Adjust your max_tokens upward if you are doing long-form generation. If you are running structured outputs, the JSON mode behavior is the same as 4.6 in my testing today.

If you are building agents or orchestrations, this is the moment to revisit your model routing logic and your eval suite. Run Opus 4.7 side-by-side against your existing pipeline for a week. Then switch.

What I am NOT changing today

A short list, because it matters.

• I am not changing my system prompts on agents that are working well. Test first, switch second.
• I am not raising my temperature settings. The hallucination floor on Opus 4.7 looks similar to 4.6 in my limited testing today.
• I am not migrating my Sonnet-handled tasks to Opus on principle. Sonnet still wins for high-volume work and cost-sensitive paths.
• I am not declaring this the "AGI moment." It is not. It is a working tool that got better.

The bigger picture for AI engineering in 2026

A flagship model release is no longer a curiosity. It is a annual event that shifts the bar on what an AI-fluent engineer is expected to do. Three predictions for the 90 days after a release like this:

1. Recruiter screens will start asking about it.

If you have an interview lined up in the next month at any AI-forward company, you will get asked about Opus 4.7 either directly or indirectly. "What new model are you most excited about" is the modern version of "what is your favorite framework." Have an answer that is more than the marketing copy.

2. Companies will ship features they could not before.

The 1M context jump is not a marketing line for engineering teams. It is a unlock for products that need to reason about whole documents, codebases, or transcripts. Expect a wave of "we now do X across your entire history" features in the next 60 days.

3. The agent market will reshape.

If you are building agents, the math just changed. Tasks that took 5 LLM calls because of context limits can now be done in 1. That is a 5x cost cut for some workflows and a 5x quality jump for others (because each call was losing context at the boundaries). The agent frameworks that adapt fastest to 1M context will win the next 6 months.

Common questions

Is Claude Opus 4.7 better than Opus 4.6?

For the kinds of multi-file engineering tasks I do daily, yes. The model stays on task longer, asks for the right context, and pushes back appropriately without spiraling. I have not seen formal benchmark numbers yet, so I am not going to invent any. What I can say is that my own iteration speed went up today and the number of "stop, let me clarify" turns dropped meaningfully.

Does Opus 4.7 actually have a 1M token context window?

Yes. The model identifier exposed at runtime is claude-opus-4-7[1m], which is the canonical signal for the 1M context variant. You can verify in your own client by inspecting the model metadata when you connect.

When should I use Opus 4.7 vs Sonnet vs Haiku?

Use Sonnet for high-volume drafts, summarization, and well-scoped feature work. Use Opus when the task needs cross-file reasoning, real architectural judgment, or you want the model to disagree with you. Use Haiku for parsing, classification, and labeling at scale where cost matters most. The simple rule: drafts in Sonnet, finishes in Opus, parsing in Haiku.

Will Opus 4.7 replace AI engineering jobs?

No. It will raise the bar for what an "AI-fluent engineer" looks like. The engineers being hired in 2026 are the ones who can drive these models well, not the ones who can avoid them. If anything, model releases like this one increase demand for engineers who know how to wire flagship models into production systems.

How do I get access to Opus 4.7?

Anthropic Pro or Max subscription for claude.ai. API access through console.anthropic.com using model ID claude-opus-4-7. Claude Code is a separate CLI tool that wraps the API and adds file-system tooling, terminal integration, and an agent runtime. All three surfaces are getting Opus 4.7 today.

What is the model card or system prompt strategy I should use?

Same fundamentals as 4.6. Be specific. State what you want and what you do not want. Give the model your conventions. Use XML tags for complex structure. The 1M context lets you include more reference material per prompt, so consider including your style guide, code conventions, and at least one good example in long-context prompts. The "few-shot in the system prompt" pattern is now meaningfully cheaper.

Should I switch all my agents to Opus 4.7 today?

Test first. Even a quality jump can change the shape of agent outputs in ways your downstream code is not ready for. JSON shape, response length, and edge-case handling can all shift slightly between model versions. Run side-by-side against your eval suite for a week, fix what breaks, then switch.

How does Opus 4.7 compare to GPT-5 or Gemini 2.5 for coding?

Honest answer: I have not done a formal comparison today. My bias is toward Claude because it is what I built Orbyt with and what I trust for production code. The flagship models from the three frontier labs are close enough that prompt quality and eval discipline matter more than the choice. Run your actual workload against each for a week and decide on your own evals.

What tools work with Opus 4.7 on day one?

Claude Code (Anthropic's official CLI), the Anthropic API directly, claude.ai web and desktop, and any third-party client that lets you specify a model ID. Cursor, Zed, Continue.dev, and the major IDE integrations all expose model selection. Your existing Anthropic SDK code does not need to change other than the model string.

Is the 1M context window expensive to use?

Per-token pricing is not changing in a structurally surprising way as far as I can tell on day one. The economics depend on how you use it. If you load a 500K-token codebase and then iterate over 50 short turns, you pay once for the load (with prompt caching) and then small per-turn costs. If you load 500K tokens fresh on every turn, you will burn money. Cache aggressively.

What about hallucination rates and safety?

Anthropic's safety posture on Opus 4.7 looks consistent with 4.6 in my limited testing today. The model still refuses what it should refuse, still flags risk, and still wants you to confirm before destructive operations. I have not stress-tested every adversarial case. If you are deploying in a regulated context, do your own red-team pass before shipping.

Where can I see official Anthropic documentation for Opus 4.7?

Check console.anthropic.com for the official model card, pricing, and rate limits. Anthropic typically publishes the model card and a release note simultaneously. As of the time I am writing this, the model is live in the API but the public-facing docs may still be catching up. Refresh the docs daily for the next 72 hours.

The bottom line

Opus 4.7 is not a marginal upgrade. It is the version of Claude where I stop second-guessing the multi-step commands I send it. That is a workflow change, not a feature.

If you build with AI, today is the day to spend an hour rewriting your highest-friction prompts and seeing what happens when you ask the new model to do more in one turn. That single hour will pay you back tenfold over the next month.

I am going back to building. Try it.

Take the AI Skills Assessment to see where you sit against the 2026 bar. Browse the AI Skills Lab for the modules calibrated to your tier. Track your AI-augmented job search inside Orbyt. The tools are here. The bar moved. Go.