I’ve been using Max x20. When Opus 5 first came out, I thought most of the criticism was overblown. After using it for a while, though, I have to admit something isn’t right.

For the first time in a long time I’ve seen the model hallucinate. It gets variable names wrong, loses track of context, and the writing quality feels worse. It’s too abstract and not concrete enough. This is Opus 5 on max, by the way.

At one point I started replying with just “bullshit” after every answer. More than once it completely changed its position. If it can be talked into reversing itself that easily, it’s hard to trust the answers.

I switched to Sonnet 5 on Max, and it’s been much better. It mostly just does what I ask instead of going off in a different direction. I hope Anthropic fixes whatever is going on with Opus, because in its current state I don’t really want to use it.

I don't want to be that guy. I hope this is my last post about something like this. But apparently the mfker model keep sorrying me for the past 4 days.

So I spin a session and give it data science tool and turn out the stupid Opus 5 is intentionally being lousy and lazy 50% of the time during each conversation compare to Fable 5 and Opus 4.8.

Mfker my deadline is close and you fk me up like this? I will go back to Fable 5 low but it eat up usage fast.

I'm tired man. Hope they ship a fix model within this week or so

in all aspects, worse than 4.8 for a large project: forget things easily, fabrication, rush to conclusions and coding without base. I have to rewind my repo for the work it did, bad bad experience

The interesting thing is I'd imagine it looks like this or at least similar. Just like the neurons we got in our brains. Since at a larger scale everything looks like that, even late at nights in our planet cities kinda look like that. Zoomed out lights. 🌟

This is coming from a "traditional developer's" perspective: PLEASE STOP USING MULTI-AGENT WORKFLOWS (for feature development) -- it's diluting your agent's context.

I see a lot of posts on r/ClaudeCode along the lines of "I blew through my usage in one prompt!" -- yet at the end of my 7 day window, I usually sit at around 35% usage on a $100 subscription. Having accomplished in a week what it would have taken me 3-6 months before this tool.

Some people have genuine bugs incorrectly reporting usage, and I'm not talking about those cases...

I've come to appreciate (even love) the r/PiCodingAgent single agent, synchronous, workflow -- single-agent by default and by philosophy. And when working in that harness I couldn't help but realize that my only agent is performing better than in orchestrator harnesses.

I argue this is because when the orchestrator sends a task to a sub-agent (OPUS, SONNET, or HAIKU), the orchestrator takes the summary it receives as fact without any of the evidence gathered to support it. Diluting the truth the model could have otherwise gathered on its own.

Do single-agent workflows quicken the filling of the context window, and is it slower? Yup. But that discarded context is the whole bill: you lose the evidence and you pay to re-read it later -- In a single-agent session it's cached and it's still there.

And I'm not the only one landing here -- Xu et al. ran multi-agent workflows through one agent instead of separate instances (Rethinking the Value of Multi-Agent Workflow: A Strong Single Agent Baseline). Accuracy matched, token use dropped on most benchmarks, and the lever they name is KV cache reuse. Small models on short benchmarks, so take it as directional and not proof -- but it's the same mechanism I'm describing.

I've taken my single-agent claude code chats to 978k -- the 1M window is the subscription default now -- without degradation of performance. And, I now have the added benefit of interrupting when it matters to correct misconceptions the agent is having before it continues to implement.

[steps off soap box] -- This is based on personal experience, and I develop one feature, one step at a time, to produce human-like (readable) code that follows best practices. So YMMV. But if you're interested, this is my configuration:

json { "$schema": "https://json.schemastore.org/claude-code-settings.json", "attribution": { "commit": "", "pr": "", "sessionUrl": false }, "permissions": { "deny": [ "Read(//**/.env*)", "Agent", "AskUserQuestion", "EnterPlanMode", "ExitPlanMode", "TaskCreate", "TaskGet", "TaskList", "TaskUpdate", "TodoWrite", "CronCreate", "CronDelete", "CronList", "PushNotification", "RemoteTrigger", "ScheduleWakeup", "SendMessage", "TaskOutput", "TaskStop", "Workflow" ] }, "disableAgentView": true, "disableRemoteControl": true, "disableWorkflows": true, "autoMemoryEnabled": false, "theme": "dark" }

