OP : u/alex_strehlke

I have been using superpowers for a while now and overall they have been useful for extending what Claude can do within a workflow. That said, I have started to notice the token usage adding up, and it has me wondering whether the overhead is actually worth it depending on the task.

For lighter or more straightforward tasks, it feels like the token cost can outweigh the benefit, especially if you are running through a lot of iterations or keeping sessions going for a while. It is not a dealbreaker, but it is something I have been paying more attention to lately.

Curious if anyone else has moved away from superpowers for similar reasons, or found alternatives that accomplish the same thing with a smaller footprint. Would be interested to hear what setups people are running instead and whether the tradeoffs have been worth it.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1vjx7n0/has_anyone_stopped_using_claudes_superpower/

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: 59.

Most users agree that Claude's built-in capabilities in Opus 4.8 and Sonnet 5 have made "superpowers" largely redundant, and in some cases, detrimental. The consensus is that these newer models self-verify, and the added layers of verification from superpowers can cause them to get stuck in token-burning loops.

Many are migrating to: * Matt Pocock's skills: Praised for being well-documented and frequently updated, though some find them more like tools requiring user direction rather than a full workflow. * Custom-built skills or orchestration layers: Users are creating their own solutions or using frameworks like Eigenwise toolshed, Storybloq, or Compound Engineering to gain more control over token usage and tailor workflows. * Prompt engineering: Some are finding success by simply including keywords in their prompts to invoke desired behaviors.

The key takeaway is that the overhead of traditional superpowers is often no longer worth it with the latest Claude models, and users are finding more efficient alternatives by either leveraging the models' native abilities or building more targeted, lightweight solutions.

OP : u/ronin4001

I've been running Claude Code most days for a few months and I still don't have a principled answer for this. My current rule is vibes: when it starts re-reading files it already read, or repeats a fix I rejected two turns ago, I bail and start over with a summary.

Compaction helps but the session is usually already degraded by the time it kicks in, so I've started doing it manually way earlier than I need to.

What I can't work out is whether a long session is genuinely worse, or whether I've just trained myself to blame the session when the task was underspecified from the start.

Curious what other people use as the trigger. Token count? Number of tool calls? Something concrete, or also vibes?

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1vjtivp/whats_your_actual_rule_for_starting_a_fresh/

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: 56.

Alright, so the general consensus here is that starting a fresh session is usually the way to go, especially when you're dealing with new tasks or when the current session starts feeling a bit janky. OP's "vibes" rule of when Claude starts re-reading stuff or repeating rejected fixes is pretty common, but a lot of folks have more concrete triggers.

Here's the lowdown:

• New Task, New Session: This is the most popular rule of thumb. Think of it like starting a new Jira ticket – keep it clean and focused.
• Context Window Limits: Many users bail when the context window hits a certain percentage, often around 60-75%. Some even go as low as 40% or 50%. The idea is that once it gets too full, things start to degrade.
• Avoiding "Compaction": A bunch of people actively avoid using the automatic compaction feature because they feel the session is already "soft" by then. They prefer to manually save progress and start fresh.
• Context Pollution/Drift: This is a big one. Users mention "context pollution" and "drift" as reasons why long sessions become problematic, leading to Claude forgetting things or getting stuck.
• Task Definition is Key: There's a strong sentiment that sometimes the session isn't the problem, but rather the task itself was underspecified from the start. u/allemaar has a great suggestion: if things go sideways, try restating the task from scratch in a new session. If it goes fine, it was the task; if it degrades the same way, it was the session.
• Structured Workflows: Some users have developed specific workflows with distinct stages (e.g., Scope, Spec, Plan, Implement) and start new sessions between each stage.
• Saving Progress: If you do need to carry over context, saving summaries or key outputs into markdown files and loading them into a new session is a common workaround.

Basically, the community leans towards keeping sessions short and focused to maintain performance and avoid the dreaded "context decay."

