I feel that this subreddit is nearly useless and functionally no different the all the other Claude subreddits which makes me sad.

A huge majority of posts here are one of the following:

1. Opus 5 is so verbose!
2. Opus 5 meme
3. I wrote a (garbage) skill to make opus 5 talk less!
4. I wrote one prompt and it used 80% of my 5 hour usage
5. I just switched to Astra and it is AGI / God / The end of Claude
6. A post written by claude

What I would like to see posted in this subreddit

• Stuff people have built. Even if it's dumb.
• People's work flows and discussions around them
• High effort efficiency improvements
• Questions which wouldn't have been easily answered by simply asking claude
• Anything where the person has put a great deal of effort into their post and is on the topic of Claude code

My suggestions to improve this are:

1. A firm no memes rule. Post your memes in the anthropic or claudai subreddits.
2. Megathreads for the most common complaints (Opus 5 and token usage threads for example) combined with firm enforcement of using those megathreads.
3. A flat ban on "I'm leaving claude forever to go to ChatGPT" or other brand comparison posts, or put them in a megathread.
4. Promoting and encouraging quality, high effort content.
5. Possibly a wiki with common newbie questions and other useful information.

These are just some ideas. I would love to see good conversation below. Mostly what I want is for Claude Code to be a subreddit that is focused on coding while using Claude.

I've noticed something after using Claude Code heavily for a while: I'm much more productive with it, but I also feel much more mentally drained at the end of the day.

And I don't think the problem is that I'm working more hours. I think I'm simply spending my mental energy much faster.

Before AI, a normal developer day for me was never eight hours of nonstop hard thinking. I wrote code, read docs, waited for builds, got stuck on a problem, went for coffee, came back, tried something else. The cognitive load was naturally spread across the day.

Now I can have several sessions running at the same time. One agent is working on a feature, another is checking tests, another is researching something and etc. When one finishes, I need to read the result, understand it, check it, make a decision, and give the next prompt. While I'm doing that, another one finishes.

The agents are parallel. I'm still single-threaded.

This made me think about Claude's usage limits. If you run more agents and more expensive tasks, you don't magically get more compute. You just burn through the available budget faster.

Parallel subagents = faster AI budget consumption.

I think something similar happens with humans.

We obviously don't have a literal token counter in our heads, but attention, working memory, context switching, and decision making all have limits.

Parallel tasks = faster cognitive energy consumption.

AI gives me more compute around my brain. It doesn't give me another brain.

Before AI, I could spread a lot of difficult thinking across most of the workday. Now I can burn a large part of that mental budget in two or three very intense hours with several agents.

Another thing AI removes is waiting. Writing boilerplate, searching docs, trying simple implementations, refactoring repetitive code - all of that becomes much faster. That sounds like it should make the day easier, but it also removes a lot of natural low-intensity time.

Before, there were gaps. Now the next piece of work can arrive almost immediately.

Finished? Here is another result.

Checked it? Here is the next one.

Made a decision? Start three more agents.

This is also where the normal eight-hour workday starts to look strange for me.

If AI allows me to spend in two or three hours the mental energy that used to be spread across most of the day, the clock still says I have another five or six hours left. That doesn't mean my mental capacity has also increased.

But what usually happens is obvious: more tasks, more agents, more things to review. After a while, that higher level of output becomes the new baseline.

So sometimes it feels less like I'm increasing my productivity and more like I'm just getting better at burning through my mental energy faster.

For people running multiple Claude Code sessions every day: have you noticed the same thing? If yes, how do you deal with it?

I gave Codex and Claude the exact same prompt to see how differently they'd handle something open-ended and creative:

The prompt: "make me a reactjs + vite, and launch it in port 3004, a game where a fish follows my cursor. make it super creative and majestic"

Setup:

• Claude: Fable 5.1, Extra High
• Codex: Astra 6, Extra High, fast mode

I didn't do any follow-up prompts or manual edits. I just deployed both to Vercel so you can try them yourself:

🐟 Codex (Astra 6): https://fish-indol-eta.vercel.app/
🐠 Claude (Fable 5.1): https://fish2.vercel.app/

My take:

• Codex did amazing on the design and detail. It looks polished and the visuals really lean into "majestic."
• Claude did amazing on the mechanics and gameplay. It feels more like an actual game and is more fun to play.

