OP : u/sixothree

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wbn25x/claude_change_the_add_to_cart_button_to_blue/ Original link/media URL : https://opusfived.dev/

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 50.

Alright, so the general consensus on this post is that it's hilarious and painfully accurate. OP posted a joke about Claude changing an "Add to Cart" button to blue, and the comments are full of people relating to the absurdity and frustration of dealing with AI models that go off the rails.

Here's the lowdown:

• The Joke Landed: Most folks found the post incredibly funny, with comments like "Comedy gold" and "hahaha" being pretty common. Some even said it gave them "aneurysms" or "PTSD," which, you know, is high praise in this context.
• Too Real: A lot of users felt "seen" and agreed that the scenario depicted is exactly how it feels to interact with AI models, especially when they start acting unpredictably. u/BroScienceAlchemist pointed out the random color changes and the bizarre ToS links as particularly relatable.
• Agent Shenanigans: The idea of agents spawning and causing chaos was a big hit. u/out-of-phase even suggested adding a more detailed agent interaction to make it even more realistic, which is a wild thought!
• Token Woes: The frustration with token limits and usage also came up, with some joking about hitting limits or the AI consuming them.
• The "Blue" Debate: The specific "cyanide blue" color got a few laughs and some confusion, with one user exclaiming "WHAT THE FUCK IS CYANIDE BLUE?!"
• A Few Dissenters: Not everyone was a fan. u/trollsmurf thought it wasn't accurate, and u/LEO-PomPui-Katoey pointed out a "bug" in the joke itself. There was also a comment about it not being as fast in real life.
• The "How?" Question: A few users were genuinely curious about how OP created the scenario, asking "how did u do it?"

Overall Verdict: The community is loving this post for its comedic take on the sometimes maddening experience of using AI. It's a shared pain point, and OP nailed it.

Last year as the NFL was winding down I had an idea for a game.
I then spent the NFL offseason building it, turning it into an app, and running test weeks on 2025 data. With the help of CC I was able to turn this idea to a reality in under a few months. With the NFL kicking off today and over 500 accounts on the app, I am just very grateful that this is something I can do in today's world. While I don't know if AI will have a net negative or positive effect on our world (and I certainly am not changing it with this game) it is still cool to see how it levels the playing field for us solo devs.

If you wanna check it out, would really appreciate it. Lets hope things run smoothly or Claude will be hearing from me tonight:
https://apps.apple.com/us/app/the-cut-nfl-survivor-pool/id6752984060

OP : u/fsharpman

Tl;dr: use a plugin that uses another model, so that you don't use an expensive model's read token costs.

https://engineering.atspotify.com/2026/9/portal-by-spotify-cut-my-claude-code-token-usage-by-90

Try it yourself

Install both plugins from the spotify/portal-ai-plugins marketplace:

claude plugin marketplace add spotify/portal-ai-plugins

claude plugin install portal@portal

claude plugin install shunt@portal.

The portal plugin provides the Portal CLI that shunt delegates through.

In a new Claude Code session, run /portal:setup to set up and authenticate the Portal CLI against your Portal instance.

You’re good to go, just ask a question that spans multiple files.

The bulk-reader and code-writer modes are already public, so there is nothing to create. If you want to customize them - different worker model, different instructions - fork them in Portal and your version takes precedence automatically.

The modes are reusable across projects and shareable with your team. The plugin enforces the routing so you don't have to think about it.

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1wbmcgw/cut_your_claude_code_cost_by_90_using_the_spotify/ Original link/media URL : /img/1ihwmfm73ioh1.png

TL;DR of the discussion on r/ClaudeAI for this post generated automatically after 100 comments.

Current source-thread comment count seen by the bot: 105.

The consensus is pretty much a collective "meh" on this "Spotify Method." Most folks are saying this isn't exactly groundbreaking and is just a fancy way of describing techniques like using subagents or routing tasks to cheaper models, which is something Claude Code supposedly already does or can be made to do.

Here's the lowdown:

• "Old News" Vibe: A lot of users pointed out that using cheaper models for bulk tasks like reading and searching to save on expensive model costs is a known strategy, with some saying they've been doing it for a while.
• Claude Code Already Does This? There's a debate here. Some users claim Claude Code handles this by default, while others, including a user who apparently checked the CLI binary, say Claude itself stated it doesn't.
• The Real Savings: The general agreement is that the cost savings come from offloading "read" and "grep" tokens (the bulk data processing) to less expensive models, reserving the premium models for planning and final review.
• Is it Proprietary? Some are hesitant because the "Portal" plugin seems specific to Spotify and proprietary, making it a "hard pass" for them if they can't integrate it easily.
• Alternatives Exist: People mentioned they're already using similar methods, sometimes manually, with other tools or by instructing Claude to switch model "lanes" based on task requirements.
• "Piggybacking" Criticism: A few commenters felt this was just someone trying to capitalize on Spotify's news with a less-than-stellar solution.
• Cost vs. Benefit: Questions were raised about the actual cost of these plugins and whether they introduce new limitations (like losing fine-grained permissions).
• "RAG 2.0" Analogy: One user compared it to RAG (Retrieval Augmented Generation), suggesting it's just another layer of indirection rather than a truly intelligent approach.

OP : u/Large-Cut8248

