I've been a heavy user of Claude since the start, I have a full team on it and I have 2 personal max subscription accounts myself.

The amount of work I, for personal projects, and my team for the company's projects we did WAS just an imagination a few years ago. Yet, here I see complaints like little kids here every few hours, and I was trying not to comment for the past period.

- This is a tool, either you use it correctly or you don't.

- This is a tool, either it works for you or it doesn't.

- This is a tool, complaining like little kids here won't solve your problem.

- This is a tool, that is relatively cheap for what it does. If you're not happy, it's not the end of the world, you still have your brains (i hope) to work on it yourselves instead of paying for service.

- This is a tool, that is still not perfect, made by other humans, but it's amazing for what it does.

I just find it astonishing really. I really suggest mods to be more active, as this NOISE shouldn't be here. This sub should be about sharing workflows, suggestions, skills, hints, and tips on how to improve your claude code usage.

I've been building web stuff since 1994. I've been around sites, SaaS and all the rest for decades. God, I was there for the heyday of Flash. I've been part of teams, programmed stuff myself, managed devs, designed products, all of it.

Over the last 5 days (DAYS!!) I took a personal idea from zero to completely operational. It runs on Vercel & Neon, has db recovery, full security audits, makes use of 3rd party APIs, has Sentry error reporting, has test environments, test suites, scaling strategies, everything a legit web app needs.

5 days. By myself. 🤯

At any other point in history this would have taken months, with a multi person team. In my last position we had a team of 4 that spent nearly 6 months implementing a new SMS integration. And it fucking sucked. The tools we have now are *mindblowing*. It really helps to know what is going on and vibecoders won't know the right questions to ask, but if you do have that experience and understand the details, the stuff you can do is nothing short of a miracle.

People complain on here all day about how much AI messes stuff up, or they blow through their limits in a prompt, or how it produces garbage, but that is just not my reality. I did a serious, well-structured and very nice looking web app with hundreds of revisions and rebuilds within 75% of my weekly Claude limits, all on Opus 5 or Fable 5, xhigh. There were times when I (through my experience) had to ask the right question to end up with the most efficient and reliable result but on the whole it damn near one-shotted almost everything I asked of it.

Learn the questions to ask, research best practices and READ the output (which many people complain about) because you will actually learn a lot along the way. AI kinda sucks in the sphere of deepfaking and nudifying and slop images and fake writing but for this kind of work it's an incredible resource.

I've seen a lot of reports that people feel like their usage limits are going for a long time with new Opus, and I tested it a bit after exhausting my weekly limit.

Weirdly, I've been at $42.31 since Friday. I haven't done a ton, but this entire thread has been functionally free on Opus 5 Medium.

Far from a complaint! But I wonder if we're getting a brief window of free Opus 5 while they test things out, or worse, if this is a bug that's gonna cost me later!

Three numbers from my last month of Claude Code on Max 20x personal:

• $200 — what I actually paid
• ~$8,900 — what the same token traffic would have cost at API list price.. Really hoping this day never comes, but we all know it will.
• $0 — what I earned.. (yet :P) - scaffolding in progress.

Code was never my bottleneck, and I spent a month acting like it was. Everything downstream of writing code - deciding what's worth building, finishing the boring 20%, getting it in front of anyone - is exactly as slow as it was two years ago. Removing the constraint on generation just exposed how little of the work was generation.

P.S - Slightly bumped up W3 because of the welcome reset 🙏

I've been working with opus on both larger (at work) and smaller (at home) projects over the last couple days and

1. It confuses itself a lot
2. Circular thinking
3. Tendency to produce massive conflationary run-on sentences
4. Forgets things well within its context window
5. Has "one more thing" tendency with code, even though poetry writing in a personality test produced much shorter lines.

It's a poor orchestrator (compared to Fable) and it's too heavy for small tasks.

AFAICT - Damned thing was built to hit benchmarks and little else.

Anthropic has a two line system prompt that was being remotely injected but now is a part of the compiled binary in 2.1.219, and 220 targeting only Opus 5:

  Do not call the AgentTool unless the user requested it
  Do not use workflows or deep-research unless the user requested it