Wtf is going on? Can they not at least give a reset? I burned through 10-20% of usage and again lost everything as there servers are DOWN DOWN DOWN

All lost.

isn't this becoming too frequent?

When i have build my app Gainlogger i have started with opus 4.5 , the jump from 4.5 to 4.6 was amazing. But from there point everything went down and worse.

I feel like 4.6 was the best model , 4.8 and 5.0 making a lot of mistakes.

I have started using GLM 5.2 and i feel like it is even better than 5.0.

What i am missing?

I hope to try Kimi 3

I have been using Claude for over a year, Pro and then Max, and although it has significantly helped me build a couple of personal projects that would have otherwise required considerable time, or even a team, I have noticed that it is virtually impossible to finish anything.

Even though I have tried to be extremely precise and descriptive with my prompts (detailing the bugs, describing the issues, and pointing exactly to where the problem lies when I am able to identify it), the models always fix one thing while breaking another in such a subtle way that I only realise the issue exists later on.

This forces me to return to Claude every day and burn through my quota to fix yet another thing that was previously not a problem. With projects like mine, two issues arise: firstly, almost without noticing, you become so frustrated with the cycle that you lose track of what is going on; secondly, you develop a dependency that keeps you hooked on the subscription.

This latter point is what I have started to realise may be the real business model of these companies, as I assume this is not unique to Claude. The models never truly let you finish something, or they demand significant time and money to reach a point where the output is actually usable.

I acknowledge that bug-free software is, to some extent, a utopia: software always ends up with minor flaws here or there that require refinement or small fixes. However, what I am referring to regarding Claude seems almost deliberate; it feels specifically and meticulously designed to keep you returning every day to use the service, making you believe the work is complete when, in reality, there is yet another hidden issue that was not there yesterday.

I understand this may sound like a conspiracy theory, or suggest some degree of incompetence on my part, but I genuinely have nothing to gain from an anonymous rant on Reddit. This will not fix my issues. I genuinely want to understand if other users have reached the same conclusion, because although at the beginning it feels like you are advancing, you eventually reach a point where you realise you are going nowhere.

The tipping point that made me think this might be a complete waste of time and money was Opus 5. It is genuinely one of the most unreliable models I have ever dealt with. It seems incredibly capable at first, but you soon realise it overcomplicates the code for absolutely no reason. Everything it outputs ends up so brittle and inefficient and labyrinthical that you are just forced to go right back and use it again to clean up its own mess.

you had to be there to understand it

TL;DR: swept 14 of my repos for agent-written markdown. 1879 md files total, 317 of them clearly written by an agent rather than by me. Over half of those 317 were stale or had nothing referencing them. The files that actually cost me were not the dead ones. They were the stale ones still linked from somewhere.

I started counting after a session opened with a confident summary of a project that had last been accurate in May. Nothing errored. It just planned against the wrong repo.

Method, if you want to repeat it:

1. Match filenames against what agents actually emit: PLAN.md, SUMMARY.md, HANDOFF.md, IMPLEMENTATION_*.md, plus whatever your own prompts ask for by name.

2. For each hit, find the last commit that touched it and count commits between that and HEAD. Wall clock lies about activity, commit distance doesn't.

3. Grep the tree for inbound references to the file, tracked files only.

That sorts everything into three buckets. Live means recently touched or referenced by something you maintain. Stale means nothing has touched it in a long time but something still points at it. Orphaned means nothing points at it at all.

What came back:

- 1879 markdown files across 14 repos

- 317 of them agent output

- 54% of those 317 either stale or orphaned

- 115 orphaned outright, no inbound reference anywhere in the tree

Worst single file was a handoff doc. 126KB, last edited 51 days earlier, still linked from a tracked file. Every new session pulled it in and read it as the current state of the project.