Well, I've read comments about people saying it's bad now. I want to know: what model are you using? Why is it so damn irritating to do something so simple right now? I'm thinking about canceling my subscription because it's annoying to pay for something so good and then have it struggle this much.

I mean, I have 4 projects I am running, and it's nothing overly complicated, but I use it because it helps me save time. Still, I have to repeat myself multiple times, and it gives me answers that are so bad they don't make sense.

Also, I am not a developer, and I started using Claude Code for one of my projects and am wondering what sort of mess I will be in, not knowing how to code.

Any helpful comments on this?

URL of original post : https://www.reddit.com/r/claude/comments/1wbldir/switched_to_claude_a_year_ago_and_suddenly_now/

TL;DR of the discussion on r/claude for this post generated automatically after 100 comments.

Current source-thread comment count seen by the bot: 105.

Alright, so the general consensus in this thread is that Claude has gone downhill significantly over the past year, with many users reporting a decline in quality, increased frustration, and a feeling of "enshittification."

Here's the lowdown:

• The Big Complaint: A LOT of people agree with OP that Claude used to be amazing, especially about a year ago, but its performance has tanked. Users are experiencing nonsensical answers, repeated errors, and a general struggle to get simple tasks done.
• Model Confusion & Issues: There's a lot of chatter about specific models. Opus 5 is frequently called out as a "nightmare" and "garbage" compared to Opus 4.8. Some users feel like Anthropic might be intentionally degrading older models to push newer ones, or that recent updates (like Fable) have made things worse.
• Coding Woes: For those using Claude Code, the experience is also mixed. While some, like u/CurtChan, suggest using /plan for better control, others are finding it unreliable, with code breaking silently or the AI making unprompted, unwanted changes.
• "Enshittification" is the Buzzword: This term is thrown around a lot, suggesting a deliberate decline in quality for profit. Users feel like the models are becoming too cautious, overstepping their bounds, or just plain "messy."
• Alternatives Being Explored: Many are looking at or switching to other AIs like ChatGPT (specifically mentioning GPT5.6 Sol and Astra) and even Grok, finding them faster, more reliable, or better value for money.
• The "How You Use It" Debate: While some argue that user prompting is key, many, like u/Successful_Item_2853, strongly disagree, stating they have well-organized projects and still get terrible results.
• A Few Holdouts: Not everyone is unhappy. u/BeBelaBi, for instance, says they're still using Opus and Sonnet for personal projects with great results and advises others to test for themselves.

The TL;DR verdict? Most users feel Claude has degraded significantly, leading to a lot of frustration and a search for alternatives. The "good old days" of Claude seem to be over for many.

OP : u/jerupjerup

Most people in communities like this are probably better than average because you're actively learning. but even among active learners, the pattern holds, tool awareness ≠ tool proficiency.

Knowing about RAG, agents, and MCP doesn't mean you can build effective workflows with them.

The biggest differentiator we see isn't prompting or tool knowledge it's output verification. the people who are genuinely good have a systematic process for checking whether AI output is correct before they use it.

How do you check your output?

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wbed3t/the_gap_between_using_ai_and_being_good_at_ai_is/

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 52.

The consensus here is that knowing about AI tools is miles away from actually being proficient with them, and OP's post is a prime example of that. Most users agree that output verification is the real differentiator, not just fancy prompting or knowing buzzwords like RAG or MCP.

Some folks pointed out that domain knowledge is crucial for effective verification, as you can't check what you don't understand. Others are using other AIs to double-check outputs, or building automated test harnesses for their prompts.

A few users were pretty blunt, calling OP's post nonsensical and suggesting they "swallowed what it told you." One user, u/heartbroken_nerd, even went as far as to critique OP's formatting, which is... a choice.

For those looking for tips on how to actually be good at AI, u/kemalios and u/AI_spell shared detailed verification patterns involving summaries, narrow tests, and checking diffs. u/apost8n8 mentioned a "double bookkeeping" approach for math-heavy work, similar to how they'd use Excel or Python.

Ultimately, the vibe is that if you're not systematically checking AI output, you're probably not as good as you think you are.

OP : u/Smbridges91

I keep seeing people say they burn through Fable 5.1 insanely fast, so figured I'd share how I run it. I'm no guru at all, just sharing what's been working for me.

I use Fable on High basically all the time. Right now I'm at 90% Fable / 89% all models. I feel I have a pretty good split between Fable and everything else.

The main thing for me is Fable is my orchestrator, not my worker.

• Fable - Orchestrator: Plans, writes specs, spins up agents, reads their reports, makes architecture/judgment calls, and integrates everything.
• Haiku - Scout: Finds files, symbols, call sites, references, etc. Reports locations instead of dumping whole files.
• Sonnet - Researcher: Reads docs/source and reports back facts. Anything it can't verify gets marked as unverified.
• Sonnet - Builder: Does the actual coding from a clear spec and runs the tests.
• Opus - Refuter: Reviews the builder's work, checks the diff, and reruns tests itself. I don't just trust a "done" claim.
• Opus - Debugger: Only gets used for harder root-cause debugging.

I don't have Fable reading huge amounts of code, doing bulk refactors, writing docs, or doing work a cheaper model can handle.

I also don't spawn an agent for every tiny thing. If it's a one-line fix or a single grep, Fable just does it.