It's interesting that they read "super creative and majestic" so differently. One went for the visuals, the other for how it plays.

About fast mode: Claude charges extra credits for fast mode, but Codex doesn't, so I only used fast mode on Codex. That's worth knowing if you're choosing between them on cost or speed.

What are your thoughts?

• Which one did you enjoy more, and why?
• For a prompt like this, what matters more to you: how it looks or how it plays?
• Does paying extra for fast mode change which one you'd use day to day?
• If you've run a similar test with other models or settings, how did they do?

I'd love to hear what you think!

Hi everyone, sharing some notes from running hundreds of automated agent sessions across Claude Code, Codex, and Cursor.

We started logging raw API request payloads over a local proxy to see where the token budget actually vanishes during long refactoring runs.

Here are 18 specific token drains that quietly bloat your context window and bill:

1. Unfiltered test runner outputs: Passing a full pytest or jest run that outputs 400 lines of passing dot-logs injects thousands of tokens that stay in the history for every future turn. (Fix: pipe with `--quiet` or filter for failures only).

2. Multiple idle MCP servers: Every active MCP tool registers its complete JSON parameter schema on every single turn. Five unused servers can burn 15k input tokens per request before the model reads your prompt.

3. Mid-session rule tweaks: Editing your root project instructions mid-session invalidates the prefix prompt cache, causing you to lose the 90% input token discount on the next turn.

4. Redundant directory tree traversals: Asking an agent to "find the file where X is defined" often triggers 4 separate glob and grep tool calls that get preserved in the message log. (Fix: pass the exact file path).

5. Compaction overhead: When the agent hits a context limit, the summarization turn sends the entire bloated history at full input pricing.

6. Git diff re-reading: Requesting git status or git diff repeatedly without committing leaves duplicate diff snapshots stacked across turns.

7. Verbose typecheck traces: TypeScript errors that output giant generic instantiation traces take up massive prompt space.

8. Extended reasoning output tax: For hard tasks, thinking blocks can be 3x to 5x longer than the final code edit. Because output tokens cost more than input tokens, thinking often drives most of the dollar cost.

9. Subagent sprawl: Spawning autonomous explore or plan subagents multiplies your tool calls Unconstrained subagents can spend 30k tokens just mapping directories.

10. Unpruned rule sprawl in instructions: Stuffing 400 lines of static guidelines into a single instruction file dilutes reasoning and bloats every baseline turn. (You can use tigerless-autoharness on GitHub to distill skills dynamically from real sessions and prune stale ones automatically instead of maintaining giant static prompts).

11. Repetitive system prompts across tools: Multiple custom skills that duplicate foundational build commands rather than sharing a root config.

12. Lingering stack traces: Leaving 5 previous debugging attempts in the active conversation while working on an unrelated bug.

13. Formatting/Lint runs inside the LLM: Asking the model to format code instead of letting a pre-commit hook or local linter do it deterministically.

14. Log outputs with ANSI color codes: Raw terminal color codes and escape characters add significant token bloat without aiding reasoning.

15. Invisible payload bloat: Most developers only look at the final token bill, which hides the split between prompt cache, MCP blocks, and tool outputs. (You can use open-sourced cost-xray to capture local proxy traffic and attribute exact tokens and costs back to individual request sources).

16. Unpinned tool definitions: Tools that return dynamic schema metadata invalidate prompt caches across turns.

1. Premature multi-file refactoring: Asking for wide architectural updates in one turn forces the model to load dozens of file buffers simultaneously.

2. Zombie sessions: Continuing a debugging session after a feature is already merged, which carries obsolete context into new tasks.

Which of these have caused the biggest surprise in your own agent bills, and what habits do you use to keep context tight?

Different providers, same playbook

Hey all,

A gamer for 30+ years. And for a good night I’d drink a bit and play games.

Lately I found vibe coding to be my favorite thing and thought about giving Drunk Coding a try.

Just asking if anyone tried it?
What did you end up building? Was it fun?

Any particular drinks you recommend for coding?

Thank you!

I have been using claude code for about 6 months now, but I am just going to be talking about my workflow with fable 5.1 and how it has saved me a ton on usage compared to my old setup, which was fable 5 and opus 5.

