The Opus 5 backlash is a harness problem
Everyone's angry at Opus 5, and the complaints are fair. But most of them describe bare chat: one human, one prompt, one blob of text back. Put a harness between you and the model - plan, fenced waves, review, gate - and model personality drops to a tuning parameter. That's the Google thesis too: pareto-optimal models, TPU efficiency, compute pushed onto hardware you already paid for. Doubling down on my 2025 'Google will win' post.
Everyone is mad at Opus 5, and they're not wrong
If you've been anywhere near a coding-agent community this month you've seen it. Opus 5 is verbose. It's chaotic. It narrates its own thinking, self-corrects without being asked, buries the one sentence you needed under a wall of text. The Hacker News thread asking "why does Opus 5 feel worse to work with?" is reportedly one of the largest Claude-focused threads since the model launched. People are reverting to Opus 4.8, some to 4.6, and saying it "feels way better." Others moved their daily coding to GPT-5.6 Sol.
They're not misreading it. Anthropic confirms the longer default responses are intentional: Opus 5 was built to be more thorough and more agentic, to verify its own work and expand on tasks. The complaints are the design, experienced from outside.
The behavioral reports are more interesting than the verbosity ones. They include Opus 5 rewriting unrelated code, spawning subagents to "test under load" nobody asked for, running headless browsers after being told not to, and using git checkout and git stash to test changes, then forgetting to revert them.
That last one is the whole post.
That complaint is a complaint about bare input/output
My repo has forbidden git stash for months. It's a rule in CLAUDE.md, written back when parallel agents started stepping on each other's uncommitted work, long before Opus 5 existed to misbehave:
Destructive Git Commands: parallel agents may hold uncommitted work in this tree, and
git stash,git checkout <path>,git restore,git reset --hardandgit cleansilently destroy it. For a clean baseline usegit diff HEADorgit show HEAD:path/to/file.
I didn't write that rail because I predicted a model regression. I wrote it because a harness needs rails regardless of which model is driving. When the model regressed into exactly that failure mode, the rail was already there. That isn't foresight, it's just what rails are for.
Almost every Opus 5 complaint I read is about the model's unmediated output: raw chat, one human, one prompt, one blob of text back. Verbosity is only a problem when a human is reading it. Chaos is only a problem when nothing bounds the blast radius. Over-eagerness is only a problem when the agent's scope is "the repo, I guess."
If your relationship to the model is bare input/output, the model's personality is your entire product experience. If it isn't, it's a tuning parameter.
What a harness looks like
This practice grew names while most of us were busy building it. Mitchell Hashimoto started calling it "harness engineering" in February: any time an agent makes a mistake, engineer the environment so it can never make that mistake again. Martin Fowler wrote the synthesis in April. Karpathy has argued for "agentic engineering" as the umbrella term, and Simon Willison files his writing under that tag now. "Spec-driven development" names the plan-first method inside it. The vocabulary is under a year old, which is why every serious setup still looks bespoke: we built before the words arrived.
The tools came from both directions at once. Native: Claude Code's dynamic workflows move the plan out of the model and into a JavaScript script a runtime executes, so only each agent's final answer touches a context window. Anthropic uses it on itself, on the record: Jarred Sumner ported Bun from Zig to Rust with it, roughly 750,000 lines in eleven days, hundreds of parallel agents with two reviewers on every file, and Anthropic's migration writeup has the best sentence in the genre: "You don't fix the code. You fix the process (loop) that produced the code." Codex spawns subagents citing the same context-rot rationale I would; Cursor runs subagent swarms, each worker in its own git worktree.
Third-party, the same shape gets sold in layers. Spec Kit is GitHub's spec-to-plan-to-tasks pipeline, 132k stars. superpowers (278k) teases a spec out of conversation, then runs subagent-driven development for hours; it's on Anthropic's official plugin marketplace. Beads is Steve Yegge's dependency-graph work ledger agents claim tasks from; his Gastown stacks a coordinator and worktree-backed workers on top. BMAD runs role-played analyst/architect/dev/QA agents handing documents down a line. OpenAI's Symphony watches a task board, spawns an agent per task, and demands proof of work back (CI status, review feedback, a walkthrough) before the PR lands.
Mine is homegrown on Claude Code subagents because I wanted the ledger and the fences a specific way, and because I built it before most of that list existed. One worked example scratching the same itch, compressed:
- Plan. The ask goes in verbatim, and the orchestrator is forbidden to summarize it, because a distillation at the top poisons every downstream step. A planner agent investigates the actual source tree and emits falsifiable requirements, a wave breakdown, and an ownership map.
- Waves. A wave is a dependency layer of mutually independent agents. Each gets one brief, one file-ownership fence nobody else in the wave can cross, and its own git worktree, branched off the previous wave's committed tip. A merge agent folds the worktrees, resolves the seams, runs the authoritative typecheck, pushes.
- Review, then gate. A reviewer that did not write the code reads each wave's diff. Before the arc closes, another agent re-settles every requirement against
git diff ORIG_SHA..HEAD. The test is whether the code landed, not whether someone claimed it would, and drops loop back into another wave.
Coordination runs through an append-only ledger rather than the chat transcript: every brief and every finding is a row in a shared database. That makes the coordinating context disposable: compact the conversation mid-flight or come back a day later, and nothing load-bearing was living in a context window.
Every agent is also told some version of: a claim you inherited has lost its evidence in transit, so re-run it before you believe it. Counts are leads, not facts. A green test you didn't design to be capable of failing isn't evidence. The harness assumes its own workers are confidently wrong in both directions, because they are.
The sandbox is what makes it leavable
None of it matters if you can't walk away from it while it runs.
It all runs in a cloud sandbox with least-privilege credentials, and not by convention: the IAM identity carries explicit Deny statements on the write verbs. Every AWS mutation is mine, from my laptop. When an agent needs a privilege it doesn't have, I add exactly that one, and it becomes surface area I chose rather than a bundle handed over at the start. A misbehaving agent, chaotic Opus 5 included, gets a small space to be chaotic in. Anything outside its grants denies, which is a dead lane rather than an incident.
That's what makes the rest affordable. Unattended overnight runs against a real repo are fine, not because the model won't do something dumb but because dumb has a bounded cost. Sessions are isolated and worktrees siloed, so a conflict becomes a routed outcome: the sync agent hits it, aborts cleanly, hands it back up with the branch intact. And because it's a sandbox and not my machine, I dispatch and monitor from my phone, which sounds like a lifestyle detail and is really a throughput one, since the bottleneck in agentic development is human dispatch latency.
Security usually reads as a tax paid for compliance. Here it's closer to the enabling condition: you cannot run six agents unattended against a real codebase if any one of them can reach production.
Why model strength stops mattering much
Here's the config I run, since people ask about model:effort and it's rarely published.
- Orchestrator and planner:
fable:medium. The judgment seats. Reading an ambiguous ask, deciding what a goal even is, deciding when a fork needs a human, weighing two agents' contradictory reports against each other. That's wisdom work, and Fable 5, a real public tier since June 2026 sitting above Opus 5 at $10/$50 per million tokens, is better at it. - Everyone else: Opus, at varying effort. Reviewers and adjudicators at high, coders at medium, gatherers and web-research agents at low.
Those non-judgment roles want a completely different temperament, and it's the temperament everyone's complaining about. Narrow. Literal. Single-minded to the point of savant. Tireless. An agent whose entire world is "grep this pattern across these twelve files and report every hit, and do not editorialize" benefits from a model that over-verifies and won't stop. The behavior that ruins a chat session is close to ideal in a fenced worker with a machine-checked deliverable.
Which is why swapping every Opus lane in that config to Sonnet should be viable: in a setup like this the model isn't the thing carrying correctness. The fences carry it. The requirements carry it. The typecheck, the mutation-tested assertions, the per-wave review by an agent that didn't write the code, those carry it. I haven't made the swap, so treat that as a hypothesis rather than a result.
That's the weak form of a claim people are arguing about right now, and the weak form holds up: the harness explains more of what you experience than the model does. LangChain moved their coding agent from Top 30 to Top 5 on Terminal Bench 2.0 by changing only the harness, and notes that "Opus 4.6 in Claude Code scores far below Opus 4.6 in other harnesses."
The strong form, that you can therefore swap models freely, runs into a named objection: model-harness fit. Nicolas Bustamante: "A model switch is not a model swap. It is a harness swap, a tool swap, and a cache invalidation, all at once." Labs post-train models with their own harnesses in the loop, so harness primitives get baked into model instincts. A harness made of bespoke tool schemas and wire formats inherits that coupling, and he's right that you can't lift it between models.
Mine couples more loosely. It's prose briefs, review gates, and deterministic checks: a typecheck doesn't care which model wrote the code, a mutation-tested assertion doesn't either, and a markdown doc survives a model swap in a way a tool schema doesn't. The swap still isn't free; the rails are tuned to the failure modes of the models I run, and a new model brings failure modes they haven't met. But the cost is re-tuning, not a rebuild.
The fable-vs-opus split is a snapshot, not a law. It exists because of a genuinely odd moment: Opus is spazzy and Fable is wise, and those are different axes, wisdom versus intelligence rather than more versus less. One model bump on either side and the split collapses, and my orchestrator config becomes a historical curiosity.
Once enough of the correctness sits in the harness, frontier-model drama turns into weather. You notice it the way you notice a headline.
Doubling down
That's my repo. I think it's about to be true of the whole market.
In May 2025 I wrote Google Will Win The AI Race. I'm re-upping, and the line I'd point at first isn't the flashy one. It's this, about TPUs:
This allows them to offer stronger AI at the same price, or similar AI at a lower price. We're currently seeing the former, per Gemini Ultra's $250/m tag.
I named two strategies, said Google could pick either, and observed they were doing the first. Fifteen months later they switched to the second, and it's the most important thing happening in this market.
Good enough, shipped monthly
Gemini 3.7 Flash launched on August 13th, thirteen days ago, three weeks after the model it replaced. Google's own framing is "our most intelligent workhorse model," aimed explicitly at coding and agents. It shipped with a 50% introductory price cut.
The prices, per million tokens in/out:
| Model | Input | Output |
|---|---|---|
| Gemini 3.7 Flash (intro, through 2026-12-31) | $0.75 | $3.75 |
| Gemini 3.7 Flash (standard, from 2027-01-01) | $1.50 | $7.50 |
| Claude Sonnet 5 | $2.00 | $10.00 |
| Claude Opus 5 | $5.00 | $25.00 |
| Claude Fable 5 | $10.00 | $50.00 |
At intro pricing that's roughly 2.7x cheaper than Sonnet 5, 6.7x cheaper than Opus 5, and 13x cheaper than Fable 5 on output tokens. Even after the intro period ends it stays under Sonnet 5.
The benchmarks are the interesting part, because they're split, and the split is exactly the shape of my harness:
| Benchmark | Gemini 3.7 Flash | Claude Sonnet 5 |
|---|---|---|
| FrontierCode 1.1 | 43.6% | 42.7% |
| DeepSWE 1.1 | 65.3% | 53.8% |
| AutomationBench | 30.4% | 10.7% |
| GDPVal-AA Elo (knowledge work) | 1525 | 1598 |
Flash beats Sonnet 5 on coding and agentic evals, by 3x on automation, and loses to it by 73 Elo on general knowledge work. That's a model that is pareto-optimal for the agentic workload specifically and merely fine at being a wise conversational partner.
Google shipped, at a fraction of the price, precisely the profile my worker lanes want, and did not ship the profile my orchestrator wants. That's every seat in my pipeline except two.
There's a rumored Gemini 3.8 Flash in September, and it's a leak: no public API, no SDK model ID, no model card as of two days ago. The precedent is decent: 3.7 Flash itself leaked through Google's Python SDK before launch. The leaked framing has 3.8 going after Fable 5, not Sonnet. If that lands, it comes for the last seat.
The subsidy problem is somebody else's problem
Everyone's waiting for the bubble to pop, and the specific mechanism they're waiting on is subsidy. A Claude Max 20x subscription is $200/month. The best analyst estimate I can find puts real compute cost for a heavy power user at up to roughly $90,000 a year against $2,400 a year of subscription revenue, call it 25:1 at the extreme tail. It's an outside estimate of an undisclosed number. You don't need the precise figure, just the sign, and everybody knows the sign.
The behavioral consequence is already documented: when Max was $200/month with no effective ceiling, developers built agents that were sloppy with compute. That's not a moral failing, that's what a flat rate does. And it's a liability that compounds precisely as agentic usage, the thing everyone's betting on, grows.
The counterpoint deserves its due: Anthropic cancelled Sonnet 5's scheduled price increase to $3/$15 and made $2/$10 permanent. They held the line on exactly the tier Flash is attacking. That's a real datapoint against "prices must rise." Read the other way, it's a company choosing to eat margin to defend a tier, which is the subsidy dynamic rather than an escape from it.
Google isn't playing that game. Google is competing on value, from a cost basis nobody else has. That's a structurally different position than winning a subsidy war, and a much better one to be in when the music stops.
The Pixel 11 Pro spec sheet is a letdown, and that's the point
Launched August 12th, on sale the 20th. Tensor G6, built on TSMC's 2nm process. $1,099 for 12GB/256GB.
The reception has been rough, and the critics are right on the facts. Google cut base RAM from 16GB to 12GB and raised the price $100. Trusted Reviews' headline is "too much AI, not enough upgrades." Android Authority tested the G6 and called the results "brutal," with gaming the genuine weak spot. CPU and GPU gains are real but modest: +25% on web browsing, +15% on app launch versus the G5.
The transistor budget went to the TPU. The Tensor G6's TPU is ~50% more powerful for computational photography, and some local AI tasks run up to 3.5x faster.
That's reviewers, describing a benchmark spread, arriving at "they spent it all on AI silicon" as a criticism. I read the same sentence as the thesis.
Because of what shipped alongside it: Gemma 4 E2B for TPU, an open-weight model designed to run directly on the TPU inside the Pixel. Gemma 4 launched in April under Apache 2.0, in four sizes positioned on intelligence-per-parameter, targeting phones through workstations. Google didn't put an AI accelerator in the phone and hope developers found a use. They shipped the model for it.
And the runtime shipped too. LiteRT-LM, descended from TensorFlow Lite, already runs Gemma 4 inference across Chrome, ChromeOS, and the Pixel Watch. The on-device inference stack isn't a roadmap slide, it's a shipped runtime on OS lineages Google controls end to end. Silicon is the optimization. The offload is the strategy, and the offload is already running.
Depreciation is the quiet catastrophe
The reason offloading compute matters isn't user experience. It's accounting.
Michael Burry made the depreciation argument mainstream: hyperscalers depreciate AI hardware over 5 to 6 years while its real economic life is closer to 2 to 3, and the cumulative earnings impact could exceed $176 billion across 2026 to 2028. It's a contested claim with serious rebuttals, and it's nine months old. But the underlying pressure is visible in actual filings, not just op-eds: between 2020 and 2024 big tech steadily extended useful lives, and in 2025 the trend split, with Amazon shortening the estimate on a subset of servers while Meta extended its. A Goldman sensitivity puts the swing at ~$3 trillion to ~$4 trillion in implied total annual depreciation for 2026 to 2031 if you move the schedule from five years to three.
The mechanism is simple and undisputed. Nvidia ships annually: Hopper 2022, Blackwell 2024, Rubin 2026, Rubin Ultra 2027. Every year the thing in your rack gets a successor, and your depreciation schedule is a bet on how long last year's stays economical.
On TPUs the defensible 2026 claim is narrower than raw speed. Ironwood, TPU v7, hits 4.6 dense FP8 petaFLOPS per chip against the B200's 4.5, which is parity, and Ironwood draws about as much power as Blackwell does. Google leads on energy efficiency; Nvidia leads on raw output per chip. Three claims hold up:
- Efficiency, measured. Ironwood delivers a 3.7x improvement in carbon intensity over TPU v5p and roughly 2x the performance per watt, via architectural simplification and liquid cooling.
- Vertical integration. No Nvidia margin. No Nvidia queue. When your cost of compute doesn't route through a supplier with the best pricing power in the industry, "similar AI at a lower price" stops being a slogan and becomes an income statement.
- Specialization. Google has previewed an eighth-generation TPU split into separate training and inference chips at 2nm. A dedicated inference chip is the whole thesis in silicon: inference is the good-enough-at-volume workload, and it's the one that scales with agents.
And then there's the part that isn't an engineering problem at all. In Q1 2026, at least 75 data-center projects worth $130 billion were disrupted by local opposition. Gallup has 7 in 10 Americans opposed to data centers, with water use a top-cited concern. More than a dozen shareholders have pushed Amazon, Microsoft and Google to disclose site-specific water and power consumption. Google is positioning ahead of this, pushing to open up data-center water reporting, which is otherwise a black box.
Stack it up and the shape is unmistakable. Server-farm the nimble models for the semi-heavy loads, on silicon you designed, at a perf/watt lead, in an inference-specialized generation. Push everything else onto hardware the customer already bought and already depreciates. Every token that runs on my Pixel is a token that doesn't need a rack, a megawatt, a cooling loop, a county permit, or a five-year schedule somebody's going to have to restate.
The bet
OpenAI and Anthropic are running two arms races at once: a giga-model race for the frontier, and a loss-leading subsidy race for the seats. The first is what generates the bubble fear. The second is what makes the bubble fear rational. And the climate and water discourse is the political bill arriving for both.
Google saw all of it coming from a very long way off. They built TPUs before anyone knew what that had to do with anything. They moved TPUs into consumer hardware while reviewers scored the spec sheet and called it a miss. They open-weighted a model family sized for the edge and shipped a runtime for it on Chrome, ChromeOS, and a watch. And they aimed their flagship serving model at pareto-optimal rather than at the leaderboard, then cut its price in half on day one. That's somebody who decided years ago which quantity was going to be scarce.
Which is where the two halves of this post meet. If the correctness lives in your harness, the frontier-model soap opera mostly stops reaching you. I can't point at what the last two weeks of Opus 5 discourse cost me, because the fences and the reviews and the gates absorbed it, and that's the structure doing ordinary work rather than anything clever on my part. If pareto-optimal models plus distributed compute is where the market lands, it stops reaching everyone, because the marginal token stops being scarce enough to have drama about.
Same claim from two directions: the model is becoming a part, not a product. Parts get commoditized. Whoever owns the cheapest path to a good-enough part, and the widest surface to run it on, wins the decade.
I said Google would win this in 2025 and named their two options. They've now picked the second one and started executing it in public. Check back on this post in a year and tell me where I was wrong.