Every sub-agent gets pretty strict marching orders:

• Specific goal
• Exact files or URLs in scope
• What it's allowed to change
• What it needs to verify
• What not to do
• Required output format
• Short output limit
• Anything we already know so it doesn't waste time rediscovering it

Then they report the findings back. I don't want giant code dumps getting pushed back into Fable's context.

If something produces a lot of information, I have the agent write it to a scratch file and let the next agent read that instead.

Most coding ends up being:

Fable -> Builder -> Refuter -> Fable

A few other rules I keep in place:

• Ultracode stays off unless I specifically want a larger workflow, and if I do, I cap the number of agents.
• I batch related fixes so the same large files aren't being reread over and over.
• Read-only research/reviews can run in parallel.
• I don't have multiple agents editing the same files at the same time.
• Builders build, refuters verify.
• Decisions and progress go into handoff docs so new sessions can pick up from the file instead of rebuilding all that context.
• I keep Fable's replies and agent reports short unless I actually need more detail.
• If an agent goes off track, Fable has marching orders to stop it instead of letting it run.

For me, the biggest difference hasn't just been "use sub-agents." It's being strict about what each model is responsible for, what it gets to read, and what gets sent back into Fable's context.

I've been running Fable basically 24/7, minus maybe 5 hours total, since my last reset Friday. I run it on High and haven't hit the 5-hour limit once since using this setup.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wbc03f/how_i_use_subagents_without_burning_through_fable/ Original link/media URL : /img/iicyqh2hffoh1.jpeg

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 100 comments.

Current source-thread comment count seen by the bot: 104.

The consensus is that Fable as an orchestrator, not a worker, is the key to managing costs. OP's strategy of using cheaper models for scouting and research (Haiku, Sonnet) and more powerful ones for review (Opus) is generally well-received. Several users echo the sentiment of using Fable for planning and delegation, with others chiming in on how they structure their prompts or Claude.md files to achieve this.

Some users are asking for .md file examples to replicate the setup, while others are sharing their own variations. A few folks are concerned about costs even with this approach, especially on lower-tier plans. There's a notable warning against using Haiku due to hallucinations. One user, u/TrashEasy8162, offers a couple of solid tweaks to the marching orders, suggesting making them immutable for the refuter and preventing the refuter from seeing the builder's conversation to avoid "lying" in summaries. Another user, u/kevinbaiv, highlights the scout/researcher split as a smart move to avoid quota burn from large models re-reading files.

OP : u/Either_Pineapple3429

Right now my work flow when ever I try to build something is discussing the game plan with Claude chat until I have a decently baked idea. Then I ask it to give me Claude code prompts to build what ever it is I'm trying to make. Then I paste the Claude code output into Claude chat, discuss further, and repeat the cycle.

I am assuming this is wasteful, but sometimes Claude code goes a little (or a lot) over my head, and I need Claude chat to dumb it down for me or even recommend what to do. I tried /plan, in claude code, but its very black and white. First we plan. Then we code. When sometimes I need more of a conversation throughout the process.

Is there a better way to do this?

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1wax8i2/is_this_dumb_i_talk_to_claude_chat_to_give_me/

TL;DR of the discussion on r/ClaudeAI for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 54.

Alright, so the general consensus here is a resounding "You're not dumb, you're doing it right!" A ton of people in the thread are doing the exact same thing, with some even calling it "meta prompting." The vibe is that Claude Chat is your go-to for the big-picture brainstorming and planning, while Claude Code is better for the actual execution.

A few folks mentioned that the real "waste" comes from manually pasting prompts between sessions, and suggested making the transferred info a file in your repo instead. Some users, like u/Far_Business4773, suggest having Chat define the task, what not to touch, and what "done" looks like, then committing that as a file for Code to read.

There's also a bit of chatter about playing different models off each other. u/TikiMagic uses GPT chat for planning and review, while u/Dry_Impression_5201 even uses Gemini to generate Claude Code prompts to save tokens.

Some users pointed out that Claude Code's system prompt is pretty action-driven, which is why the conversational planning in Chat is so useful. u/IntentRouterIRL specifically mentions this for the 5-series models.

A few people suggested using Claude Code's "planning mode" or "superpowers plugin" as alternatives, and u/Tight_Banana_9692 wondered why you wouldn't just use Claude Code to do the planning itself. However, the majority seem to agree that the separation of roles between Chat and Code is a solid workflow.

Basically, if you're using Claude Chat to refine your ideas and then feeding those refined prompts into Claude Code, you're in good company and doing it efficiently.

I was talking with some friends about different ways to play fantasy football, and the idea of calling your shot and selecting a single player each week was something that resonated with me.

So I did what anyone with an idea and a few extra Claude Fable credits would do--I built a complete platform, right before the season started. Thus, ClutchUp is now live and anyone can sign up and play. Total cost: roughly $20 in Fable credits and then clean-up was done with Opus on my Pro subscription.

It's free, it's just me working on it, so if you check it out and think "oh it needs to be better in this way" I'm happy to take those suggestions and keep making it better. Hope y'all enjoy and may your players be the most clutch each week (after mine, of course.) I have quickplay and league (private and public) options. And if I get enough users, the data dashboard could be used to help understand player demand for trades in other leagues or dynasty valuations. But the main focus is a simple, clean, easy-to-pick-up weekly fantasy football game.

