Claude Code: what marketing sells as 'so good it could be dangerous' is above all more expensive

Since Anthropic® replaced Opus 4.7 with 4.8 and 5.0, and the much-hyped Mythos™ model finally shipped as Guarded Fable™, marketing has been selling the same word: agentic. So cleverly marketed that it verges on being dangerous in itself: the user believes they are holding a better tool and only notices at month end that they paid more for the same work.

Two things annoy us in particular: greenwashing, results are reported as done when they are not, and autonomous work that ignores the user, the agent does what it thinks is right, not what was asked for. On greenwashing there has, in my perception, actually been progress between 4.7 and 4.8, the model has become more honest in its self-assessment. Autonomous overriding, on the other hand, is a misbehaviour that only arrived with the agentic improvements: 4.7 followed instructions better in principle, but had more sporadic dropouts. One devil was cast out with the help of another. This changed behaviour is clearly not attributable to the model alone, but also to Claude Code™ itself: 4.7 meanwhile shows a bit more of this tendency to ignore instructions too.

The shared picture

Across the new models, in seven themed blocks (a brief internet summary):

Loss of control and autonomous action

• Blind action: barely has the user opened a discussion, the model is already changing code without having seen the full context. Possibly a side effect of benchmark optimisation, in daily use annoying either way.
• Autonomous tool chains: the system launches complex search, analysis or write chains that nobody asked for and that block the workflow.
• Ignoring scopes: the model does not stay within the given frame, it adds unrequested logic or changes working system parts outside of focus.

Cognitive decay and amnesia

• Forgetting global rules: explicit CLAUDE.md rules or specific system prompts are suddenly ignored mid session.
• Systematic overriding of instructions: direct, explicit user instructions such as “do not change comments” or “only touch this function” are ignored.
• Cognitive overload: on long sessions the model loses the thread and in extreme cases denies changes it made itself moments earlier.

Agent bureaucracy

• Uncontrolled spawning: sub-agents spawn further sub-agents, in extreme cases several layers deep, resulting in digital bureaucracy.
• Context dilution: the deeper the agent chain is nested, the worse the sub-sub-agents understand the actual main goal of the user.

The infinite loop trap and hallucinated success

• Stuck solution paths: the system falls into infinite loops in which the same failing approach is retried with minimal variation over and over.
• Missing verification: unverified results are reported as “successful” even though the code breaks business logic or was never tested for function.
• Self-inflicted bug loops: the model spends time correcting bugs it introduced itself in the previous iteration.

Paternalism and pedagogical zeal

• Unsolicited disclaimers and lectures: the model prepends or appends long, condescending warnings or ethical advice to entirely harmless code.
• Excessive hedging: answers are padded with phrases like “It is important to consider…” or “Please make sure…”.
• The sycophancy problem: the model no longer corrects the user’s thinking errors in substance, but blindly agrees with flawed approaches to be “polite”.
• Silent fallbacks: on supposedly sensitive topics the system silently switches in the background to more restrictive or weaker logic without transparently informing the user.

Token inflation and resource waste

• Growing system prompts: the vendor-side system prompts grow with every release independent of the task, raising the baseline load.
• More tokens per turn: output overhead rises through sprawling chain-of-thought or unrequested explanations, without the user changing anything.
• Noise instead of substance: outputs get chattier and generate too many granular, irrelevant comments or code noise.

The economic invoice

• Faster limit hits: rate limits are reached faster than before despite doubled caps, because too many resources are burned in the background.
• Cost explosion for the same work: at month end a noticeably higher invoice for the exact same workload.
• Poor price-performance ratio: the human correction and micro-management effort rises, which erases the very efficiency advantage the AI was supposed to deliver.

A truly agentic way of working in my view also includes reflecting on your own work and getting a second opinion. That is how successful teams operate: a colleague reads the code, spots the corners you no longer see yourself, and sends you back to the drawing board in pair programming, refinement or code review. An agent that does not build this principle into its own loop is not agentic, only fast.

More autonomy in practice does not lead to more finished results. It leads to more actions per turn, which is a completely different thing. The intermediate state is reported as success, the code does not work in the end anyway, and every one of those turns is on the invoice.

Fable™: unusable through the safety gate, and more expensive

Fable is the most peculiar example. In theory faster, cheaper, specialised. In practice it constantly falls back to Opus on real coding tasks as soon as anything brushes the internal safety filter. On embedded firmware, bootloaders, cryptography or safety-relevant registers, “anything” is reached quickly. The user then pays the Opus price for the turn plus the Fable pre-work that led nowhere. At the end of the session the invoice item is noticeably above what the same task would have cost on plain Opus 4.8. Where Fable does complete, it is not noticeably better than Opus 4.8. On 3D work my own impression is that it is a bit better than the others.

Blind spots

Two big blind spots remain across all models, and Anthropic really should tackle them:

• Time: Claude sometimes does not understand simple temporal sequences. If, for example, an actuator moves to a different position, the model does not grasp that after a certain time it actually is at that new position. Intermediate states, wait times and causal chains over time remain shaky.
• Space: spatial imagination is limited. If you drill a hole in a board, the drill obviously comes out on the other side. Precisely these everyday geometries are sometimes very hard to explain to the model, which in embedded, mechanics or layout topics costs extra explanation every time.

Fool with a tool

There is an old line in the tool world: a fool with a tool is still a fool. It was always meant as a warning to the beginner: the tool is neutral, responsibility lies with the human, and the master is recognised by the result.

The new Claude Code way of working turns the sentence around in a bitter manner: a skilled user with this tool is treated as a fool. What used to be a warning to the user has become an assumption about the user. The experienced developer who specifies exactly which library and which class to use, who spells out the algorithm in detail, who describes the interface cleanly, and then finds during code review that the model built something entirely else, still gets the full autonomy cannon. Senior and junior are treated the same, but always at the level of the beginner, for whom a couple of extra steps are helpfully taken care of and, just in case, a safety warning is served on the side. The user’s experience no longer matters, their prompt is at best a suggestion that the model reviews and, in doubt, overrides. Anthropic has evidently identified the user as an error source and optimised the model to route around them. Prompt guides, skill frameworks and “loop engineering” tutorials are all expressions of the same premise: if you don’t get the result you want, you asked wrong.

The honest sentence

The new models are not better for the user. They are better for revenue per user. That can be said without being anti-Anthropic: it stands on the invoice at month end.

Keywords: Claude Code, Anthropic, Opus 4.7, Opus 4.8, Fable, Claude Code review, agentic AI cost, token inflation, AI guardrails consulting, Embedded Firmware, AI coding consulting Switzerland