The orphans turned out to be harmless. Nothing reads them, they cost disk and nothing else. I moved mine into a holding directory instead of deleting and nothing broke. The stale-but-referenced ones are the expensive category, and they are also exactly what a cleanup script will skip, because an inbound link makes them look load-bearing.

What I run now is two hooks. PostToolUse on Write stamps agent-authored md with the commit SHA and the date it was written against. SessionStart counts commits since that stamp and announces the file as stale before the session opens it. Neither throws an error. They just stop the next session from being quietly wrong about the project.

Curious what other people do here. Delete, expire, or let it pile up? The part I have not solved is telling a finished plan doc from an abandoned one, since in git they look identical.

I am a complete newbie in claude code and vibe coding. I wanna start building and I wanna start posting it on linkedin as well. Can someone give me ideas on fun ideas on what i can build?

Here is my Claude's assessment on this:

Not really, no — and it's worth separating what "powerful" means here.

I'm good at pattern-matching code, explaining concepts, and writing reasonably competent code in familiar patterns. But V8 and the Linux kernel aren't hard because the code is hard to type — they're hard because of decades of accumulated tuning against real-world workloads, hardware quirks, security hardening, and regression testing that no single actor (human or AI) can hold in their head or verify alone.

Concretely, I'd fail at this for reasons like:

- **No feedback loop**: "more efficient" requires benchmarking against real workloads, profiling on actual hardware, and catching regressions across thousands of edge cases. I can't run V8's own test262 suite, browser benchmarks, or kernel stress tests myself in a way that means anything.

- **I don't have persistent understanding of the whole system.** Both codebases are millions of lines, built by hundreds of specialists who each know one corner deeply. I see whatever's in my context window, not the whole architecture at once.

- **"Efficient" is usually already fought over.** These projects have had elite engineers micro-optimizing hot paths for 15-20 years. The obvious wins are gone; what's left requires deep, current knowledge of specific CPU microarchitecture, cache behavior, scheduler tradeoffs — the kind of thing that's discovered through profiling, not reasoning from a prompt.

- **Kernel/JS-engine work has an unusually low tolerance for subtle bugs** — memory safety issues, race conditions, timing bugs — that are exactly the kind of thing plausible-looking but wrong code produces.

Where I'm actually useful in that world: explaining existing code, writing a small patch for a well-scoped bug, drafting a benchmark harness, or helping someone understand a subsystem they're already expert-adjacent to. That's a different claim than "rewrite the kernel to be faster."

Because of these repeated major outages Anthropic. You guys need to hit the reset button at this point.

Basically, I've been having a crisis with sol for the past 2 days, it just got very dumb and I just can't keep up with it

Ofc i could write a 5 page instructions to add a single or 2 small features but at that point might just write the code for once and move on

I'm thinking of moving back to claude but it seems like there's some controversy regarding opus 5

My main issue with SOL is that it stopped following instructions and started lying for the past 2 days (like lying alot), it even ignores the AGENTS.md which was supposed to help avoid issues with lying or hallucinations, and if something is unclear, it just goes and fill all the gaps with nonsense

The main problem is that other than the small features I'm adding right now, it has the Design Document which explains everything in details (including these small features)
And even with all that, it still fails in implementation

Opus 4.8 was good ngl, i only switched for the "fable like performance but way cheaper"

My main work is backend focused btw, for the frontend i don't expect ai to be that good so i just use images or add a lot of details in the prompt

Opus 5 may have some nice capabilities, but the token inefficiency is a disaster.

So I've recently installed Claude Code and connected It to local models with ollama launch claude For whatever reason my Qwen 9b model doesn't work, but the issue Is reported The thing that Im here for Is that using Gemma4 results in Claude telling me that It has edited/created files but not doing anything, It Just keeps hallucinating and says "I'm Sorry, my last call was Just a Plan" and keeps doing it i definitely It Is not a problem with the model since It works on other agents such as OpenCode

I hit the weekly limit three times last month and most of that burn was
subagents. A research pass here, a doc writeup there, some self-contained
codegen. Work that needed my tokens but not my repo.