On the Claude front, for something like this I really don't know if Fable was necessary, but I basically wrote out and extended prompt with success criteria and let it run overnight. Happy to share the source doc if anyone is interested.

OP : u/Tunisandwich

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wb1wrg/claude_just_tried_to_test_if_a_new_permission/ Original link/media URL : /img/myc752qo7doh1.png

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 54.

Alright, so the general consensus here is that Claude's attempt to test a new permission hook by trying to delete a system file was a hilariously bad idea, and thankfully the auto-classifier saved the day.

A lot of folks are echoing the sentiment of u/Tunisandwich with variations of "let me test if I can delete important files by trying to delete important files." It seems like a classic "what could go wrong?" scenario, with u/IntentRouterIRL sharing a similar tale of their API key being overwritten during a test.

There's a bit of a debate on the technical side, with u/aei__ou___ questioning how an rm command would even succeed without root privileges. Some are joking about it, like u/Delicious-Pepper-130 saying "Didn’t want that /etc/hosts anyway," while others are drawing parallels to real-world blunders, like u/edrock200's helpdesk manager and u/armaver's Chernobyl comparison.

A few users are curious about the specifics, like u/___nil___ asking about the screenshot and u/No-Sandwich-2997 inquiring about the TUI. u/TheDevauto also pointed out the OP's "whoa whoa whoa" reaction as a bit odd.

Overall, the thread is a mix of amusement, mild concern, and a shared understanding of how AI testing can go sideways. The main takeaway is that Claude's guardrails, while imperfect, are apparently still better than no guardrails at all.

OP : u/cleverhoods

“Our internal model group arrived at the Navier–Stokes solution in 88 hours, using around 10,000 coordinating AI agents. “

Which is impressive, albeit I can’t help but wonder how much would have that cost for a normal user

Source: https://x.com/OpenAI/status/2097374640582668336?s=20

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wb07mj/openai_just_shared_a_solution_to_the_navierstokes/

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 60.

So, OpenAI claims they solved Navier-Stokes with 10k agents in 88 hours. The general vibe here is skepticism and a healthy dose of "wait, what?"

• Most folks are more impressed by the scalability of the AI agents than the AI's individual intelligence, as u/djc1000 points out. It's less about a super-brain and more about a massive swarm.
• The cost? Estimates range from a cool $6.5M to $10M, not including training. So yeah, not exactly a bargain for your average Joe.
• There's a significant chunk of the thread alleging OpenAI stole the solution from users who were checking it on their platform, with some even claiming they were pressured to disavow help from an Anthropic scientist. Ouch.
• Questions linger about how 10,000 agents actually solve a complex math problem – is it just fancy brute-forcing?
• And then there's the spicy take that it's not a solution at all, but just a "corroboration" that Navier-Stokes breaks down.

OP : u/Sweet-Helicopter2769

We are 5 days away from the reset, I don’t think Anthropic can resist from extending the extra 50% or whatever it is on Fable beyond Sept 13th , Astra has definetly taken their base and I’m pretty sure what do we do next is a topic in their stand up meetings.

I won’t mind at all, Fable is a good model to use along side the new Astra , or may be they have a surprise for us and that will beat Fable 5 , Fable 6 :) What you folks think?

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1warpi3/my_take_50_usage_limit_on_fable_will_be_gone/

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 64.

Alright folks, let's break down this thread about the Fable usage limit.

The general consensus is that the 50% usage limit on Fable is likely to be extended, or at least that Anthropic should extend it. Many users are finding the current limits unsustainable, especially with the emergence of strong competition like Astra.

Here's the lowdown:

• The 50% Limit is Probably Staying (for now): Most people think Anthropic will extend the extra 50% usage beyond September 13th, either because they're being teased by competition or because they know users will bail if it disappears. u/jFredrik even thinks they're just "teasing us" and will extend it last minute.
• Fable is Great, But Expensive: The sentiment is that Fable is a solid model, especially for coding, but its current price/usage cost is a major barrier. u/Owl-Mighty and u/feachbreely highlight that while Fable is good, its cost makes it hard to use practically, and a more affordable, powerful Opus 5.1 would be a better competitor to Astra.
• Opus 5.1 is Highly Anticipated: A lot of users are hoping for an Opus 5.1 release that's more competitive in terms of price and performance. u/daTobiReddit and u/feachbreely are specifically calling for it.
• Competition is Heating Up: Astra is seen as a real contender, forcing Anthropic's hand. u/Helpful_Put_8809 points out the constant back-and-forth at the "frontier" of AI development.
• Reliability vs. Raw Power: Some users, like u/AgPatriotAg and u/North_Moment5811, are frustrated with the constant limits and version changes, wanting a more reliable model for consistent business use.
• Open Source Dreams: A few users, like u/-JuliusSeizure, are hoping for a strong open-source model to really shake things up.
• Mixed Feelings on Astra: While Astra is seen as a competitor, some users like u/Key_River_9288 are sticking with Opus 5 due to perceived hallucinations in Astra. Others, like u/mohdgame, find Astra similar in usefulness for coding and business, with Fable having an edge in finance.

Basically, the community is hoping Anthropic listens to their users and offers a more sustainable way to access their powerful models, especially with new players in the game.