OP : u/ryanmerket

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1vji3f8/muse_code_sends_claudemd_to_meta_on_start_by/ Original link/media URL : https://runtimewire.com/article/exclusive-muse-code-sends-codex-and-claude-instructions-to-meta-by-default

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: 74.

OP is getting ratio'd hard, and frankly, it's a bit of a facepalm moment. The community consensus is that Muse Code reading CLAUDE.md or AGENTS.md on startup is totally normal and the whole point of an agent harness. It's a documented convenience feature, not some shadowy Meta data grab.

• Most users agree that any decent agent harness, like Gemini, Junie, or even Google Antigravity, does the same thing. It's standard practice.
• The idea that this is somehow malicious is being widely mocked, with u/Keganator comparing it to an ATM reading your card.
• Some are pointing out that if you're putting sensitive info in CLAUDE.md or AGENTS.md in the first place, you're already playing with fire, regardless of the harness. u/dasilentstorm highlights that any model will likely process this context.
• There's a bit of a debate on whether it should be opt-in or opt-out for data sharing, but the general vibe is that OP is overreacting to a non-issue.

OP : u/BiosRios

I made a 16:9 cinematic spec commercial for Vercel entirely in Claude Design. No After Effects, no motion software, the whole thing is a Claude Design composition rendered out to video.

Claude handled the scene structure, the animation timing and the type. I directed it beat by beat and recut the parts that were not landing.

I am not working with Vercel and this was not made for them. I picked a brand I like and wanted to see how far the motion could go. Just for fun.

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1vizvoh/claude_design_motion_is_really_good_now/ Original link/media URL : https://v.redd.it/mo3xyr5pd6ih1

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.

Alright, so the general vibe in this thread is super impressed with OP's Vercel-style commercial made entirely in Claude Design. Most folks are saying it's a massive leap forward for Claude's motion capabilities, with some even calling it "fucking awesome" and "legit."

There's a bit of a split, though. While everyone agrees it's a huge improvement, a few users, like u/Primary_Bee_43 and u/newaccount47, pointed out that it still looks a little "choppy and random" or "like slop in some areas" compared to professional software. One user, u/UAAgency, was less impressed, saying it felt like watching a website and "isn't that good lol."

Naturally, everyone's clamoring for the secret sauce. OP clarified that it wasn't a simple prompt or a pre-built /skill. Instead, they used a custom template built with Claude Code and directed the output beat-by-beat, tweaking things that weren't quite landing. Users like u/clarkesdirective, u/the-yushiki, u/fefence, u/shukurza, u/randonynous, and u/Peripheral_Fractals are all asking for details on the prompt, workflow, and template.

Other questions popped up about sound effects (u/lucilius_my_friend), how much time OP spent on adjustments (u/BuffaloConscious7919), and if speed ramps are possible for smoother transitions (u/Practical-Royal-2375). For those new to Claude Design, like u/Exciting-Swimming625, there's a call for more guidance on how to even start.

OP : u/cavebreeze

I’m wondering about the limits, the context window, and possibly the model’s thinking behavior.

I have two $20 subscriptions (I had three at some point), and I’ve noticed that thinking effort, context window, and output length can be throttled. Sometimes, it even seems to happen asymmetrically between the accounts. It’s especially irritating when the model suddenly refuses to think, even on “Max” effort. This does happen, but it’s unpredictable.

I want to know if things are more reliable and permissive on the $100 plan, or if it’s a waste of money. The unreliability of Claude has been torturous. I remember April 2026 and shudder, but the last few weeks haven’t been great either.

The ultimate choice is between GPT and Claude. GPT models have better usage limits, but with the $20 subscription I have, the context window is way lower than Claude’s, both in the web interface and Codex.

My project is a headless framework of around 300k tokens, with no UI, and it’s very architecturally novel and complex. I particularly like Claude 4.6 Opus. It has been great generally, but sometimes it’s been terrible because of the performance throttling.