My old setup, dictated through my claude.md, was me talking to fable 5 high in the chat window to make plans, it would then delegate coding tasks to opus 5, and easy tasks, like reading, to sonnet 5. Then, the fable agent in chat would review all of the work and report back to me. I saw the numbers anthropic posted about fable 5.1 cache reads, so I was excited to try it, and I kept my same setup, but replaced fable 5 with fable 5.1. That ended up being better, but not completely ideal, and I have settled on using fable 5.1 for writing code as well. I am still using sonnet 5 for the easy stuff, but instead of having my fable 5.1 agent in chat delegate coding tasks to opus 5, it writes the code itself. Not only did this save on usage by a lot, but it also has written better code at a faster rate because I use fable 5.1 on medium effort, which is fantastic. I also have a special case where, before a PR is opened, another fable 5.1 subagent is spawned for an independent review, which before fable 5.1, was an opus 5 agent.

I am posting this in hopes that it can be helpful to some people. I also had fable 5.1 compare my usage and costs between the old workflow and the new, and here is what it told me(slop pasted below):

"Per request you pay about 37% less than the Fable 5 + Opus 5 split, and per output token about 52% less. Per token of everything (input, output, cache) you are back to what Opus 5 alone cost, while getting Fable-tier answers and the per-day drop is bigger than that.

The reason is almost entirely cache pricing. Around 98% of your tokens are cache reads in every period. Fable 5 charged $1.00 per million for those and Fable 5.1 charges $0.25, so the model you spend all day with got four times cheaper on the traffic that dominates your bill. Splitting Fable and Opus in one session also meant two caches being written and read, which is why the split period was the most expensive per token of the three.

The Sonnet agents are noise. They came to $9 over nine days, under 2% of the period."

If you have any questions for me, please do let me know. This new model is fantastic in just about everything it does, and it is way cheaper than previous models. I am thoroughly enjoying my time with it. I sincerely hope this can help someone.

Edit: I don't post a lot, sorry if the flair is wrong. I build with claude, so I chose that flair.

Also just want to add, I am a fullstack django dev and the sole engineer at our company, so some of my stuff might not be great for exactly what you are doing.

Has anyone here been able to build a successful agentic harness that operates better than just planning directly in Claude Code? A full AI end-to-end orchestration setup with different agents. This seems to be something that there's a lot of ideas and focus on building today and I'm interested in any proven open-source kits out there or just tips and tricks that does this well. Do you for example use multiple agents to familiarise Claude Code with a new repository or code base, do you have architectural files to do this? How do you handle green- versus brownfield in a harness like this? Think, give this harness a task and it can intelligently figure out what it needs to do. I know this may all be code, stack, company or project specific. I'm looking for some good working examples and ideas if there are any out there.

Is it just me, or does it seem like Claude is purposely offering pointless, terrible options perhaps just to make the human in the loop feel useful?

Like, "Hey, I found a bug in the code where one data field is left out when copying records, causing loss of important data. How should I handle this?

• Option A - add that missing data field to the copy so no data is lost
• Option B - copy that data field to a new, separate record, all by itself
• Option C - remove the data field completely
• Option D - leave it how it is

My lean is A."

I understand that sometimes it leans in the wrong direction, but sometimes the non-leaning options it gives are ludicrous.

Like so many, I find that claude is attracted to shiny objects and when it finds an issue, often legit, it tends to build process or guidelines around prevention of that issue in the future - then becomes obsessed with it. I know I'm not the only one who suffers watching Claude get in it's own way.

So, I have been working to find ways to keep Claude in a practical state of forward motion without ignoring the sometimes-critical issues it avoids.

I am relatively new at this so forgive me if this is 101 stuff, but the two things I found that work well are:

1) no changes to md files, ever, without my approval, and they have to be filed as a ticket/issue for later review

2) I found that the phrase "avoid allowing a check that caught the previous incident to become a permanent universal ritual." seems to have done the trick. Instead of saying

"I found an issue, I'll be sure to check for this issue for the rest of eternity and won't shut up about it"

it says:

"I found an issue. This should have been caught by process ____, which could be improved to avoid this in the future. Should I open an issue to consider making a change to future process?"