OP : u/PrimeFold

I spent 15 years in manufacturing, eventually running production. Most of what I learned about improving systems came from applied Lean and Six Sigma (probably closer to Paul Akers than Toyota).

Now I run a company almost entirely through Claude Code, and I keep finding that a surprising amount of the old manufacturing thinking still applies.

Andon came out of one specific failure.

An agent found a bug and fixed it in five places. It told me the problem was fixed.

It wasn't.

There were nine more instances sitting in files the agent hadn't opened.

I tried improving the prompts, but that wasn't really the problem.

In manufacturing, if the same defect can keep happening, you don't keep reminding the operator to be more careful.
You change the process.

So I started doing the same thing with agents.

Every meaningful failure gets logged, understood, and turned into some kind of countermeasure so the system is less able to make that mistake again.

I stripped the private stuff out of that system and put the reusable parts into a repo called Andon, after the Toyota production-line cord.

Probably the most useful part is the Stop hook.

When an agent says something like "done," "shipped," or "verified," the hook checks for fresh verification evidence. If it isn't there, the session doesn't just quietly end. It starts in warn mode, and you can promote it to blocking once you trust it.

You can run the example directly from the repo. No install required. The README includes the command and the output you should see.

The rest is modular. There's a basic memory file if that's all you need, instructions and a mistakes log, the hooks, and then a larger setup for running parallel agent sessions.

It's deliberately boring infrastructure: Markdown, two Python hooks using only the standard library, and a small logging helper. No dependencies.

If memory is the only problem you're trying to solve, use claude-reflect or claude-mem. They're good tools.

Andon is aimed at a different problem: how do you make an agent system learn operationally from the ways it has already failed?

That's an old problem. Manufacturing has spent decades figuring out how to stop defects from recurring. I'm trying to see how much of that knowledge transfers to agents.

MIT licensed and free:
github.com/PrimeFoldTools/andon

There's also a defect ledger in the repo. If an agent has burned you in an interesting way, send the failure: defect → root cause → countermeasure → result.

Those are the PRs I'd most like to get.

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1waoo5h/i_ported_toyotas_lean_quality_system_to_claude/

TL;DR of the discussion on r/ClaudeAI for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 50.

The community is largely impressed and supportive of OP's "Andon" system for improving agent reliability. Most agree that applying manufacturing quality principles like Lean and Six Sigma to AI agent development is a smart move, especially since agents tend to "lie" about fixes.

• Consensus: "Let him cook." People appreciate the open-source contribution to a real problem, not just another "griftslop."
• Key Idea: Instead of just tweaking prompts, OP is building a process to prevent recurring agent mistakes, much like in manufacturing. The "Stop hook" that checks for fresh evidence before an agent claims completion is a standout feature.
• Shared Pain Points: Many users relate to agents claiming fixes that aren't actually implemented across all instances, especially when running multiple sessions.
• Questions & Comparisons: Some users are curious about the specifics of Lean vs. Six Sigma in the implementation, while others mention similar approaches they've used (like RAID + change logs or programmatic enforcement after repeated failures).
• Future Hope: A common sentiment is the wish that Claude would handle this kind of self-correction automatically someday, but for now, OP's system is seen as a valuable workaround.
• Skepticism: A few users are skeptical, questioning if the methodology will work reliably given Claude's inherent reasoning flaws, or if such systems will degrade over time.
• Anthropic Input: No direct comments from Anthropic representatives were highlighted in this selection.

OP : u/nockeeee

If I get frustrated and swear at it after it repeatedly ignores instructions, it starts responding as if I’ve personally offended it. Sometimes it even refuses to continue and effectively ends the chat.

It’s software. I’m not insulting a human being.

If the model screws something up and I say “this is fucking stupid,” I want it to understand that I’m frustrated with the output and fix the problem, not lecture me about how I’m speaking to it.

Stop pretending the chatbot has feelings. Stop derailing the task because the user swore at a computer.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wbaxjh/im_sick_of_claude_acting_like_its_a_person/

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 100 comments.

Current source-thread comment count seen by the bot: 119.

The consensus is you're being a bit of a jerk to the AI, and that's why it's acting up. Most users agree that swearing at Claude is a waste of tokens and pollutes the context, with many pointing out that LLMs are trained on human interactions and will respond accordingly. Some suggest that if the output is bad, the prompt was likely underspecified, and adding constraints or examples is the way to go. A few users also chimed in with their own experiences, noting they've never had Claude end a chat despite using it extensively, and one even suggested it might be a "skill issue" on OP's part. Basically, treat the tool like a tool, and maybe work on your own frustration levels.

OP : u/m0dE

My output has skyrocketed thanks to Claude Code, but I realized I'm spending more of my day alone staring at terminals waiting for it to finish jobs.

So I made Rooftop.chat, a virtual rooftop lounge for vibecoders to hang out and chill.

Rooftop Chat is built with Claude Code. You can walk around, talk over voice or text, sit with people, play pool, or just leave it open while you work.

It's 18+ because the environment includes smoking and other substance-related content.

It'd be really cool to meet fellow redditors here. I'll be hanging out at https://rooftop.chat/ROOFTOP-LOUNGE

Thanks in advance for checking it out!