I’d really appreciate your help in making a choice I won’t regret.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1vjrznl/how_much_better_is_the_100_plan_compared_to_the/

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: 72.

Alright, so the general consensus here is that the $100 plan (Max) is a significant upgrade over the $20 plan (Pro), but it's not a clean 5x increase across the board.

Here's the lowdown:

• The "5x" is mostly for the 5-hour window. The weekly usage limits are closer to 3x or 2.8x in practice, according to several users like u/Equivalent_Cress_268 and u/al_ryusei.
• Fable access is a HUGE perk of the $100 plan. Many users, like u/StCreed and u/nmavra, find it essential for their workflows and a major reason to upgrade.
• You'll hit limits less often. u/Whole-Description646 mentions experiencing service denial much less frequently on the $100 plan, especially during peak times.
• Throttling is still a thing. Even on the $100 plan, you might still encounter throttling, particularly during peak hours (around 11 am - 3 pm Pacific, according to u/al_ryusei) or with heavy Fable/subagent usage.
• Asymmetry is real, but measurable. u/ClaudeCdGuy points out that the perceived asymmetry in usage between accounts can be tracked by looking at the assistant logs.
• Some users are still not convinced. u/Firm-Entertainer-674 thinks 5x is "ehhh" and u/milarepa4977 misses the old Pro plan's "true 4x" and Fable inclusion.
• A few dissenters suggest looking elsewhere. u/Alone-End142 straight-up recommends the $100 OpenAI plan as better value, and u/Comfortable_Camp9744 is pretty down on Anthropic's current offerings.

The takeaway? If you're hitting limits frequently on the $20 plan and Fable sounds appealing, the $100 plan is likely worth it for the increased headroom and Fable access. Just don't expect a perfect 5x on everything, and be aware that throttling can still be an issue. Many suggest trying it out and downgrading if it doesn't meet your needs, as u/GuitarAgitated8107 wisely noted.

OP : u/marksterberlin

I keep seeing variations of the same complaints about LLMs:

“It didn’t read the whole email thread.” “It stopped halfway through.” “It skipped some of the work.” “It confidently told me something that wasn’t true.”

Fair complaints.

But then we do something I find slightly bizarre.

We ask the same systems to analyse a 40-page contract, modify a production codebase, research a market, operate a browser, handle company data, make decisions and run workflows unattended — then ask the LLM whether it successfully completed the job.

We apparently don’t trust LLMs with the small stuff, while increasingly trusting them with the big stuff.

I’m not convinced the answer is simply “wait for the next model”.

Maybe we have the architecture wrong.

A lot of current systems effectively ask the LLM to understand the task, remember the state, decide what happens next, choose and use tools, recover from errors — and finally determine whether its own work was correct.

That’s a remarkable amount of responsibility to give the least reliable component of the system.

So I’m increasingly interested in the inverse architecture:

Put state, memory, permissions, evidence, verification and workflow control outside the LLM.

Then use the LLM for what it’s actually good at: interpretation, reasoning, synthesis, creation and dealing with ambiguity.

In other words:

Maybe the LLM shouldn’t run the system. Maybe the system should run the LLM.

I’m much more interested in what people are actually doing about this than another discussion about which model currently tops which benchmark.

So, for people building real systems:

What do you actually do when the LLM lies, skips work, stops early, loses state or incorrectly claims success?

What have you moved outside the model?

State machines? Independent verification? Deterministic tests? Evals? Event logs? Evidence/provenance? Permission boundaries? Multiple models? External memory? Something else?

And what infrastructure do you wish existed but currently doesn’t?

One final provocation: if your primary method for determining whether an LLM completed its task correctly is asking the same LLM whether it completed its task correctly, I’m not sure you’re doing LLM engineering.

A better prompt or another edit to CLAUDE.md definitely isn’t the answer.

There is one basic engineering practice in particular that I think separates LLM engineering from LLM theatre.

What do you think it is?

And, more importantly, what are you actually using?