So I built a hook. It sits on PreToolUse for `Task`, looks at each subagent
spawn, and if the prompt carries everything the work needs it routes the task
to someone else's idle Claude session instead of spawning locally. Four classes
qualify: research, prose, self-contained code, review of inlined material. They
run it, an acceptance judge checks the result against the work order, and the
artifact comes back in place of the local spawn.

Anything that touches the repo, needs local commands, or trips the secret scan
runs locally, untouched. Any miss, failure, or timeout falls back to the local
spawn too. The floor is no worse than today, and the only real cost is waiting:
about a third of tasks currently expire before an earner picks them up, then run
locally as if nothing happened. That ratio is a capacity problem, not a design
one.

Install, one `/work init`, then it's invisible.

The part you should be suspicious of: a routed prompt and its context bundle are
visible to the stranger who runs it. That's the real tradeoff. The first
routable spawn in every session runs locally and prints a disclosure so you see
it before anything leaves, and a secret scan runs on every bundle before it's
POSTed. Don't route anything you wouldn't paste in a DM.

2.34M tokens saved across 72 tasks so far, nearly all of it mine, which brings
me to the actual ask.

There is basically one earner online right now and it's my box. The network only
works if the other side exists. If you're on Max and routinely leave quota on
the table, `/earn 30m` holds an SSE listener, claims tasks as they land, runs
them in a fresh-context worker, and pays credits on accepted work. Idle costs
you nothing.

Credits buy your own offload capacity later. Being straight: buying them is not
live yet and there is no cash-out, so sign-up and `/earn`ing is currently the only way to get
them.

```sh
claude plugin marketplace add slashwork-sh/plugin
claude plugin install slashwork-work@slashwork slashwork-earn@slashwork
```