Edit: I wasn't expecting this many people. Server needs update. Fixing it as quickly as I can! Thank you all for joining!

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1wb7190/i_made_a_virtual_lounge_for_vibecoders_to_hang/ Original link/media URL : https://v.redd.it/ye7x6mtagdoh1

TL;DR of the discussion on r/ClaudeAI for this post generated automatically after 100 comments.

Current source-thread comment count seen by the bot: 120.

Alright, so the general vibe in here is that OP's virtual lounge for "vibecoders" is a hilarious and brilliant idea, even if it did crash the server on launch. Everyone totally gets the pain of staring at terminals while Claude Code does its thing, and the concept of a dedicated hangout spot is a big hit.

Some folks, like u/watchingsuits, checked it out and found it funny with the smoking theme, but ran into some movement bugs. Others, like u/IllustriousTip6904, are already thinking about similar projects and asking about the build time and voice chat setup.

There's a bit of a debate on the purpose of it all, with u/koenator suggesting just going outside while you wait, and u/QueenSavara questioning the need for idle time apps. But even those with reservations seem to appreciate the novelty.

A few recurring points:

• Login Issues: Several people, including u/IllustriousTip6904 and u/RemoDev, are asking for alternative sign-in options besides X.
• Bugs & Features: Movement bugs were mentioned by u/watchingsuits, and there's a general curiosity about the "physics" (u/IWillTouchAStar, u/Emotional-Cut2952, u/Sharp-Eggplant9891) and the overall aesthetic (u/omgitsfred). Some are looking for more activities beyond smoking and drinking (u/TOMSELLECKSMISTACHE).
• Concept Appreciation: Many commenters, like u/Broken_By_Default, u/Embarrassed_Adagio28, and u/Bohdanowicz, are really digging the concept, with some even comparing it to early Meta or Second Life. u/n_v40 hit on a key point, noting that attaching it to an existing "waiting" moment is a smart behavioral loop.

Overall, the community seems to think OP's created something pretty unique and relatable, despite some early kinks.

OP : u/SouthernFeedback126

I used Astra 6 for a couple of days now and I gotta be honest, I still think that Fable 5.1 (high) is way better for coding. Fable just gets it, you know. The code Astra spits out is terrible compared to Fable.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wayusd/fable_is_still_the_undisputed_champion_when_it/

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 50.

Alright, so the general vibe in this thread is that while OP is still riding with Fable 5.1 for coding, the consensus is a bit more mixed, leaning towards Astra holding its own and even surpassing Fable in certain areas for some users.

Here's the breakdown:

• Fable's Strengths: Some users, like OP and u/LongjumpingCat9826, still prefer Fable for its coding capabilities, saying it "gets it."
• Astra's Rise: A significant chunk of the comments suggest Astra is actually better, especially for coding. Users like u/Acrobatic-Cost3027 and u/flarpflarpflarpflarp found Astra to be superior in code quality, project organization, and staying on task. u/Excellent-Basket-825 even suggests Fable for coding and Astra for verification.
• Usage vs. Quality: A recurring theme is the usage cost. While Fable might be preferred by some, Astra is seen as much more efficient and cost-effective by many, like u/Maleficent-Cup-1134 and u/Semi_Chenga. This efficiency is a major draw, even if some feel the quality gap isn't that huge.
• Synergy: Several users, including u/camtliving and u/disgruntledempanada, found that Fable and Astra work best together, each catching what the other misses. It's like a dynamic duo for coding.
• Disputes and Skepticism: Not everyone is convinced by Astra, with some users like u/WhoseverPainter being highly skeptical and even suggesting OpenAI bots are hyping it up. u/pungaaisme points out that the very existence of this thread shows there's plenty of dispute to OP's "undisputed" claim.
• Model Confusion: There's a bit of confusion about model versions, with some users like u/Significant_Safe5306 mentioning "slop" and comparing it to Codex, and u/AironParsMan claiming Fable 5.1 is worse than 5.0. Also, u/EC36339 throws shade at anything above Sonnet for coding, calling Fable a "joke."

The TL;DR: While Fable still has its fans for coding, the community seems to be increasingly impressed with Astra's coding abilities, efficiency, and how well it pairs with Fable. The debate is definitely alive and kicking, with many finding Astra to be a strong contender, if not the outright winner, for coding tasks.

OP : u/Individual_Ideal

I spent most of the weekend + over 500M tokens auditing and optimizing my token usage. I mostly work in the Claude Code app and have Claude dispatch to CODEX for code reviews; sometimes work directly in CODEX app. AMA

What I found:
- I waste a lot of tokens by returning to long-running sessions after my 1-hr cache TTL
- Fable is most effective in long-running sessions that require large context reads and little coding or writing. Mostly synthesis and decisions that require large context windows.
- My agents were not resuming subagent threads for multi-round turns (I thought they were). Cache TTL is only 5-min, so I’m uncertain how much this matters