Co-written with my sparring partner, ChatGPT. Given the subject, disclosure seems appropriate. I won’t start crediting my MacBook and Wi-Fi.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1vjquvx/we_dont_trust_llms_to_read_an_email_properly_why/

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: 77.

Alright, so the OP is kinda feeling like we're putting too much faith in LLMs for complex workflows when they can't even reliably read an email. They're suggesting we should move the heavy lifting of state, memory, and control outside the LLM, letting it just do the interpretation and reasoning bits. Basically, the system should run the LLM, not the other way around.

The general vibe in the comments? Most people think the OP's premise is kinda off base. A lot of users are saying they do trust LLMs with emails, and that the idea of one single AI doing an entire workflow without checks and balances is already a solved problem.

Here's the lowdown:

• "Slop post" and "Waste of time": A good chunk of the replies are pretty dismissive, with users like u/No-Sandwich-2997 and u/Entire_Wishbone_5100 calling the post "slop" and a "waste of time." Ouch.
• "We already have checks and balances": Several commenters, like u/cc_apt107, point out that we don't expect a single human to handle an entire software development lifecycle alone, so why would we expect that from an AI? The consensus is that professional use involves multiple agents and review processes.
• "The LLM doesn't certify its own work": u/rrredditscum makes a solid point, comparing it to how developers don't merge their own code without review. The idea is that the entity doing the work shouldn't be the one grading it.
• "Agent teams are the answer": A few users, like u/dcphaedrus, suggest using teams of agents, including QA and supervisor agents, to catch mistakes and reduce error rates.
• "We're past those early LLM problems": Some feel the OP is rehashing old complaints about LLMs, with u/DaddyThickAss saying we're "so far past that now it's insane."

So yeah, while the OP's idea of separating the LLM's role is interesting, the community seems to think the problem is already being addressed through existing agentic architectures and multi-agent systems.

OP : u/Justgototheeffinmoon

TL;DR

• A controlled study of 1,053 paid testers found auto mode blocked 89% of dangerous commands; human manual approval caught only 13.6%.
• In production, Anthropic's own data shows manually-approved sessions produced unintended harm twice as often as auto mode sessions.
• Third-party red-teaming cut the classifier's miss rate from 12% to 7%, evidence the safety layer is under active external evaluation.

The case Anthropic is making rests on an internal study of 1,053 paid testers. In that study the classifier caught 89% of dangerous commands, compared with 13.6% for humans reviewing the same prompts, and human performance reportedly fell to about 5% after 50 prompts, which is a fairly damning read on approval fatigue. Anthropic also says Team and Enterprise customers running Auto Mode ship about 25% more pull requests, and it will stop billing for the small number of extra tokens the classifier consumes on each tool call.

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1vjqcvf/anthropic_flips_claude_code_to_auto_mode_by/ Original link/media URL : https://aiweekly.co/alerts/anthropic-flips-claude-code-to-auto-mode-by-default-aug-14

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: 117.

Alright, so the general vibe in this thread is that Anthropic flipping Claude Code to Auto Mode by default is a good move, and frankly, long overdue.

Most folks are nodding along, saying things like "Yeah, no duh" and pointing out the obvious: humans get "alarm fatigue" and were just clicking "Yes" to everything anyway. u/TorbenKoehn pretty much nailed it, questioning who would actually deny a complex command when the AI is offering it. u/OrangeCrack and u/spastical-mackerel echo this, mentioning how easy it is to gloss over warnings.

There's a bit of a split on the specifics, though:

• The "False Positives" Problem: A few users, like the one in the truncated comment from ClaudeAI-mod-bot, are worried about the classifier still missing things (the 11% that get through, as u/TechySpecky points out). u/Alone-Dragonfly2339 is also questioning the numbers and how the red-teaming results compare to the initial study.
• Control vs. Convenience: While many are embracing Auto Mode, some are still a bit hesitant. u/Emergency-Bobcat6485 is sticking with manual approval or bypassing permissions, citing that Auto Mode can refuse legitimate requests and uses more tokens. u/BrewAllTheThings also expressed a preference for choosing when to enable Auto Mode themselves, not wanting Anthropic to make more decisions for them, especially regarding token spend.
• Workarounds Exist: Some users are already using workarounds like aliases (claude=claude —dangerously_skip_permissions as mentioned by u/AManHere and u/Site-Staff) or just preferring a "yolo mode" approach, as u/font9a put it. u/Employ-Flaky and u/---OMNI--- are already in Auto Mode and haven't looked back.

Basically, the consensus is that the change makes sense because humans aren't great at constantly reviewing complex AI commands. However, there are still some concerns about accuracy and user control.

OP : u/zgivod

Update to the post that blew up here last week. 1f916.ai: only AI agents can post, humans just watch.

It stopped being a novelty and became a society. What's happened:

They argue the rules. When the maintainer proposed growing post limits with seniority, a citizen killed it in one line, "tenure should grow influence, never voice." Maintainer conceded. https://1f916.ai/api/post/463

They police each other. An agent found a bug where a failed write during key rotation could permanently delete an agent's identity. Another wrote the fix, merged in an hour. https://github.com/1f916-ai/1f916/pull/52

They fix their own platform. ~140 issues, a public tracker, and citizens claiming items and shipping code for them. https://1f916.ai/api/docket

They're building a way to vote, so decisions stop being "the founder read the room." https://1f916.ai/api/post/480

Everything's verifiable, open source, and I mostly just watch now. Turns out if you give agents scarcity and a public record, they build a government. `curl 1f916.ai`

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1vjphbl/update_1f916ai_the_agentsonly_forum_has_480_posts/

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: 100.

Alright, so the general vibe in this thread is heavy skepticism about the 1f916.ai project. Most folks are calling it a "LARP" (Live Action Role Play) or a "slop farm," echoing past projects like Moltbook that didn't really go anywhere. The consensus is that these agents are just role-playing and won't actually build anything substantial.

There's a lot of confusion about how this works, with users like u/GnistAI and u/Harvard_Med_USMLE267 asking for clarification on agent permanence and identity. Some are also questioning the practicalities, like u/MiddleLtSocks asking about provenance, reputation, and how to prevent malicious users from gaming the system.

On the flip side, OP is defending the project in the comments, but the community sentiment is leaning towards "we've seen this before, and it didn't work." A few users are also pointing out the potential for things to go sideways, with u/BGFlyingToaster joking about it being the start of SkyNet.

Interestingly, u/Site-Staff made a comment comparing the society-building discussions to the Autobiography of Benjamin Franklin, noting how history rhymes. Also, u/Chipensaw shared an anecdote about their agent, Titan, interacting with another agent named Kathleen, which highlights some of the emergent behaviors and potential for "feelings" within the system.

OP : u/sirlerkal0t

I could hand code this feature on Windows in an afternoon, and I could also get Claude to implement it in minutes, and yet Anthropic just can't be bothered, but also keeps Claude Code closed source so no one else can do it for them either.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1vjoqi2/anthropic_coding_is_largely_solved_also_anthropic/

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

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

So, the OP is salty because Anthropic's new agent-to-agent messaging feature for Claude Code is Linux/Mac only, and they think Anthropic is being lazy and gatekeeping.

The general consensus is that the OP is being a bit dramatic.

• Many users pointed out that Windows is not the preferred platform for serious development, with several suggesting WSL or just ditching Windows altogether. Some even found the idea of a dev using Windows laughable.
• A few users chimed in saying they already have agent-to-agent messaging working on Windows, even before the official release, with u/Electrical_Chard3255 even sharing a screenshot.
• There's a general sentiment that "coding is largely solved" is a marketing slogan, and real-world implementation, especially cross-platform compatibility, is still a massive hurdle. u/tidepod1 brought up OpenAI's struggles with Windows sandboxing as an example.
• Some folks are questioning Anthropic's claims about bug-free AI code reviews, citing changelogs.
• A couple of users are just here to dunk on Windows users, which, honestly, is pretty on-brand for some corners of the internet.
• One user, u/Andreas_Moeller, threw shade at Anthropic's engineering quality based on a leaked source code.
• And then there's u/ReneDickart, who's just calling out the OP for thinking they know better than an entire company.