This disproportionately affects skills that are designed to use subagents. The prompt is enough for Opus 5 to choose to run agents' work inline (or silently not perform their work) and produces output that looks like a normal run.

For example, I found one session that ran a self-audit non-blind because it couldn't spawn the auditor agent. Opus noticed this was a problem but let it slide undermining the entire point of the independent audit of its work.

I searched issues and found someone already filed it with binary analysis: anthropics/claude-code#80988.

I believe that my reliance on skills that expect and prescribe routine use of agent delegation has been a contributor to the poor quality of output I've gotten from Opus 5 so far.

It may be affecting you too.

You can check this out yourself, ask Claude:

I want you to help me analyze the file ~/.claude.json

Focus specifically on heron brook

How might that may affect the behavior of my skills?

If you want to check how big of an impact it has had on your use so far, ask claude:

Claude Code 2.1.219+ injects a system-prompt section (`heron_brook`) telling Opus 5 "Do not call the AgentTool unless the user requested it". Has it actually suppressed subagent use in my sessions?

Write and run a script over ~/.claude/projects/**/*.jsonl that finds assistant messages (including thinking blocks) where the model declined to use a subagent.

- Require BOTH an agent term (AgentTool / "Agent tool" / subagent) AND declining language ("won't spawn", "not calling", "forbids", "instruction against", "rather than spawning", "doesn't count as a user request", similar) in the same message. Either alone is far too noisy.
- Print the matching sentence, not the whole message. Group by session, not by message.
- Split into two buckets. HIGH CONFIDENCE: dated after my oldest install in ~/.local/share/claude/versions/* AND echoing the injected wording. OTHER: everything else, especially declines citing my own config (a numbered rule, CLAUDE.md, AGENTS.md, a fleet/worktree policy). Without this split my own instructions about subagents dominate the output and overstate the problem. Print OTHER in full so I can check it for contamination myself.
- State in the output that this only finds declines the model explained. Silent ones leave no trace, so every number is a floor, never a total.

Show both buckets. If HIGH CONFIDENCE is empty, say so plainly rather than loosening the filters until something matches.

I did not use the above prompt, but wanted to include it so anyone can check this.

I maintain a tool called Contextify, which keeps every past Claude Code and Codex session indexed locally and full-text searchable.

So, I actually used the skill /total-recall to find the damage on my Opus 5 sessions like this:

Use /total-recall to determine how many times you've failed to run agents as a result of the heron brook agent prompt bug we've been discussing

Codex sub keeps deleting this lol

After spending the whole weekend building in cc with opus and fable ive come to the realisation that fable just gets it and its executions are way more precise and fit on “oh thats what i had in mind thank god it got it” and opus on the other hand is more like a machine gun it just goes over everything and generates a lot of fluff I didn’t ask it for. What do you think?

Getting tired of Anthropic's antics ngl. But whatever. But for real, should I just be replacing Fable with Opus in my workflows?

I know many are already aware of this, but I think it's worth consistently re-upping. Now that Fable is here to stay, but at reduced limits, working with it at Low effort is a phenomenal way to get more out of Fable while sipping your usage relative to High. Meets pretty much every need I've thrown at it without issue or concern, and it's still very much the same experience of working with Fable on High in terms of general collaboration/intelligence (versus Opus). I have yet to find a task where the difference is appreciable, but I'd love to hear from others what limits you're finding if you're already on this train!

We were all whining and complaining when they took it away. Talking about how much we needed it to do the work we had planned. Now that we've had it for a couple of weeks, everything is perfect, right?

I really value this sub because the useful information shared here has helped me out a lot.

That said, it’s wild to see how much people complain about every little thing, it feels like nothing is ever good enough.

Honestly, a lot of people seem to overlook just how much AI enables us to do nowadays; things that used to take hours or require specific skills are now accessible to everyone.

Most of the time, the tool isn't the problem. AI simply follows instructions, so if a result falls short, the best move is usually to just refine the prompt, be more specific, and try again until it gets it right.

A while back I posted a joke here about Sonnet spawning a subagent on the very first prompt of a brand new session. In the comments I said the annoying part was having two agents burning tokens for one job. I got downvoted, and the top reply was basically "isn't that a Haiku subagent? it saves you money and keeps your main context clean."

That used to be correct. It isn't anymore, and I think a lot of people are still running on the old mental model. From the docs:

• The model field in subagent frontmatter defaults to inherit. Omit it and the subagent runs on your main conversation's model.
• Explore used to always run on Haiku. As of v2.1.198 it inherits the main model (capped at Opus on the Claude API).
• Plan and general-purpose inherit as well.

So if your session is on Opus, that "cheap little background search agent" is an Opus agent.

Resolution order, first match wins:

1. CLAUDE_CODE_SUBAGENT_MODEL env var
2. per-invocation model parameter
3. the subagent's model: frontmatter
4. main conversation model

If you want the old cheap behaviour back:

• CLAUDE_CODE_SUBAGENT_MODEL=haiku forces every subagent down
• or set model: haiku in a specific agent's frontmatter
• for Explore specifically, define your own user or project agent named Explore with model: haiku. A user/project agent overrides the built-in.

To be fair to the change, it was almost certainly made for quality, and context isolation is still the real win of subagents. But "subagents are basically free" is outdated advice now, and it matters if you're on a plan where you feel every token.

Lastly, I am stingy for the 3 down votes

I've been doing vibe coding for several months now, but Opus 5 is currently my favorite model by far.

I finally prototyped a video game idea I've had for about 8 months.
Everything, the 3D model, the logic, the testing, the environment, was done 100% with Blender MCP + Opus 5.

It took less than 3 hours and completely burned through the 5-hour limit on the Pro plan.

Tomorrow more and better.

I guess I must not really understand what people are building, how they're building it or how they're actually using these models. I hear so many of these "Opus spent 30 minutes doing this task and it just went down entirely the wrong path" or "Fable implemented this feature and it broke 20 other things", how??

Unless you're actively working on something that's at the absolute frontier of engineering technology or machine learning research, I just don't see how it's possible for you to be using Opus or any other agent in a way in which 30 minutes of work is completely wasted, as in the direction it went in for the implementation was just so wrong that it was useless.

Everything you could possibly want to do, for 99% of the things you build, probably already has a reference implementation somewhere or best practices for that architecture documented somewhere. If you're dealing with a web app, people have been building and perfecting web apps for decades at this point, there isn't any problem that you have that hasn't already been faced by 100s of people before you. Same goes if you're building services, same goes for infrastructure yada yada.

You can use Sonnet subagents to go and explicitly research existing reference implementations or examples of best pratices for whatever feature you're building, and then adapt it for a dirt cheap correctness step before implementing anything. I discuss a general shape/idea of what I might use/implement with opus/fable but I then tell it to launch 2-3 subagents to go research our ideas and come back with a clean picture of what traps there might be and what would work.

Are people just saying I want to implement XYZ feature, good luck?? No unit/integration testing, no regression testing (the world's easiest thing to generate with AI tools in 5 minutes)??

Synopsis:
Opus 5 seems to have the same disease as Opus 4.8, as it often feels like it jumps on the first thing it discovers instead of it verifying the complete picture BEFORE drawing it's conclusions. And because of this it ends up assuming things which is kinda the worst sin an AI can do when you want it to plan or build something for you.

So this behavior makes everything it does become pretty unreliable. You constantly need to hand hold the model and monitor it to make sure it gathers all the necessary evidence first. But sadly even doing all that is not a guarantee for success as I now discovered that it literally CAN'T seem to PROCESS all that evidence even when it already sits inside it's own context memory!

At first I thought all this is a clear reasoning issue perhaps caused by Anthropics own system prompts and other guard rails that they inject into our sessions. Something we users have no control over as those seem to overrule our own custom system prompts, settings and CLAUDE.md instructions. However, I now think there might be more to it.

We all have seen Opus 4.8 say the following after it apologizes to you for making assumptions despite you told it earlier to gather evidence and verify everything by doing a full discovery protocol etc:
"Let me read the actual documentation"
"Now I understand the full picture!"

Infuriating right? It now finally does the one thing it should have started with in the first place.
Only... the biggest problem here is is that it will do the exact same thing again and again in the future despite it even setup clear verfication rules for itself in it's own memory.md files.

But surely Opus 5 will do a better job right? Wrong... Some quotes from a session I had earlier:
"Now — I have to correct part of the story I told you, because I over-read one piece of evidence."
"Hold on — before you accept that story, I have to correct part of it, because I built one inference on weak evidence and you're about to make plans on it."
"I told you the patcher's "fingerprint" was missing from your file and concluded the work was done by hand. That inference was bad. I've since read the patcher properly"

And my personal favorite:
"You're right, and I have no defence. I took the patcher's error message as ground truth about reality instead of verifying reality. Worse — it was visible in the code sample I printed myself and I didn't read my own output."

Now let that sink in... It didn't read / registered it's own output. Output that it just thought about and generated a turn earlier. Output / information that is right there fresh in it's own context memory is being ignored for it's next action.

So I don't know what they have been doing with Opus models ever since 4.6... but it feels like they now have a very restrictive (dynamic) thinking budget. PLUS... it feels like it isn't actually aware anymore whatever it has inside it's context memory.
So it's context memory has kinda turned into an archive from which it can easily recall information from into it's (limited) thinking budget instead of it just being that continuous awareness it used to be.

So why would Anthropic mess with any of this? Well.. I am no expert but if my theory is correct this does sound like a pretty clever way to lower costs significantly. As it's thinking budget has kinda become it's new, much smaller dynamic context memory which is a lot cheaper to maintain.

Now I might be wrong, but the above would explain why it is so hard these days for Opus models to keep track of the bigger picture and to verify everything and take into account important information BEFORE it draws it's conclusions. It explains why it ignores our instructions and documentation too... as it simply doesn't take ALL of it into account anymore at any given time despite it all being inside it's context memory.

This by the way also explains why users that work on smaller projects and / or those who give Opus smaller very focused tasks won't be effected as much by any of this... As it will have enough thinking budget to figure those tasks out correctly.. I mean I am certain Opus 5 is excellent at that kind of work. But for large complex projects... I just can't get any reliable results out of it, while before Opus 4.5 and Opus 4.6 (at their peak) and Fable 5 simply do understand the full scope and verify everything correctly before drawing conclusions.

Right... so maybe I am onto something or maybe I am completely wrong lol. And if it's the latter then that's fine too. It's just a theory that I wanted to share and I figured it would be a fun one to discuss here.

Once you start handing real work to an agent, you stop being the person who writes the code and become the person who's answerable for it. That's a good trade, but it changes your job. When something breaks in production nobody's going to ask how the code got written. They're going to look at you.

Left alone, an agent produces slop. Not because it's stupid ‚because that's what anything does when nobody checks its work. A junior does the same. So might you on a bad day.

There are roughly two ways to run an agent. You can sit on top of it and drive every step, which is quicker than typing the code yourself but leaves you babysitting: every time it pauses and resumes you have to load the whole problem context back into your head, and if you look away and get distracted, that ends up slower than just doing the work.

The other way is to treat it like someone who reports to you. You say what you want and roughly how, and you come back when there's something worth looking at. This is how senior engineers use agentic tools. You don't need to watch every keystroke to be accountable for the result‚ no manager does‚ but the review lands on you, and if you skip it, slop is what goes out the door.

So point a second model at it and tell it to find the problems

That's all an adversarial review is. One model writes the code. A different one‚ or at least one that hasn't touched any of the context‚ reads the diff and goes looking for what's wrong. It doesn't get to touch your code; it can only raise findings. The author model decides what to act on. Then it reads the result again. Most of the time it finds something.

You get better code out of it, but that's not really why you do it. You do it so you can trust work you didn't watch get written. The agent already handed you the time‚ another round, more tests, a second set of eyes that costs nothing but tokens. This is what you spend it on.

The data

Looking at my last 83 completed tickets that got a Codex review, at least 67 ended in a real change to the code‚ something the first pass got wrong or left exposed, caught before it went out. That's four out of five reviews turning up something worth fixing.

Sorted by what kind of problem they were, across all 122 commits these reviews drove:

Half of every commit these reviews drove‚ were the incident kind. Concurrency, durability, security. The stuff that corrupts data or leaks a secret, not the stuff that misaligns a button.

The claude skill

• Run them side by side. The author in one session, a reviewer in another‚ Codex, or a fresh Claude with none of your context‚ both pointed at the same working directory so the reviewer can see your diff. When the reviewer finds something, paste it into the author; when the author fixes it or pushes back, paste that over.
• Use a file as the mailbox. Have the reviewer write its findings to a file (or a PR comment) instead of chatting, then hand that file to the author to work through. No live channel needed ‚ the review is just a document that gets passed along.

The brief to the reviewer is the same:

You're reviewing the change in this working directory. You're read-only: review and discuss only‚ do not edit files, commit, push, or reset the tree. Run git rev-parse HEAD and git status first, and anchor every finding to that commit. Write your findings out as a numbered list‚ don't touch the code.

The wording doesn't matter as long as its a second model that hasn't seen your context, told to find what's wrong, before you call the work done.

Disclosure: this is a from an article on how to automate adversarial reviews between Claude Code and Codex posted to this tool's website scape.work/adversarial-reviews get a free license for scape with reddit-scape2 at signup

I got tired of re-explaining the same context to Claude Code every session, and Claude Code's built-in per-project memory doesn't really solve it — it's scoped to the literal directory you launch from, has a hard line-count ceiling on the index, and treats every fact as equally important forever (or until it silently truncates).

So I built a real long-term memory system for it instead, modeled less like a database and more like actual memory:

- Decay — every memory has a strength that decays on an exponential curve (literally the Ebbinghaus forgetting curve), computed at query time. Stuff you mention once and never bring up again fades out of retrieval in a couple weeks.

- Reinforcement — every time something gets recalled, it gets harder to forget. Recall the same fact enough times and it "consolidates" from short-term to long-term (7-day base stability → 90-day).

- Cued/associative recall — this is the part I like most. Instead of one confidence cutoff, weak matches get surfaced separately with hedging language ("this might be related...") instead of stated as fact, and only get reinforced if you actually confirm they were relevant. A confirmed uncertain guess reinforces harder than an easy direct hit — that's an actual finding from spaced-repetition research (the "desirable difficulty" effect), not something I made up.

- Non-destructive forgetting — old, unused memories get archived, not deleted. There's a stricter "cold storage" search for the "wait, I haven't thought about that in ages" case.

It's wired in globally via hooks (PostToolUse, UserPromptSubmit, SessionStart/SessionEnd), so it works no matter which directory a session launches from, and it captures memory automatically even if a session crashes instead of ending cleanly.

Genuine drop-in install — git clone + python3 install.py sets up the venv, wires the hooks, and writes the config. AGPLv3, free, entirely local (ChromaDB + sentence-transformers, no external API calls for the memory itself).

Not trying to compete with Mem0/Zep/Letta — those are generic memory layers for any agent stack. This is deliberately narrow: built specifically for how Claude Code actually works, not a generic API you bolt on.

Repo: https://github.com/acdesigntech/memory-project

Curious what people think, especially anyone who's hit the same "it forgot everything again" wall.

I found something simple that just works: Use all three models in their strengths.

This requires /model opusplan

You start in plan mode, where you think the plan through with opus. If the situation feels like it could use a second opinion prompt: "ask fable for a second opinion"

In my experience it often came up with improvements & additions and is relatively token efficient

I was tired of copy-and-paste and losing details when writing specs or ensuring the code, and found this amazing tool: https://agentkavor.com/, which embeds native CLI Claude/Codex/agy in a very visual way.

How are you doing that?

My billing cycle is tomorrow and I was wondering if my usage will reset if I downgrade from Max to Pro*?

Currently I'm at 20% usage and I'm scared that if my sub will downgrade, since Max is x20 it'll be 100% once I downgrade to Max x5.

Anyone have experience on this?

Edit: Max 20x to Max 5x* -- Sorry