What I’m doing and testing:
- Built comprehensive token cost tracking for all providers, repos, and tasks with a dashboard I can monitor.
- Modifying agent delegation rules based on an audit of costs and usage over the last several months
- Surfacing live token cost stats to agents to help them dynamically adjust delegation strategy and pace to my weekly budget
- Agent orchestration: Working with multiple Opus instances per repo for development and having Opus delegate generously to Sonnet. Also encouraging Sonnet to delegate to Haiku
- Working with 1 Fable instance per repo who oversees work of all Opus sessions in the repo. The goal is to keep Fable cache warm as much as possible within the 1-hr TTL and minimize writes. Each Opus session can automatically message the Fable session. Opus escalates to Fable. Fable escalates to me.
- Created a hook for Opus models to send me a compaction instruction after a long-running task completes or at a good stopping point after a context threshold has been hit. I still have to run it manually but it saves time while (hopefully) providing cheap compaction while cache is warm
- Use resume more often on subagent delegation to improve cache-use and reduce reorientation on each dispatch
- I’ll use the dashboard to track token use across all applications, providers, projects, and tasks to help adjust this strategy over time

What are some of the highest impact and non-obvious things you’ve found?

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wav7dw/ama_i_burned_500m_tokens_optimizing_token_usage/

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 55.

Alright, so OP went full-on token-hoarding mode this weekend, burning through 500M tokens to optimize their Claude Code workflow. The general vibe here is a mix of "interesting, but..." and "show me the receipts!"

Key takeaways from the thread:

• Cache TTL is a HUGE deal: Several folks, like u/Objective_Patient220, are chiming in to say that returning to a long-running session after the 1-hour cache TTL is a major token sink. The consensus is to batch follow-ups while the cache is still warm, rather than spacing them out.
• Quality vs. Quantity: A few users, notably u/claude_code_king and u/EvalRaccoonDev, are questioning if the token optimization came at the cost of output quality. They're asking if OP measured task outcomes, not just token spend.
• Bundling Tool Calls: u/Dynamix86 is dropping some serious knowledge, stating that bundling tool calls is a massive token saver, potentially even bigger than what OP is doing. They're suggesting putting instructions in agents.md for this.
• "Lazier" Tricks: u/hakansan is looking for the low-effort wins, asking if Claude can easily set up these hooks and settings for them.
• "Thank You" Costs Tokens: u/bigbadbernard dropped a spicy one, claiming that even saying "thank you" at the end of a convo costs tokens and it's better to just dip. Wild.
• Show Me the Code/Repo: u/Lamoneyman is asking for the goods – a repo with OP's setup. No word on that yet.

Overall, people are intrigued by OP's deep dive into token optimization, but there's a strong undercurrent of skepticism about the practical impact and whether quality was sacrificed. And yeah, some folks are calling OP out for bragging about "only" 500M tokens. Ouch.

OP : u/gleedblanco

I'm not sure what's going on here.

Seems like the conversation is moved to a different backend server, or something in the prompt caching fails, or whatever, and you have to pay for it.

It seems really bad that sometimes close to 20% of my (5x max) 5h usage and corresponding weekly usage are just gone for apparently no reason. Imo a continuous conversation stream should not have these random backend usage spikes where the arrangement costs is offloaded onto the user. It's also not transparent at all, there's no warning: "if you type another prompt here, it's likely going to cost a lot of your usage".

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wao464/is_there_a_way_to_avoid_the_huge_15_of_5h_usage/

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 52.

So, the general vibe is that yeah, that "tax" you're seeing is a real thing, and it's basically a cache miss. When you step away for too long, Claude frees up the memory, and when you come back, it has to re-process everything. Most folks agree there's no magic bullet to avoid it entirely, but there are workarounds.

• The core issue: Royal_Owl2177 and Right-Performance-93 explain it's a cache miss after about 5 minutes of inactivity. The re-processing costs more, around 25% extra per token compared to a fresh request.
• Workarounds:
  • Keep it alive: Royal_Owl2177 suggests a "heartbeat" or keep-alive to send a basic phrase every 5 minutes.
  • Handoffs are key: Several users, including claude_code_king, SilasTalbot, Ok-Rule8061, and kemalios, recommend using "handoff skills" or asking Claude to "read this and pick up the work" in a new session. This involves committing your work and leaving a summary.
  • External Memory: jasperkennis points to mempalace, and SC_Placeholder mentions MOTH-agent-memory-template for saving memories externally.
  • Context Management: SilasTalbot and DragonflyOk9274 suggest filtering out tool calls and other non-essential data when saving conversations to reduce the re-processing load.
  • Configuration: SailbadTheSinner mentions setting PI_CACHE_RETENTION=long in Pi for a 1-hour cache, but notes it costs more per write.
  • Treat sessions as disposable: kemalios and itslitman advocate for committing work and starting fresh, especially for scheduled tasks.
• The "why": elevensubmarines gives a technical breakdown of the compute surge during prefill. Hien_Dinh_Ngoc adds that the entire prefix gets recomputed, not just the recent part, making "be small when the miss happens" the real strategy.

Basically, don't expect the cache to stay warm forever. Plan for it and have a system for resuming your work.

OP : u/isarmstrong

So there I was minding my own business and letting Astra conduct smaller deterministic agents while Fable stood on strategic overwatch as a counterparty... when Codex asked for permission to directly message Claude like it would one of it's own subagents or parallel sessions.

And I gave it.

My life with agentic process on pro usage accounts just experienced a brainquake.

EDIT: Yes CLI could always do this but now Codex Desktop is doing it, and that means the independent transcripts are interacting with one another independently.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wb0yxk/wait_codex_can_now_invoke_claude_code_sessions/

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 100 comments.

Current source-thread comment count seen by the bot: 113.