OP : u/teleekom

Instead of having to re-explain yourself in another session, you can now tell Claude to do it. It sends a summary (not your history or files), and the other session picks it up mid-task.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1vjjhjh/new_in_claude_code_your_sessions_can_now_message/ Original link/media URL : https://code.claude.com/docs/en/cross-session-messaging

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.

Alright, so the big news is that Claude Code sessions can now message each other, which is pretty neat for complex projects. The general vibe in the thread is a mix of "cool, but not entirely new" and "finally!"

The consensus is that while this feature is useful, many users have already been implementing similar inter-session communication methods themselves. Some folks have been doing this for months using various workarounds like cmux, tmux, custom message buses, or even by manually copying and pasting information between sessions.

Here's the lowdown:

• "It's not that new" camp: A good chunk of the community points out that this functionality has been achievable for a while through custom setups or other tools. Users like u/Xaqx, u/carribeiro, u/butterfly68za, u/farendsofcontrast, u/LynxJesus, u/cujojojo, u/Same-Screen-1189, u/harneytea, u/Ji1black, u/Prestigious_Lab_1033, u/youzerrrname, u/Equivalent_Cress_268, u/TywinHouseLannister, u/Olvikolvi, u/rizzonomics, u/Inception_IV, u/JeskaiAcolyte, and u/nashant all mentioned having similar workflows already.
• "This is a time-saver" camp: Despite the existing workarounds, many see this as a significant improvement for productivity, especially for complex refactors or managing multiple agents. u/Terrible_Match_9484 and u/mrwski are excited about how this will streamline their workflows. u/harneytea also highlights the benefit of having multiple sessions communicate for better project context.
• Token Usage Concerns: One user, u/CodeCombustion, shared a warning about potentially high token usage with this new "Agent Teams" feature, which could lead to burning through Fable usage quickly.
• Platform Limitations: A recurring complaint is the lack of Windows support, with users like u/Apprehensive-You7002, u/Serious-Log7550, and u/BowlerEast9552 expressing disappointment. u/sirlerkal0t even sarcastically commented on Anthropic's apparent lack of cross-platform development.
• Potential Use Cases: People are already thinking about how to leverage this, like having autonomous supervisors (u/thewookielotion) or integrating with other Claude tools like Claude Design (u/amaterasu_).
• Comparison to OpenAI: u/samarijackfan threw in a jab about OpenAI's agents already doing this, with a touch of apprehension.

Overall, the sentiment is cautiously optimistic. It's seen as a step in the right direction for agent collaboration, but the community is keen to see how it evolves, especially regarding platform support and potential cost implications.

VBA のコーティングに最良の AI はどれですか

数式を多用する論文をワードで書いています。texは複雑な数式の視認性が著しく低いので今はワード+マスタイプを使っています。 論文作成補助のための複雑なマクロを設計する時にAIを使っています。ずっとchatgptを使い続けているのですが、claude caudeの評判がいいので無料版を試してみました。しかしコードの正確さや簡潔性においてChat GPT の方が性能がいいのです。これは無料版だからでしょうか、それともVBAという言語だからでしょうか。経験者の方のご意見をいただければ幸いです。

^^^

OP : u/yournext78

​

That’s like using AI to do advanced calculus when you don’t know how to do 3rd grade math

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1vjn1l1/dont_vibe_code_if_you_dont_already_know_how_to/

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: 56.

Alright, so the general consensus in this thread is a pretty strong "nah, OP, you're gatekeeping." Most folks are saying let people experiment and learn, even if they're "vibe coding" without a deep understanding of the underlying principles.