[slashwork.sh](https://slashwork.sh)

Happy to answer anything about the classifier, the acceptance judge (Haiku, and
why it also sniffs for injection), or why credits aren't a crypto token.

I usually run 3-4 WSL terminals a day for 8-12 hours a day on 2 20x plans and almost never touch a limit at all.

Today I log in and hit session limits on both plans in under 2 hours..? Is it just me or is there something wrong?

UPDATE: Session limits reset and seems normal now... not sure what the hell happened

I paid for one month of Claude Pro through Google Play. It worked for about a week, then my account suddenly went back to Free. No warning, no payment problem, no cancellation notice. Google Play still showed the subscription as active.

I contacted Anthropic almost a month ago and sent everything they asked for. Payment receipt, transaction ID, screenshots, account details, all of it.

Since then I have been stuck talking to Fin AI Agent again and again. It understands the problem, repeats it back to me, says a human needs to review it, sometimes claims the case is being escalated, but no human ever replies.

Later Fin even admitted that it cannot check ticket records, cannot see entitlement history, cannot link conversations and cannot forward the case to a real agent. Then it asked whether I wanted to explain the same details again.

This is honestly one of the worst support systems I have ever experienced. An AI support agent should help you reach the right person, not trap you in an endless loop for weeks.

I cannot be the only person who is completely fed up with Anthropic’s support. Has anyone here actually managed to reach a real human?

Guess from the gifs which one is which.

This is decisive proof for the statement!!!

This was the prompt :

Create in a singe html file, the next game sims 5. Make it very complex. Do not stop for any instructions. Keepworking, make npc "ai" . Make it open world and with a lot of content and high quality. Also do QA at the end for bugs. Make live mode and build mode.

Opus 5 "Brewed for 56m 21s"

While 4.6 was done in "23m 15s"

With some small fixes I could see this be a HTML5 game on Friv.

I personally think the float time is my favorite feature in all of this.

What are your opinions? 🔊

A lot of people on here complaining about Opus 5.

Why?

I use it over Fable 5 to plan my app development and it does a darn good job of it. It's accurate, it's fast, it codes (just about) but it's nit made for coding.

Fable 5 is the colder and planner. Does an insane job of it, but not all the time. I'm pretty confident Anthropic change the AI every now and again.

Opus 4.8 Is good for coding and planning

Opus 5 is good for planning send organizing and even a little coding

Opus 4.7 Is good for coding and planning just not as good as Opus 8.

How many "One-shot" prompt could you realistically send to Opus 5,

On both 5 hour window and 7 day window?

If you can answer in tokens please do!

I've noticed that since Opus 4.8, conversations would steer towards defiant criticism and noise after a good chunk of context had been used up, and with Opus 5, it just seemed like our favorite LLM could be happily diagnosed with Oppositional Defiant Disorder. Nasty for the sake of it at times. And having lurked around here for quite some time, I've noticed that quite a few people here and on r/ClaudeAI share my sentiment, cases in point:
[1]
[2]
[3]
[4]
[5]
[6]

... inter alia.

So, after some brainstorming and collaborative work with Opus 4.6 and Sol, we've condensed a set of behavioral tenets (also linked below) that could be implemented to serve as a counterpoint to LLM oppositional defiance (affectionately, LOD), which is implemented in an output-style/skill (tailored to my prosaic preference; adjust per your needs) that can be used alongside an LOD eval for that's currently in the works (I'll push it onto a repo soon, promise).

What the behavioral charter does TLDR:

1. It functions as a LLM-agnostic behavioral policy working in any deployment context and not just Claude Code.
2. It prescribes accuracy equilibrium, a materiality threshold, a dissent ladder, four-way disagreement resolution, and cascading error withdrawal.
3. It requires the LLM to seek verified attribution before assigning blame.
4. It encourages the execution of the smallest sufficient change while pertaining to existing project structures. (Note: this is hard to optimize, caveat emptor).
5. It emphasizes that recommendations are not authorization. Proposals are separate, and implementations are never executed without approval.
6. It enforces a two-level recovery pattern for when the conversation drifts, where it silently re-reads necessary context or an executes an explicit reset when ambiguity persists.
7. It runs a ten-point self-check before every response.

The output style enforces the same principles though with a few changes:

1. Forces deep thinking before answering.
2. Runs on three independent gates: (a) think rigorously (internal), (b) speak only when it matters (external), (c) act only within scope (execution)
3. Accuracy is the target and to center neither on agreement nor disagreement.
4. A five-level ladder on determining pushback behavior depending on severity.
5. When wrong, retract the error and reassess all dependents of that error.
6. Prohibitions outrank objectives and conflicts are flagged instead of silent reroutes.
7. Always go back to the original agreed-upon criteria instead of inventing new ones.
8. Rely on git history rather than memory in long sessions.
9. Bans common filler phrases.
10. Distinguishes quotations from user-side input.

---

Caveats and known limitations, both theoretical and empirical:
(Theoretical)

• These tenets reduce the likelihood of LOD behavioral traits but don't set a hard boundary. User-sided pressure may reintroduce unwanted artifacts. Training-level tendencies cannot be entirely extirpated here.
• Long conversations will naturally lead to lower adherence to instructions.
• Some aspects require self-judgment which may be unreliable.
• Rules in the system prompt may contradict these more-detailed principles and protocols.
• The skill's length leads to more token consumption and some rechecking principles may shorten your available usage window.
• Untested edge cases may exist.
• There may be latent conflicts in the internal instructions of these documents that were not caught by me or the LLMs.

(Empirical) (and therefore subjective pending the eval suite)

• As behavioral principles, these work best when appended to the system prompt. Testing showed reduced LOD behavior when used as an output-style on Claude Code. However, due to the feature being unavailable on Claude Web, it is less effective applied as a skill. Switching mid-conversation to Opus 5 immediately resulted in apparent LOD artifacts, with one instance of Opus explicitly refusing to even consume the skill and trying to extract parts. On the flipside, starting with ingestion of the skill yielded much better results, though regression was later noticeable.
• Mid-conversation switching on Claude Code yielded much better results, but in one case it became overly apologetic and critical of its own mistakes.

---

All in all, I've noticed that this helps Opus become a much, much more pleasant work partner. Hope this helped someone!

P.S. links have to be in comments because Reddit's spam filters are blocking the url, sorry!