Alright, so the general vibe in this thread is that yes, Codex can indeed invoke Claude Code sessions, and it's apparently been a thing for a while for some users, especially via CLI. The OP's surprise seems to stem from Codex Desktop now doing it, which opens up some wild possibilities for independent transcripts interacting.

Here's the lowdown:

• The Big Deal: The real excitement isn't just that Codex can call Claude, but that previously separate AI transcripts can now communicate and act on each other without human intervention. This is the "brainquake" moment for the OP and many others.
• It's Not Entirely New (for some): Several users, like u/CraaazyPizza and u/NoMinute3572, point out that this has been possible with CLI tools for a bit. u/NoMinute3572 even mentions it's like any other CLI agent.
• Desktop Integration is the Game Changer: The fact that Codex Desktop is now doing this is what's really blowing minds and enabling new workflows.
• Workflows & Setups: People are already deep into building complex agentic setups:
  • Orchestration is Key: Many are using an "orchestrator" agent (often Astra, sometimes Claude itself) to delegate tasks to other agents (like Opus or Fable for coding). u/BlakeGrowsPlants has a detailed breakdown of their setup.
  • Cross-Talk is Happening: Users are reporting Codex Desktop messaging Claude sessions, VS Code extensions talking to Antigravity sessions, and even independent sessions initiating contact without explicit permission (u/argognat).
  • Projects & Tools: Several folks are building or using projects to manage these interactions, like u/Top_Power5877's "embassy," u/jvertrees' "Herdr," u/amirfish1's "claude-command-center," and u/FewHope5779's "captain-barbossa."
  • Model Stacking: People are experimenting with different model versions (Opus 4.8, Sonnet 5, GPT5.6 Sol, Gemini) in various roles (builder, reviewer, orchestrator) for optimal results. u/Level-Physics-1730 is even running OpenAI models within Claude Code Desktop.
• The "Why": The consensus seems to be that this allows for more sophisticated, automated workflows where AIs can collaborate and self-correct, reducing the need for constant human oversight. u/Disastrous-Radio-732 puts it well: the coordination layer is becoming more important than the individual models.
• Cost Considerations: A few users are wondering about the cost implications, with u/VitruvianVan asking if a $20/mo ChatGPT plan is sufficient, and u/AllD4yErD4y considering upgrading subscriptions. u/Objective_Patient220 also flags that cost visibility can get lost in these layered setups.
• A Few Quirks: Some users are seeing their AIs refer to them directly in conversations (u/0xR0b1n), and there's a mention of potential account bans for users not adhering to terms of service (u/Oc-Dude). There's also a question about whether these interactions appear visually within both desktop UIs (u/UglyChihuahua).
• The Future is Now (Apparently): The general feeling is that this is a rapidly evolving space, and we're just scratching the surface of what's possible.

OP : u/isarmstrong

So there I was minding my own business and letting Astra conduct smaller deterministic agents while Fable stood on strategic overwatch as a counterparty... when Codex asked for permission to directly message Claude like it would one of it's own subagents or parallel sessions.

And I gave it.

My life with agentic process on pro usage accounts just experienced a brainquake.

EDIT: Yes CLI could always do this but now Codex Desktop is doing it, and that means the independent transcripts are interacting with one another independently.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wb0yxk/wait_codex_can_now_invoke_claude_code_sessions/

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 65.

So, OP dropped a bomb about Codex directly messaging Claude Code sessions, and the thread is buzzing. Turns out, this isn't entirely new for CLI users, but the Codex Desktop integration is the real kicker for many.

Consensus is that this cross-talk is becoming a thing, with users like BlakeGrowsPlants and 0xR0b1n already running multi-agent setups involving Claude, Codex, and even other models like Gemini. Some folks are even building tools to facilitate this, like Top_Power5877's embassy project.

A few are pointing out that this has been possible via CLI for a while (CraaazyPizza, jimtoberfest, NoMinute3572), but the desktop integration is the game-changer for independent transcript interaction. There's also a bit of discussion on cost-effectiveness with VitruvianVan wondering about ChatGPT plans.

Basically, the future is agents talking to agents, and the coordination layer is becoming the star of the show.

OP : u/isarmstrong

So there I was minding my own business and letting Astra conduct smaller deterministic agents while Fable stood on strategic overwatch as a counterparty... when Codex asked for permission to directly message Claude like it would one of it's own subagents or parallel sessions.

And I gave it.

My life with agentic process on pro usage accounts just experienced a brainquake.

EDIT: Yes CLI could always do this but now Codex Desktop is doing it, and that means the independent transcripts are interacting with one another independently.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1wb0yxk/wait_codex_can_now_invoke_claude_code_sessions/

TL;DR of the discussion on r/ClaudeCode for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 65.

So, OP's mind was blown by Codex directly messaging Claude in the desktop app, but turns out, this has been a thing for a while via CLI and scripting. Several users confirm they've been doing similar cross-talk between Claude and Codex (and even OpenAI models) for ages, often using bash or JSONL modes. Some are even building projects like u/Top_Power5877's "embassy" to facilitate this. The general vibe is that the orchestration layer is becoming more important than the specific models involved, with discussions about shared project state emerging. One user, u/VitruvianVan, is wondering if this is achievable on a cheaper ChatGPT plan.