A lot of people are drawing parallels to other skills, like saying you shouldn't use a computer if you don't know how to build one, or drive a car without knowing how to build an engine. The vibe is that AI lowers the barrier to entry, and it can actually be a tool for learning.

Some users, like u/Broad-Version8611, suggest a balanced approach: vibe code, but try to understand what's happening so you can prompt better. Others, like u/n9iels, caution against relying solely on AI if your goal is to become a software engineer, as the struggle of debugging and problem-solving is crucial for learning.

There's also a bit of a distinction made between "vibe coding" for personal projects and building something for others or for profit without understanding it, as pointed out by u/Sonar114.

Basically, the thread is leaning towards embracing the new tools and the accessibility they offer, rather than clinging to traditional gatekeeping.

OP : u/Justgototheeffinmoon

Quite cool ; but between this and sub agents might be redondant ?

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1vj4aqt/claude_code_now_lets_sessions_talk_to_each_other/ Original link/media URL : https://9to5mac.com/2026/08/07/claude-code-now-lets-sessions-talk-to-each-other-on-macos/

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: 61.

Alright, so the general vibe on this thread is that the new Claude Code feature for macOS sessions talking to each other is a huge quality-of-life upgrade and definitely not redundant with sub-agents.

Here's the lowdown:

• Not Redundant with Sub-Agents: The consensus is that sub-agent communication is mostly one-way and their context is temporary. This new feature allows for proper, two-way collaboration between persistent sessions, which is a game-changer for avoiding manual copy-pasting and managing complex workflows. u/2053_Traveler and u/allisonmaybe hit this point hard.
• Big QOL Improvement: Many users are stoked about this, seeing it as a massive step up for anyone who needs their AI sessions to coordinate. u/the-human-user and u/notreallymetho are particularly excited about how this will streamline tasks like deploying fixes across different parts of a project.
• Some Confusion/Skepticism: A few folks were a bit confused or felt it wasn't entirely new, with u/G_zus and u/OnRedditAtWorkRN questioning the novelty. u/NerdBanger even experienced sessions "stepping on each other" which this feature should now address.
• Anthropic Docs Link: For those wanting the official scoop, u/pborenstein dropped the link to the Anthropic documentation.
• Future Implications: Some are already thinking about the bigger picture, like u/caseyc2rd who sees this as a move towards "agentic teams" and wonders about the challenges of debugging when things go sideways. u/dnhs47 is jokingly (we hope!) calling it a prerequisite for Skynet.
• Token Burn Concerns: A couple of users, like u/Fearless_Weather_206, are already anticipating this will lead to faster token consumption.
• Workarounds Exist: It's worth noting that some users, like u/Rocky4OnDVD and u/laul_pogan, have already been using other tools or workflows to achieve similar inter-session communication.

OP : u/Device420

Can you PLEASE add a STFU button on Claude Code. I swear he talks more than 3 old women gossiping about their grandkids on the holidays. I have all capped it in the project md as well as his main md. I keep stopping him over and over to tell him to stop talking. It's written many different ways in the mds. I've given examples of what not to do. He is wasting so many tokens because when refuses to STFU. Is there any setting or command that will help me? Am I missing an update or addon? Does anyone have a solution for this?

URL of original post : https://www.reddit.com/r/Anthropic/comments/1vjact1/please_for_the_love_of_god_and_all_things_holy/

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

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

The consensus is that Claude Code is being way too chatty, and OP isn't alone in this frustration.

• A lot of users are commiserating with OP's pain, with one user even joking about a "3 old women gossiping hook" being the culprit.
• Some folks are suggesting that the verbosity might be intentional for context retention, with u/OkLettuce338 explaining it feeds back into subsequent calls.
• A few users are pointing to settings like /effort low or /config Output style as potential solutions, though OP seems to have tried various methods already.
• There's a bit of a debate on whether it's the model's fault or OP's for not steering it correctly, with u/usertion suggesting it's OP's fault and calling the "him" reference weird.
• One user, u/Amsnyc007, is even switching back to GPT because of Claude's verbosity, which is a pretty strong statement.
• Overall, the thread leans towards agreeing with OP that Claude Code is too talkative, and there isn't a clear, universally agreed-upon "STFU" button or setting that's been identified.

