Verdict: Yes — Claude Opus 5 ships one-shot 3D application builds that hold their own against frontier models costing twice as much, and it is the sensible default for high-volume agentic coding work as of late July 2026. The model launches at $5 per million input tokens and $25 per million output tokens (Anthropic, July 24, 2026), identical to its predecessor Opus 4.8 and exactly half of Claude Fable 5's $10/$50 rate. On the benchmarks that matter for builders — SWE-bench Verified, Frontier-Bench, CursorBench 3.2, and ARC-AGI-3 — it now either leads or sits within a rounding error of the most expensive Anthropic model, while being cheaper to run. The honest caveat: one-shot tests, the kind of single-prompt "build me a game" evaluation popular on YouTube right now, are a useful vibes-check, not a substitute for a real benchmark harness. Below is the method to do it right, what the verified numbers actually say, and a rubric you can reproduce.
Last verified: 2026-07-30 · Primary keyword: Claude Opus 5 one-shot build test
- Opus 5 launched July 24, 2026 at $5/$25 per million tokens — half of Fable 5.
- SWE-bench Verified: Opus 5 leads at 97.0%, ahead of GPT-5.6 Sol (96.2%) and Fable 5 (95.0%).
- CursorBench 3.2: Opus 5 within 0.5 points of Fable 5's peak, at roughly half the cost per task.
- ARC-AGI-3: Opus 5 scored 30.16% — about 3× the next-best model.
- Prices and limits are volatile — re-check before you commit to a build pipeline.
Why one-shot "build me an app" tests are a useful (vibes) sanity check
A one-shot build test is exactly what it sounds like: you give a model a single prompt — "build a 3D driving game with working physics, a track, and lap timing" — and you inspect what comes back without iteration. It is the test of a model's first-move quality. Recent hands-on evaluations of Opus 5 have used exactly this approach, asking the model to one-shot a driving game, a dragon-flight game, a 3D snake, an open-world RPG, a flight simulator, a neon racing game, and a top-down arcade blaster, then comparing the output side by side against Claude Fable 5, GPT-5.6 Sol, and Kimi K3.
What you actually learn from a one-shot test, in order of importance:
- Detail and polish on first contact — does the rendered scene have a coherent look, proper lighting, readable text, and reasonable physics, or does it look like a placeholder?
- Instruction adherence — did it implement everything you asked, or silently drop half the requirements?
- Plan-before-write behavior — did it structure the code, isolate concerns, and scaffold assets, or dump a single file of tangled logic?
- Failure modes — where does it break? Inconsistent controls, broken physics, missing collision, dead UI?
These are genuinely useful signals because they are signals the model exhibits before a human can correct it — and agentic coding tools spend most of their tokens on first attempts. As an Anthropic customer noted in the official launch announcement, "the best animations, games, and 3D work we have seen from an Opus model" came from Opus 5 (Anthropic, July 24, 2026). That is exactly the kind of first-move quality one-shot tests surface.
What one-shot tests are not: a replacement for SWE-bench or a multi-turn agent harness. They tell you nothing about long-horizon reasoning, test-suite construction, or how a model recovers from its own mistakes — and those are the skills that determine whether an autonomous coding agent finishes a feature. For a fuller treatment of when to use a single agent versus a slow multi-turn one, see our single-agent vs multi-agent decision framework.
How much does Claude Opus 5 cost?
Claude Opus 5 is priced identically to Claude Opus 4.8 and at exactly half the per-token rate of Claude Fable 5. Here is the comparison built from Anthropic's own published pricing page and the launch announcement (Anthropic, July 24, 2026):
| Model | API model ID | Input / MTok | Output / MTok | Context | Max output | Notes |
|---|---|---|---|---|---|---|
| Claude Opus 5 | claude-opus-5 |
$5 | $25 | 1M | 128K (300K via Batch API) | New default on Claude Max; strongest on Claude Pro |
| Claude Fable 5 | claude-fable-5 |
$10 | $50 | 1M | 128K (300K via Batch API) | Frontier tier; safety-classifier fallback to Opus 4.8 on cyber/bio tasks |
| Claude Opus 4.8 | claude-opus-4-8 |
$5 | $25 | 1M | 128K | Legacy; still callable as fallback |
| Claude Sonnet 5 | claude-sonnet-5 |
$3 | $15 (intro $2/$10 through Aug 31, 2026) | 1M | 128K | Mid tier for high-volume work |
Opus 5 also ships a Fast mode that runs at roughly 2.5× the default speed for double the base price ($10/$50 per million tokens), and an adjustable effort setting that scales from low through high, xhigh, and max. The new xhigh effort level — above high, below max — targets agentic runs lasting 30+ minutes and actually outperformed max on Frontier-Bench v0.1 (Anthropic, July 24, 2026). For a walkthrough of how to route Opus 5's effort levels and Fast mode into a working agent stack, see our dedicated Opus 5 routing guide.
What the verified benchmarks actually say (the part no video explains)
Video build tests are fun to watch, but the published benchmarks are where the load-bearing claims live. Here are the ones that matter for builders, with their primary sources. Every number below was independently verified against the original benchmark runner, not Anthropic's marketing.
SWE-bench Verified is the standard test of "can the model resolve a real GitHub issue and produce a patch that passes unit tests." Vals AI runs it on a uniform minimal bash-only harness to keep comparison fair. As of late July 2026, Opus 5 leads at 97.00%, ahead of GPT-5.6 Sol (96.20%), Claude Fable 5 (95.00%), and Kimi K3 (93.40%) (Vals AI, SWE-bench Verified leaderboard). The 15-minute-to-one-hour task bracket — the largest segment and the most differentiating one — is where Opus 5 separates from the pack. Opus 4.8 by comparison scored 88.60% on the same harness, so the gap to the prior Opus is real.
CursorBench 3.2 is Cursor's independently measured in-editor coding benchmark. Fable 5 leads the published snapshot at 70.5%, with Opus 5 second at 70.0% (BenchLM, CursorBench leaderboard). That is a 0.5-point gap on raw score, but at roughly half the cost per task. Anthropic's own framing: at max effort, Opus 5 performs within 0.5% of Fable 5's peak, and it beats every other model on the same cost on high, xhigh, and max effort levels (Anthropic, July 24, 2026). For a complete benchmarks and pricing teardown, our developer verdict guide goes deeper.
ARC-AGI-3 is the reasoning benchmark for genuinely novel problem-solving — the one most resistant to benchmark memorization. ARC Prize verified Opus 5 at 30.16% on the High reasoning effort variant, the highest score ever recorded on the benchmark, roughly 3× the next-best model, with five additional Public Demo environments solved that no prior model had beaten (ARC Prize, Claude Opus 5 results). Because of a short testing window, ARC-AGI-3 was only evaluated at the High effort level — the max effort score is not yet on record. Treat the 30.16% as a floor, not a ceiling.
Frontier-Bench v0.1 is the agentic coding benchmark where the biggest launch-day jump landed. Opus 5 more than doubles Opus 4.8's performance at lower cost per task (Anthropic, July 24, 2026); independent trackers place Opus 5's xhigh effort at roughly 44% versus Opus 4.8's 18.7% (vendor-reported; not every tracker publishes identical numbers, so treat this as directionally accurate).
OSWorld 2.0 is the long-horizon computer-use benchmark — clicking through real desktop workflows. Opus 5 outperforms all models at any given cost, and surpasses Fable 5's best result at just over a third of the cost (Anthropic, July 24, 2026). This is the benchmark that should matter most to anyone building agents that operate software rather than just write code.
The BUILD rubric: how to run your own one-shot comparison
If you want to actually verify model quality on your own workload — and you should, because vendor benchmarks never match yours exactly — here is a five-criterion rubric, scored 0–4 each, that you can apply to any one-shot "build me an app" prompt. Run your test on two or more models using the same prompt and the same harness, and score each model blind. This is the same pattern we describe in our broader frontier model side-by-side testing guide, sharpened for build tests.
- B — Build completeness. Did the model output a runnable project that addresses every requirement in the prompt? 0 = does not run; 4 = every named feature present and working.
- U — UI/UX polish. Visual coherence, readable text, sensible camera, controls that feel responsive. 0 = placeholder art; 4 = a shippable first impression.
- I — Implementation structure. Did it plan before writing — separating concerns, isolating assets, scaffolding tests? 0 = one tangled file; 4 = clean module boundaries and a build script.
- L — Logic fidelity. Physics, collision, game-loop timing, edge cases. 0 = broken; 4 = no obvious defects in a five-minute playthrough.
- D — Defect recovery signal. Even in a one-shot you can tell a lot from where it breaks: a model that fails on collision detection but nails the rest is a different beast from one that produces a coherent scene you cannot move in. 0 = total failure; 4 = graceful and localized failure.
Score each model on each letter; sum to a 0–20 score. For a side-by-side test of Opus 5 against Fable 5, GPT-5.6 Sol, and Kimi K3, you can use the prompts recent evaluators have been running — driving game, dragon flight, 3D first-person snake, flight simulator, open-world RPG, neon racer, and arcade blaster — but the rubric works on any prompt that exercises physics, controls, scene composition, and UI simultaneously. If you cannot be bothered to set this up, the published benchmarks above are a reasonable proxy; if you can, the one-shot rubric catches things no benchmark will.
Claude Opus 5 vs Fable 5 vs GPT-5.6 Sol vs Kimi K3: the comparison
The table below is built from primary sources only — Anthropic's launch page, the ARC Prize verified results, Vals AI's SWE-bench leaderboard, and BenchLM's CursorBench snapshot. Vendor-reported benchmark numbers are marked.
| Capability | Claude Opus 5 | Claude Fable 5 | GPT-5.6 Sol | Kimi K3 |
|---|---|---|---|---|
| API input / output $ per M tokens | $5 / $25 | $10 / $50 | $5 / $30 | open weight (self-host) |
| SWE-bench Verified | 97.0% | 95.0% | 96.2% | 93.4% |
| CursorBench 3.2 | 70.0% | 70.5% | 67.2% | — |
| ARC-AGI-3 (High) | 30.16% | — | — | — |
| Frontier-Bench v0.1 | ~44% (xhigh, vendor) | ~33.7% (vendor) | — | — |
| OSWorld 2.0 | Beats Fable 5 at 1/3 cost (vendor) | Strong (vendor) | — | — |
| Context window | 1M | 1M | varies | varies |
| Max output | 128K (300K Batch) | 128K (300K Batch) | varies | varies |
| Safety behavior | Most aligned Opus to date (Anthropic) | Fallbacks to Opus 4.8 on cyber/bio; ~5% of sessions | — | 51% hallucination rate on a held-out coding test (Moonshot-omitted; independently verified) |
| Knowledge cutoff | May 2026 | Jan 2026 | varies | varies |
A few honest caveats on this table. The CursorBench 3.2 gap is 0.5 points — below the resolution you would use to change a production route, so treat it as a tie. ARC-AGI-3 was only evaluated at High effort; the max score may be higher. The Frontier-Bench and OSWorld figures are mostly vendor-reported — they are directionally useful but a vendor has every incentive to pick the number that flatters its model. And Kimi K3's hallucination rate, independently measured at ~51% on held-out data, is the main reason we are cautious about recommending Kimi K3 for agentic coding despite its elite benchmark scores — see our Kimi K3 open-weights analysis.
Is Claude Opus 5 worth switching to?
For most teams running daily agentic coding work — feature implementation, bug triage, code review, browser-automation workflows, structured research — Opus 5 is now the sensible default. It is the cheapest frontier-tier Anthropic model, it leads SWE-bench Verified, it is within a rounding error of Fable 5 on CursorBench at half the cost, and it has the most current knowledge cutoff in the Anthropic lineup (May 2026). The benchmarks that matter for "did the agent finish the task without three restarts" — CursorBench, Frontier-Bench, OSWorld — all favor it on cost-to-capability.
You should still reach for Claude Fable 5 specifically when:
- the work is genuinely senior-engineer-grade — multi-day, ambiguous, multi-step reasoning;
- the cost in tokens is dwarfed by the cost of a wrong answer (compliance, security, scientific work);
- you are doing cybersecurity, biology, or chemistry research, where Fable 5's deeper safeguards and Mythos-class capability are real advantages (myclaw.ai opus-vs-fable comparison).
You should reach for GPT-5.6 Sol specifically when:
- the 1–4 hour task bracket dominates your workload — Vals AI shows Sol uniquely excels there (98% vs Opus 5's 90%);
- you are tooling on OpenAI's ecosystem already.
You should reach for Kimi K3 specifically when:
- you can self-host for free and tolerate the risk of a ~51% hallucination rate on held-out coding tasks;
- you are building a one-off internal prototype where every output is human-reviewed.
For everything else — the daily workhorse case — start with Opus 5, and escalate up the cost ladder only when a task fails to complete.
What this means for you
If you are an individual developer or a small team building production software with AI coding agents, three concrete takeaways:
- Start on Opus 5 and stop pretending you need Fable 5 for everything. The published numbers show you are giving up nothing on coding or knowledge work by halving your model spend. Most teams were overpaying on Fable 5 for tasks Opus 5 now does better, not just cheaper.
- Make one-shot build tests part of your eval ritual. Use the BUILD rubric above on a small set of prompts that exercise your actual domain — not generalized benchmark tasks. Vendor numbers never match your workload exactly, and a 10-minute one-shot rubric run catches integration issues that take hours to spot in a benchmark leaderboard.
- Don't build a workflow that hardcodes one model. Frontier models change every few weeks; your stack should be able to route to whichever model wins the moment. For a long-term answer to "what survives the next model launch," see our deeper piece on model-agnostic LLM cost optimization — the architecture matters more than the model.
FAQ
Q: What is Claude Opus 5's actual price? A: Claude Opus 5 costs $5 per million input tokens and $25 per million output tokens on the Claude API — identical to its predecessor Opus 4.8 and exactly half of Claude Fable 5's $10/$50 rate. A Fast mode runs at roughly 2.5× default speed for $10/$50 per million tokens. Source: Anthropic launch page, July 24, 2026.
Q: Is Claude Opus 5 better than Fable 5? A: On coding and knowledge work, Opus 5 matches or beats Fable 5 on most benchmarks at half the price — SWE-bench Verified 97.0% vs 95.0%, ARC-AGI-3 30.16% versus no published Fable score, OSWorld 2.0 "surpasses Fable 5's best result at just over a third of the cost" (vendor). Fable 5 still wins narrowly on CursorBench 3.2 (70.5% vs 70.0%, a tie within margin) and on absolute hardest-horizon work like long-running autonomous research. Pick Fable 5 only when cost is not the binding constraint.
Q: What is the BUILD rubric for one-shot build tests? A: A five-criterion, 0–4 score each, 0–20 total rubric: Build completeness, UI/UX polish, Implementation structure, Logic fidelity, and Defect recovery signal. You give two models the same single prompt, score both outputs blind on each criterion, and sum. It takes 10 minutes per model and catches integration issues that generalized benchmarks miss.
Q: How do I run Claude Opus 5 through the API?
A: Set the model ID to claude-opus-5 in your client, send text and image inputs via the standard Messages API, and pick an effort level — low, medium, high, xhigh, or max. Note that thinking cannot be disabled at xhigh or max (the API returns HTTP 400 if you try). It is the default model on Claude Max and the strongest on Claude Pro as of late July 2026.
Q: Why is one-shot testing useful if real benchmarks exist? A: One-shot tests measure first-move quality — the part of a coding agent's work that happens before a human can course-correct, and the part that dominates token spend. They are not a replacement for SWE-bench or a multi-turn agent harness; they are a 10-minute sanity check that surfaces UI/UX polish, instruction adherence, and where a model fails first. The BUILD rubric makes them reproducible.
Q: Should I migrate from Opus 4.8 to Opus 5?
A: Yes, in almost every case. Same price, strictly better model. Opus 4.8 is now legacy and will retire soon [Opus 4.1 retires August 5, 2026 per the Oflight launch analysis]. If your existing prompts rely on disabling thinking at xhigh or max effort, note those now return HTTP 400 — that is the one breaking change to audit during the migration.
Discussion
0 comments