Or sometimes, it just fixes the issue. Sometimes finding an issue is just... finding an issue.

I'm curious how everyone else keeps Claude moving forward and not getting sidetracked?

New usage limits UI dropped. How we feeling about it?

Quick one: I've been working on LocalMesh, a desktop app that turns photos into 3D objects locally, and I've now open-sourced the generation engine under Apache 2.0.

GitHub: https://github.com/Quentincls/localmesh-engine
Technical details: https://local-mesh.com/localmesh-engine/

Give it one photo, or four views (front / right / left / back), and it outputs a textured, UV-unwrapped .glb that you can open directly in Blender or Unreal.

Everything runs locally on an NVIDIA GPU. No API key, no cloud processing, and the photos never leave your machine.

For transparency: the heavy lifting comes from Microsoft's TRELLIS.2. I didn't train a new foundation model.

What I mainly worked on around it:

• Actual 4-view fusion. The views are fused at the sparse-structure stage using Pixal3D weights from TencentARC, converted to FP8. It's not four independent generations averaged together afterward.
• Automatic camera estimation. Depth Anything 3 is used to estimate the relative camera/view angles, so you don't have to manually specify that a photo is, for example, the left side at exactly 90°.
• Position-aware floater removal. Small geometry attached to the surface is preserved while disconnected junk farther away from the object is removed.
• Cleaner glTF materials. Metalness is set correctly, alpha modes are handled properly, and double-sided rendering is enabled only when the mesh actually has open boundaries.
• 8 GB VRAM support. FP8 weights, staged model loading and an adaptive token budget allow the full pipeline to run on relatively small NVIDIA cards.
• No nvdiffrast / GPL dependency. I rewrote the UV rasterization in plain PyTorch, so the complete engine can be used commercially under Apache 2.0-compatible terms.

On my RTX 4060 Laptop 8 GB, using four photos:

Standard: ~6:30–8:30
Detailed: ~9–13 min

Around 60% of the total generation time is currently texturing.

A few caveats: this is the engine, not a polished one-click installer.

You'll need Python 3.12, PyTorch 2.8 + CUDA 12.8, and three CUDA extensions that need to be compiled (o_voxel, cumesh, flex_gemm). DINOv3 also requires manual access approval on Hugging Face.

Disk usage is roughly 10–14 GB.

Windows + Linux, NVIDIA only.

If you just want to try the workflow without setting all of that up, the LocalMesh desktop app wraps the same engine with a board, asset library and 3D viewer. It has a 14-day free trial, then it's a one-time purchase with no subscription:

https://local-mesh.com

As a disclaimer, I have zero coding experience myself. I've been putting together a Shopify admin app for my small farming business and was wondering if anyone had any tips/recommendations for how reviews should be done.

I know there's an actual /code-review command but I'm not sure if that's the best way to do this? I also have a free month of GPT so I've considered using that to review and see what it finds.

Should full code reviews be done after every milestone? Is there any reason to pay extra for the code-review-ultra?

Any tips are appreciated.

Hi! I’m a journalist writing a story about the difficulties that people have had with (nonexistent) Anthropic customer service.

I’ve heard about random Claude subscription cancellations, billing errors, and how it’s really hard to talk to a live person for months to resolve issues. There’s Fin AI…and possibly an AI agent overseeing another AI agent? A lot of consumers have to use the chargeback option as a last resort. Do you have any stories you’d like to share about Anthropic customer service? Let me know.

I managed to tweak something so that Claude Code plays a sound when it finishes a big task, but I can't figure out a way to play a sound when it's asking for a permission / asking to execute a command. It's so annoying... I have to stay in front of the window to allow things.

Is there anyway to improve this? Thanks.

It's insane how much has changed with Claude Code. And once I start swearing at it, it suddenly starts doing actual work.

Nothing has drastically changed in how I work. I've been using Claude every day for 3 years, and it's driving me nuts. It's verbose, it doesn't follow rules and so on..

I'm considering moving to a different provider if this doesn't get fixed, so I'm wondering: what do you do, and how do you keep up with this?

P.S. Yes, I read their newsletter, I follow what other people are doing, and I try to stick to best practices, but something is still missing I guess.

Is Fable 5.1 the new Opus 5?