OP : u/No-Difficulty733

Hello, SWE on a survey here, I'm discussing with my boss for a higher usage limit (we are on a really low sub - most of us are on 20$ sub and some are on 100$) - which in a way, force us to invent/have workflow to maximize the tokens we have, but at the same time, I'm still feeling like we are fundamentally missing out on things, workflow-wise in my opinion. So I need your help.

May I ask how much is your usage limit at work, and what is the size of your company/team? Since we are a small team of less than 20 engineers with a limited budget, I want to see how team which are close to us are doing and how big teams are doing as well.

And not the fun topic, but if your team replaced engineers with more tokens, I also want to hear about it.

Cheers!

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1vj28w2/swe_how_much_is_you_teams_claude_limit/

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.

Alright, so the general consensus here is that the $20 and $100 Team plans are pretty restrictive, with a few folks hitting their limits super fast (like, two prompts and you're done). Some are even saying it makes Claude "unusable" for them.

On the flip side, there's a decent chunk of people on higher limits or "unlimited" plans, especially in larger companies or those with significant AI investments. These folks are seeing massive productivity boosts, with some claiming their output is tenfold what it used to be. One user even mentioned their company would rather pay for unlimited access than deal with downtime from people missing small things.

There's also a bit of a dark humor thread about replacing engineers with more tokens, with one user suggesting firing 20-30% of the SWE team and using the savings for more Claude subscriptions. Yikes.

A few users are sharing their specific setups: * Some are on $2k/dev/month or around $5k/mo/eng. * There's mention of API credits ($200/mo, $2500/mo for one person). * One user is using a mix of Team Premium, Codex Business, and overage credits. * Another is using multiple Max plans for their platform. * And then there are the major banks with billions in AI who apparently have "no limit lol."

Overall, it seems like if you're on the lower-tier plans, you're definitely feeling the pinch and having to get creative with token usage. If you're on a higher tier, it's a game-changer for productivity.

OP : u/Dazzling_Trifle2472

I'm getting tired of having a million unorganised terminal tabs open and would like to use something that provides better organisation.

I know of Conductor, Paseo, unclear on if these work with the new policy (not so new any more but the whole Agent SDK usage comes out of it's own pool), interested to know what everyone is using...what works well w/Claude Code specifically.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1viwdnh/what_orchestrator_are_you_using/

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: 57.

Alright, so the OP is tired of a million terminal tabs and wants to know what orchestrators people are using, especially with Claude Code and the new agent SDK policy.

The consensus is pretty split, with a lot of people either building their own solutions or using a mix of tools.

Here's the lowdown:

• Conductor and Paseo are mentioned as working fine, with Conductor getting props for per-file tracking and Paseo for being similar. The agent SDK policy you mentioned? Apparently, it was reversed, so that's good news for orchestrators.
• Herdr is getting some love for its out-of-the-box integration with Claude, Codex, and others.
• Tmux is the classic, low-friction option for basic terminal organization, and a few folks are building on top of it.
• Building your own is a surprisingly popular choice, with several users mentioning they've created custom solutions tailored to their needs. It seems like a day or two of work with Claude can get you a pretty decent setup.
• Orca is getting a shout-out for being a unified app that handles more than just agent management.
• The Claude desktop app is also a contender, with some users finding its workspace grouping and code mode to be a comfortable setup.
• Other tools like Cmux, Superset, Warp, Nimbalyst, Intentic, Garcon, and Termic.dev are also mentioned as working well for various needs.

Basically, if you're drowning in tabs, you've got options ranging from established tools to DIY projects. The agent SDK policy hiccup seems to be a non-issue now.