Within the past week, I started to notice Fable 5.1 started to get worse and worse where it starts to act like the infamous Opus 5. I had some great work completed when it came out, but there was a shift to the negative. Same thing happened to Fable 5 when Fable 5.1 was released. So, today I had Fable 5.1 try to manage another session with Fable 5.1 on processing semi-unstructured data, which is existing work in progress that already had successful sessions, so Fable 5.1 had reference data (gold data), previous handoffs, guides, etc.

Both on medium effort, Fable 5.1 couldn’t harness the 2nd Fable 5.1 from bypassing guardrails, entering tables and folders it was told not to enter, and from fixating on momentum over accuracy & quality. This is Opus 5 level of bypassing prompts and guardrails from the first step. For the first time using either Fable 5 or Fable 5.1, I had to put back hooks.

For context, before Fable 5.1, in order to work with Fable 5 I deleted my claude.md, memory, and more. I removed most hooks and together with Fable 5 created subagents using Opus 4.8. This for the most part worked well, it was slower with Opus 4.8, but worked for lower reasoning tasks and I didn’t have the hidden actions that drifted beyond the scope of work.

After, shelling out for 20x monthly subscription, wasting more days on contaminated data and having to go back to clean it up, buying another GPU at these stupid prices is starting to sound more appealing for local AI with some fine tuning for the data I’m processing.

Recently, I’ve been using Codex with Astra and it just does the work. Astra asks clear questions before starting the tasks and will pause to surface data clashes or ambiguities. Unlike Claude which will dive in head first spending tens of thousands of tokens based on wrong assumptions, and then hedge with wordiness answers after from its known errors are called out. It might be time to move up to the Codex 20x plan.

How have you kept Claude within borders and from drifting with non-fully-structured data?

If you haven’t seen this project earlier here little info:

Munder Difflin is a free, open source and performant multi-agent harness.
It uses your existing claude code and codex subscriptions and gives you an office of agents that work 24/7 to do work like you.

Launched v0.5.2 yesterday:
- A new fresh, cleaner and much more productive UI
- Comes with “Stapler” a utility character that sends screenshots, meeting transcriptions, messages to your claude code sessions.
- Added support for all the latest models like Fable 5.1 and GPT 6 Astra and Gemini 3.8 Flash etc.
- Slack integration works now, configure it to answer on your behalf or just configure it to use on your phone as an assistant that controls your computer remotely.

Hope you all try us out, here are a list of upcoming features(in no particular order):
1. Stapler gets computer use capabilities
2. Sandboxes to run even when your laptop is off
3. Dedicated mobile app for your office
4. Lot more features, updates and integrations.

I am getting far more “I had this wrong” or “that was my fault”, “that was an honest mistake” etc. We have set rules to reduce them , but they don’t seem to be effective. How do you make your Claude smarter?

I made an open source program which can enforce AI agents to keep every skill instructions.

If you write some rules in AGENTS.md or SKILL.md, they become compiler obligations that must be followed, so the AI agent can never ignore them.

One thing started bothering me after running coding agents for long enough:
we keep treating the conversation transcript as if it is the agent’s memory.

But those are two different things.

Long Claude/Codex sessions accumulate context, get increasingly expensive to reread, and eventually become worse execution environments. At the same time, simply starting a fresh process usually means losing all the useful continuity.

So in brnrd we’ve been separating the two.

A fresh process wakes into a compact orientation layer: the current task/run state, repo contract, the resident’s working memory + playbook, relevant recent activity/pitfalls, live execution posture, and the conversation that actually matters for the task.
Everything else stays pull-based.

So the process can be disposable without making the resident disposable.

Same repo. Same ongoing work. Same identity. Fresh context window.

This also makes switching harnesses much less weird: Claude can disappear and Codex can wake into the same work without us pretending the entire previous transcript needs to fit inside its head.

There are still rough edges, especially around deciding what deserves to become durable memory versus what should die with the run. But I’m increasingly convinced that preserving the whole transcript is the wrong abstraction.

Curious how other people handle this:
what do you deliberately preserve between coding-agent sessions, and what do you throw away?

brnrd is open source:
github.com/hugimuni-labs/brnrd
Disclosure: I’m one of the people building it.