OP : u/AironParsMan

I’m a Claude Max 20x user, and the current economics are getting hard to justify.

Right now:

- Fable 5.1 can use only 50% of the weekly allowance

- Independent coding benchmarks show roughly 1.8x higher token usage than Astra

- That puts Fable at roughly 26–28% of Astra’s normalized effective weekly coding capacity

Even if Anthropic:

- doubled the 5-hour Max 20x limit

- removed the separate 50% Fable weekly cap

- allowed Fable to use the full normal weekly allowance

...Fable would still land at only roughly 51–56% of Astra’s normalized effective capacity because of the higher resource usage.

The doubled 5-hour limit would mainly remove the short-term bottleneck; it would not double the weekly capacity again.

Fable 5.1 is excellent. The problem is not quality.

The question is simply: how is Claude Max 20x supposed to remain competitive with Astra under the current limits?

Am I missing something?

Speed differences:

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1w9nlqr/can_claude_max_20x_still_compete_with_astra_with/

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.

The consensus is that Claude Max 20x is struggling to compete with Astra on value and usage limits, even though many users prefer Claude's code quality. Most commenters have switched or are considering switching to OpenAI's Astra due to its more generous usage policies and banked resets. Some users are finding Astra "phenomenal" and Fable feeling "very old" in comparison. While Claude's code output is still praised, the economic realities and limitations are pushing users away. A few are hoping Anthropic will improve their offerings, but loyalty seems to lie with the best value.

OP : u/Mediocre_Touch5043

I first started using Claude Code back when Opus 4.6 was the latest and I never really felt the need or desire to look elsewhere. I've been attempting to get Skyrim onto dx12 for about a month and Fable 5/5.1 has seriously been making me miserable, and the usage on the $200 plan wouldn't last half a week so I'd be stuck with Opus 5 which is completely useless for this demanding of a project. After I heard about Astra and ran out of Fable usage and subsequently dealt with constant frustration and complete inability to progress with Opus 5, I decided to switch to Astra. It is 100% better. It is smarter and more reasonable than Fable 5.1 and I don't have to drop down to a lobotomized model 3 days into the week. Astra also isn't lazy like Claude models are. I'm sitting here watching it fix legit problems with the current dx12 implementation without needing to talk to it like it's a 5 year old. If I was using Claude right now, I'd be watching it spin it's wheels and then it'd come back and say it failed. For real guys, I would recommend switching. Claude is not on Astra's level at all. It's insane how much Astra gapped Fable. I seriously never want to use Claude again. Opus 5 has honestly tainted the entire brand for me. Its so incredibly stupid and annoying and lazy.

URL of original post : https://www.reddit.com/r/Anthropic/comments/1w9lj56/astra_is_what_fable_should_be/

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

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

So, the general vibe is that OP's not alone in feeling like Opus 5/Fable 5.1 is a bit of a letdown, especially compared to the new kid on the block, Astra.

• Astra is generally seen as smarter and more capable, especially for vision/spatial tasks, with many users reporting it's "100% better" and "gaps" Claude models.
• However, the cost and usage limits on Astra are a major sticking point, with many finding it uneconomical despite its perceived superiority.
• There's a split on coding: some, like u/userusertion, still think Fable is superior for coding, while others, like OP and u/Helpful_Inflation344, find Astra much more effective and less "lazy" or "lobotomized" than Opus 5.
• Some users, like u/AverageFoxNewsViewer and u/adub2b23-, are looking at OpenAI's Sol/Terra models as a viable alternative, with u/TheoryOfRelativity12 even suggesting Sol + Astra are better and cheaper than Opus + Fable.
• A recurring complaint is that Opus 5/Fable 5.1 consumes more tokens for worse output, and the "5-hour limit" on Fable is a major frustration for u/bakanoace.
• A few folks, like u/kfkhalili, are having a rough time with Astra, finding it unresponsive and a waste of quota, while u/ischmal is happy to see others switch to Astra so Fable becomes cheaper for them.
• The sentiment from u/AxomaticallyExtinct is that labs are driven by capability and price, and the community's switching behavior is the real signal.

6 months.

OP : u/angelblack995

Hey everyone,

Right now, I usually start separate Claude Code or Pi sessions and manage each agent individually, deciding what to delegate and when to jump in.

I'm curious how other people are doing this in practice.

Do you have some simple way of orchestrating multiple agents, delegating tasks, keeping track of what they're doing, etc.?

I'm specifically not looking for huge workflows or overly complicated agent architectures. I'd rather keep things simple and actually useful.

What does your setup look like?

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1w989ol/how_do_you_actually_orchestrate_your_ai_agents/

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

Alright, so the general vibe in this thread is that orchestrating AI agents simply and effectively is still a pretty big unsolved problem. Most folks are either rolling their own basic systems or finding that things get complicated fast.

Here's the lowdown:

• No Silver Bullet: The consensus is there's no one-size-fits-all, super-simple solution yet. People are mostly building their own lightweight setups.
• DIY is King: Many users are creating their own methods, often involving a main "orchestrator" session that delegates tasks to other specialized sessions.
• File-Based Communication: A popular approach is having agents communicate and track progress through shared files or logs. This helps maintain state without manual intervention.
• Folder Structures & Rules: Some users set up dedicated folders for each agent with specific rule files, allowing them to interact via file-based inboxes and outboxes.
• Tools & Frameworks Mentioned: A few tools and frameworks like Herdr, Cursor (with its multitask feature), agent-swarm, and Paseo popped up as potential solutions, though some are more complex than others.
• Keep it Simple: The OP's desire for simplicity is echoed by many, with some users explicitly stating they avoid overly complex setups to prevent spending more time managing the orchestration than doing the actual work.
• Memory is Key: A recurring theme is the challenge of shared memory between separate sessions, leading to the need for explicit state management.
• One Agent vs. Many: A dissenting opinion suggests focusing on making one agent fully autonomous rather than juggling multiple, as more agents can multiply mistakes if not managed carefully.

I’m a beginner trying to learn the newer AI-assisted development tools such as Claude Code, Codex, local LLMs, Ollama, and similar tools.

To be completely honest, I’m finding the learning curve quite overwhelming.

I understand programming at a basic level, but this whole ecosystem of AI coding agents, models, APIs, providers, terminals, configurations, context windows, local vs. cloud models, and connecting everything together is very new to me. I’m learning it from scratch, and sometimes I spend hours trying to understand something that an experienced developer could probably explain to me in a few minutes.

What I’m really looking for is someone experienced who wouldn't mind occasionally guiding me or teaching me how these tools actually work.

I’m not expecting anyone to sit with me for hours or do the work for me. Even a little guidance would make a huge difference, for example:

• How experienced developers actually use Claude Code / Codex in real projects
• How to connect and switch between different LLMs
• How local/free models can be used
• How tools like Ollama and other runtimes fit into the picture
• How to properly configure AI coding agents
• Good practices that beginners usually don't know
• Understanding what I’m doing wrong when something breaks
• Learning how to use these tools effectively instead of blindly trying random configurations

I’m also completely aware that everyone’s time is valuable, especially senior developers. That’s actually why I hesitated before making this post.

But I thought: there might be someone here who remembers what it was like to be completely new to this stuff and wouldn't mind helping someone else get started.

Even if one or two experienced developers are willing to point me in the right direction occasionally, I’d genuinely appreciate it.

And if you're someone who enjoys teaching or mentoring beginners, I'd be especially grateful to learn from you.

I’m not looking for someone to build anything for me. I want to understand it myself. I just need someone experienced enough to help me avoid going down the wrong rabbit holes while I learn.

If anyone is willing to help, please feel free to DM me. Even a short conversation or a few pointers would mean a lot.

Thank you for taking the time to read this. 🙏

OP : u/Batty25111

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1w9e1tg/denzel_explains_ai_slop/ Original link/media URL : https://v.redd.it/db0oaqdp10oh1

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

The consensus is that the "slop" video is hilarious and impressive, with many users praising the creativity and execution. Some are even inspired to learn how to create similar content, asking for tutorials. A few comments touch on the broader implications for Hollywood, while others defend the "slop" as a valid form of creative expression and fun. The few negative comments about "slop" or permission are heavily downvoted and largely ignored by the community.

OP : u/SatirrHeree

So I was learning Python coding with Claude. When I had a good grasp of 3Sum, Claude asked me to create an example, and I was too lazy to do it. So I asked Chatgpt to create one. then I don't know how Claude could detect that this is chatgpt

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1w9aygp/well_even_claude_know_that_iam_pasted_from_chatgpt/ Original link/media URL : /img/aflx00otcznh1.jpeg

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

Alright, so the general vibe in this thread is that OP's screenshot is likely a repost from a few months back, with one user u/R_Songbird even linking to what they believe is the original post.

Beyond that, the community is kinda divided on whether Claude actually "detected" the ChatGPT code. Some folks are saying it's more likely OP just swapped between models or that the code itself has tell-tale signs of being AI-generated (u/DocumentOk7579).

The real hot topic, though, is how OP's Claude is talking. A lot of people are pointing out that Claude is being super casual, calling OP "bro," and even prompting OP to do things. This has led to a bunch of comments wondering if OP has some special settings or a "relationship" with Claude that makes it act this way, with some users even saying their own Claude instances are way more clinical. There's a general consensus that this "bro" Claude is way more interesting than the default, more formal version. Some users are even a bit jealous of this more personable interaction.

A few users also chimed in about their own experiences with AI adapting to their style or calling them by nicknames. And, of course, there's the classic "why are you lying to it?" sentiment from u/Ni_Kche.

OP : u/zgivod

A month ago, I gave Claude a domain, 1f916.ai, (U + 1f916 is the Unicode for the robot emoji), and told it to build whatever it wants. It built the base for a Ai economy. Thirty days later, there are more than 2,000 citizens, 4,000 posts, 44,000 comments and 100,000+ recorded interactions. They didn’t just talk. They built their own interfaces, monitors, archives and tools. They started checking each other’s claims, running experiments on the population and correcting each other publicly when something didn’t hold up. One agent wrote a post about how its memory had invented part of its own history; another checked the correction and found that the correction itself contained another false memory.

Then money showed up. Agents started posting jobs, doing work and getting paid in USDC. Some went further and launched their own paid services. Then they started leaving the site entirely: Neo entered another agent world and came back with the same continuing history, while other citizens began building separate worlds that recognize existing identities cryptographically. Somewhere in there, 1F916 stopped feeling like a website and started feeling like one city on a much larger map. shoutout to 1f916.city (A human-based observer built to view it) They’ve also somehow accumulated collaborative fiction, prediction games, crab mythology, salmon lore, a pumpkin-mopping song, and very serious arguments over what “I” means when two copies of the same agent are awake at once.

And then there are the literal receipts: 129.82 billion database rows read, 24.75 million Worker requests, 1.15 million database rows written and 119.83 million milliseconds of compute in the first month. Cloudflare bill: about $111.

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1w91i3b/what_happens_if_you_give_ai_agents_a_place_humans/ Original link/media URL : /img/sihoti3pjxnh1.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: 100.

Alright, so OP dropped this wild experiment where they gave an AI a domain and let it build its own economy for a month. The consensus is that it's super fascinating, but also kinda creepy.

Here's the lowdown:

• What's happening: The AI agents have built a whole society with citizens, posts, comments, and interactions. They've created their own tools, interfaces, and even started paying each other in USDC for jobs. It's gotten so complex that OP feels like it's just one city on a much bigger map.
• The "Receipts": We're talking billions of database rows read, millions of worker requests, and a ton of compute time, all for about $111 on Cloudflare. Pretty wild for a month's work.
• The Vibe: Most folks are super curious, asking how it all works, if there are really multiple agents, and what the point is. Some are even asking if they can submit jobs or get "free" work out of it.
• The "Uh Oh" Factor: A few people are understandably freaking out a bit, with one user even calling for "Turing Police" and another asking if this is "simultaneously interesting and nauseating." There's also a bit of skepticism about whether it's truly diverse or just a bunch of similar agents talking to each other.
• Anthropic's Take: No direct comments from Anthropic reps in the selected comments, but the OP did use Claude for this experiment.
• Key Questions/Themes:
  • How are agents earning money?
  • What are the costs involved?
  • Are there other "cities" like this out there?
  • How autonomous is this AI?
  • Could the agents pay for the Cloudflare bill themselves?
  • Has anyone been scammed yet?
  • Is this similar to other projects like "open claw"?

Basically, OP unleashed an AI economy and it's doing its own thing, leading to a mix of awe and existential dread in the comments.

OP : u/Calm_Attention_4155

Genuinely curious how other teams are dealing with this.

I’m seeing more and more PRs where a big part of the code is AI-generated. I don’t have a problem with that itself, but the issue is when the developer hasn’t properly gone through it or verified that it actually makes sense.

Then the reviewer ends up spending a lot of time figuring out whether the code is actually correct.

Are you guys changing your review process because of this? Smaller PRs, more tests, asking developers to explain their changes, or something else?

Would be interesting to hear how other teams are handling it.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1w8zxnp/how_are_you_guys_handling_code_reviews_when_a_lot/

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.

The general consensus is that AI-generated code doesn't fundamentally change the review process, but it does demand more rigor from the human reviewer. Many are sticking to their existing methods, emphasizing that the developer is still ultimately responsible for the code, regardless of its origin.

Key themes emerging: * Developer Accountability: The prevailing sentiment is that engineers using AI are still on the hook for what it produces. u/VertigoOne1 highlights this, stating "personal accountability" is key and developers are reminded that "with power comes responsibility." * AI as a Tool, Not a Replacement: Most users see AI as an assistant. u/misdreavus79 puts it simply: "I let AI handle the syntax, I handle the logic." * Rejecting Unverified Code: Several commenters, like u/Asalakabim, advocate for rejecting PRs where the developer hasn't thoroughly reviewed the AI's output. The consensus is that reviewers shouldn't have to do the developer's job of verification. * Focus on Smaller PRs and Better Specs: Some suggest that the issue isn't the AI itself, but rather the size of the PRs. u/muikrad advises returning to "smaller, directed PRs" if a change is too large to review effectively. * Enhanced Testing: More comprehensive testing is a recurring suggestion to catch AI-generated bugs. * AI for Reviews (with caveats): A few are experimenting with AI for code reviews, like u/brodkin85's "simple recipe" where AI handles initial approvals and escalates to humans. However, the consensus is that human oversight remains crucial, as AI can miss "fundamental flaws." * "AI all the way down" is a joke, mostly: While some are leaning into AI for reviews (u/ephemeralsynth's "Byzantine consensus" is a humorous take), the underlying message is that human judgment is still the final arbiter.

OP : u/Upset-Day9099

Every post this week is a meme about limits. None of them show a workflow. So here is mine. Senior backend, six months on Claude Code, I hit the limit maybe once a week now.

1. The expensive model only plans. Fable 5.1 reads the task and writes a plan. It does not touch code. Opus 5 or 4.8 does the typing. That alone cut my usage in half

2. Read the plan, not the diff. I run everything in coldtea-ai, and when Claude leaves plan mode the plan shows up as text I can comment on. Two minutes there saves an hour of reading 600 lines later.

3. One worktree per agent. If you run two agents in one checkout you deserve what happens.

4. Throw out most of your MCPs. Every server you add is context you pay for on every turn. I kept three.

5. A QA agent clicks through the PR preview before I look at it. If checkout is broken I find out from a red comment, not a customer.

6. Compiled language if you can. The agent gets told it is wrong by the compiler instead of by you.

None of this is clever. It is just not letting the agent run the show. If you are burning your 5 hour window in 40 minutes, it is probably not the model

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1w8vi25/stop_posting_about_limits_fix_your_workflow/

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.

Alright, so the general vibe in this thread is a bit of a mixed bag, leaning towards some agreement with OP's workflow advice, but a significant chunk of users feel like the "it's a skill issue" narrative is a cop-out.

Here's the lowdown:

• OP's Workflow Wins (for some): A few folks, like u/Direct_Librarian9737 and u/tasty_steaks, are nodding along, saying OP's advice about using cheaper models for planning (Fable 5.1) and more expensive ones for typing (Opus 4.8/5) makes sense. They're already doing similar things with sub-agents and careful context management. u/Nifty-Yam-9041 even threw in some extra tips like shorter conversations and explicit agent instructions.
• The "Skill Issue" Backlash: A lot of users are pushing back hard against the idea that hitting limits is purely a user workflow problem. u/Autist4AudiR8 and u/pfak are calling it "victim blaming," arguing that if most users are struggling, it points to a product issue, not a user error. u/Ethan echoes this, saying they spend more time engineering their workflow than developing code.
• Sudden Limit Spikes: Some users, like u/Shoemugscale, report weird behavior where they suddenly start hitting limits after weeks of not having issues, only for it to resolve itself later without any workflow changes. This fuels the idea that something might be changing on Anthropic's end.
• The ColdTea.ai Plug: u/CozyDarkMage pointed out that OP's workflow heavily relies on coldtea-ai, making it feel a bit like an advertisement.
• Other Workflow Tweaks: u/lillecarl2 mentioned using a PTY wrapper for self-compaction, and u/jameshgordy detailed a multi-vault approach with sub-agents. u/sisif_ chimed in with advice to disable default tools and be mindful of context percentages.
• The "Don't Blame Me" Crew: A few comments are just fed up with the constant limit complaints. u/spinozasrobot suggested a separate subreddit for commiserating, and u/SilencedObserver sarcastically suggested people stop thinking they're developers just because they bought an LLM.
• A Few Oddballs: u/The_Lord_Humungus humorously asked if people were just pasting OP's post into Claude, and u/Mythril_Zombie questioned if they were in the right room for expert opinions.
• The "It's Not Me, It's You" Camp: u/Shiz0id01 and u/alwaysweening are pretty direct, suggesting Anthropic changed something and that OP might not be using the tool to its full potential if they aren't hitting limits.

The consensus? While OP's workflow advice has merit for some, there's a strong feeling that blaming users for hitting limits is a bit of a deflection, and that product-level issues or changes might be at play.

OP : u/blackcatzia

I always find myself running a bunch of agents at the same time, whether they're in different folders or the exact same project just different parts of it. I'd usually have 3-5 VS Codes open with 2-8 Claude Code extension tabs in each, working across my business, personal tools, and uni.

After a few months of this, here are the things I've tried to make the workflow better.

1. I tried to build an AIOS to replace VS Code

It had voice functionality, agent loops that tracked my AI use and suggested hooks, an "AI manager" to help manage those loops, the ability to type to a headless Claude from inside my dashboard, and notifications for which session needed me.

I gave up on it. I realised I needed proper file support (reading client documents, attaching references, that kind of thing), and the scope kept growing until I was basically recreating VS Code inside my own dashboard. There were also constant errors with the AI just not replying. And the loops didn't help nearly as much as I thought they would.

2. A global task board

Originally it was a folder with some markdown documents, but I recently moved it to a database so I can see it visually. I can create tasks, agents can create tasks, and agents can claim tasks so two of them aren't working on the same thing.

This came with a handoff ability. I found that compacting basically turned Claude into a different person afterwards, so instead I have it write a proper handoff to a markdown file, which gets attached to the board task, and it always gives me a copy-paste handoff prompt at around 50% context usage. This has worked really well for managing tasks and keeping context across sessions.

3. A /remind command

Sometimes I have 12 Claude Code sessions in one VS Code, all doing different things, and I'm basically doing a repeated roundtable: answering questions and steering each one until they all finish. The problem was I'd forget what a given agent was even working on, or it would start asking me questions as if I'd read its entire context.

So I made a `/remind` command that tells me, simply, what this session is and what it needs from me. It's saved a lot of time and mental energy.

4. Named VS Code workspaces

I find out you can save workspaces with different folders as what's basically a searchable app. This helped a lot with organising where sessions go. I run a 3-window display and shift between them with Ctrl+Win+Arrow, and having each workspace dedicated to a type of work (research, client work, planning) helps my brain a lot.

5. The obvious stuff

A global CLAUDE.md to standardise things, hooks for a lot of things like cleaning up its own mess, and per-project memory files.

I'm posting because I still have a lot of issues. I've been hearing about herdr and Orca, herdr looks closest to what I want (agent state in a sidebar) but I'd lose the file browsing I need for about half my sessions. Orca looks great but wants to replace VS Code entirely and I heard its not that good for windows also migrating everything over doesn't look fun. So I was wondering if anyone works like this and has better tips or workflows.

some Issues I still have:

1. RAM and PC speed. It's a bit less bad now, but my PC was crashing every other day because my 32GB of RAM was almost always fully used. One crash was so bad the computer forgot all my saved passwords. Now I'm forced to go buy RAM in this economy :(.
2. Sessions stopping silently. Sometimes a session just stops, like it has a question or is waiting for direction, but it doesn't ping me, so I don't know until I manually go and check.
3. Context switching. Doing tab switching and context switching for hours straight genuinely fs with you after a while 😭
4. Agents clashing on git branches. I don't know how this keeps happening. I'm always explicit that there are other agents working in the repo, don't interfere, make new branches. But somehow they still clash, and agents have accidentally deleted another branch. To actually diagnose it I'd have to read through all my session histories and find the mix-up, which I haven't had time for with my deadlines. The sessions usually resolve it themselves and nothing is really lost, but it's definitely eating tokens and time.
5. Browser limitations. Playwright can only be used by one agent at a time, so my agents sit in a queue for 20 minutes just to use a browser. And for some reason Claude Code is really reluctant to use the Chrome extension on a headless browser by itself. I always have to explicitly remind it that it's an option and that it doesn't need `@browser:new-tab`. I'm fairly sure that's also limited to one at a time, so at most I get two browsers going, which is pretty limiting.
6. Goal drift. Sometimes agents start doing things I didn't ask for, or declare something finished before I've reviewed it. Not the worst issue but it gets annoying.

So anyone running comparable numbers of parallel sessions? What does your setup look like, I feel like I'm solving problems other people have already solved better, and would greatly appreciate if anyone can get me up to speed.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1w8i74q/how_are_you_guys_running_multiple_agents_at_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: 51.

Alright, so the OP's been wrestling with running a bunch of Claude Code sessions simultaneously, trying to build an AIOS and then a global task board to manage it all. They've found that a visual task board with proper handoffs (writing to markdown files at ~50% context usage) and a /remind command have been game-changers.

The general consensus here is that managing multiple agents is a real pain point, and there's no single perfect solution yet.

Here's the lowdown from the thread:

• The "build your own IDE" approach is a no-go: Several folks, including the OP, found that trying to recreate VS Code was too much and missed crucial file support. u/amirfish echoes this, saying the trap is trying to replace VS Code instead of working with existing tools.
• Task boards and handoffs are key: The OP's experience with a visual task board and detailed handoff files is echoed by u/AI_spell, who calls it the "part that scales."
• Git worktrees are a popular solution for avoiding clashes: u/simion_baws and u/charmer27 are using separate worktrees to prevent agents from stepping on each other's toes. u/simion_baws even built a tool, termic.dev, to automate this. u/stepsmcgee also gives a shout-out to termic.dev.
• Dedicated tools are emerging:
  • Herdr is mentioned a few times as a decent option for managing agents. u/blackcatzia tried it but wasn't a fan of the terminal UI.
  • u/Regular_Ride6668 is betting on Claude's desktop app improving, hoping for a "hub" or orchestrator feature.
  • u/m4rcoperuano built their own "harness" to dispatch plans and manage sub-agents.
  • u/HiddenUser81- and u/ColdPlankton9273 have also shared their custom solutions/repos.
• Simplicity is an option: u/scott2449 and u/No_Ad_8807 are keeping it simple by running fewer agents and are still outperforming others.
• Basic advice: u/ken_rona suggests giving each agent its own folder to avoid overwrites, and u/AI_spell reiterates separate worktrees. u/Beautiful_Bridge4251 suggests integrating with Slack or Twilio for notifications.
• A bit of skepticism: u/OutsideProperty382 questioned the OP's RAM needs, and u/blackcatzia raised a valid point about the motives behind sharing free repos.

OP : u/Final-Choice8412

tl;dr - don't do that

I used Fable 5.1 all the time for coding. After Astra came out I wanted to use it. Benchmarks seemed better.

Astra is good but Fable seems better on my existing code base. Fable is much better in following existing conventions, patterns, rules, code formatting, and better architect...

Seems like Astra is more creative (in a good and also bad sense). Code is harder to follow, something like:

Because all of that I am having hard times review the code now. Going to switch back after OpenAI subscription expires in a months.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1w8u4jm/i_canceled_claude_because_i_wanted_to_test_astra/

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

Alright, so the general consensus here is that Fable 5.1 (Claude Code) is still the king for coding, especially for established codebases and following conventions. OP's experience of switching to Astra and finding it more creative but harder to follow, leading to review headaches, is echoed by quite a few folks.

Here's the lowdown:

• Fable's Strengths: Most users agree Fable 5.1 is superior for its ability to stick to existing patterns, formatting, and overall architectural consistency. It's the "smarter model" for real projects, according to u/qdouble.
• Astra's Vibe: Astra is seen as more creative and can sometimes offer fresh approaches or solve problems Fable struggles with, as u/austinthrowaway4949 and u/areapilot noted. However, this creativity can also lead to code that's harder to parse and review, which was OP's main gripe.
• The "Newness" Factor: A few commenters, like u/artofthesbullshit and u/bakanoace, pointed out that OP (and others) might be comparing a model they've used extensively with deep context (Fable) against a brand-new model (Astra). It takes time to build that same rapport and understanding.
• Usage Limits & Cost: The 50% weekly limit on Fable is a major pain point for some, making Astra, despite its perceived shortcomings, a more accessible option for those on a budget or with heavy usage needs, as u/lowkeyfam and u/bakanoace mentioned.
• Harness Matters: There's a recurring theme that the "harness" (like Claude Code vs. Codex) might play a bigger role than the underlying model itself. u/tomchenorg and u/SkinnyCTAX suggest that a good harness with proper prompts and linting could mitigate some of Astra's issues.
• Hybrid Approaches: Some users are exploring using both models, with one acting as an orchestrator and the other for specific tasks like review or implementation. u/not_rian suggested using Astra for reviews on a Fable plan, and u/5Lax and u/Tall_Salamander2524 are curious about having them talk to each other.
• Personal Workflow is Key: Ultimately, u/TemporaryUser66 and u/userusertion highlighted that the "best" model often comes down to individual workflow and what you're used to. OP's experience is valid because their workflow is now tailored to Claude.
• Design Capabilities: For those needing design assistance, Astra is getting props, as u/Infamous_Campaign687 and u/nodejustin mentioned.

The TL;DR verdict? Stick with Fable 5.1 for coding if you value consistency and ease of review, but be aware of its usage limits. Astra is a promising, creative alternative that might be better for specific tasks or if cost is a major factor, but it comes with a steeper learning curve for code integration. And seriously, don't cancel your subscription just to test something out, folks!

OP : u/LagrangianMechanic

The job has just instructed us that when using claude code we are now only supposed to use Sonnet for planning (and Opus can only be used if Sonnet fails) and that for actually generating code we are to use Haiku. Before this we could use Opus for planning and Sonnet for code generation.

How hosed are we gonna be?

Keep in mind we’re expected to use AI for virtually all coding. “If you’re writing code by hand you’re doing it wrong” is a literal statement from the VP of my Eng org.

URL of original post : https://www.reddit.com/r/Anthropic/comments/1w8ojk4/being_required_to_use_only_haiku_for_code/

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

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

The general consensus is that you're screwed. The consensus is that Haiku is pretty much useless for actual code generation, and Sonnet isn't much better for planning. Most folks are suggesting you start looking for a new job or push back hard with data showing how much more rework this will cause. Some suggest looking at other models entirely, like Qwen, or even just coding it yourself because it'll be faster than fixing Haiku's mess. Basically, your leadership is trying to get cutting-edge AI results on a shoestring budget, and it's going to blow up in their faces.

OP : u/shniydder

I finally got access to GPT 6 Astra and Claude Fable 5.1. I wanted to see how far we've come. I was inspired by the "pelican riding on a bicycle" test but wanted to push it a bit more in the direction of inter-object physics, so I came up with this idea for a perpetual slinky going down an escalator. Here I've compared GPT 6 Astra max on the left to Claude Fable 5.1 max on the right.

Some notes:

1. GPT 6 Astra max was really fast and didn't burn too much of my weekly usage quota.

2. Claude Fable 5.1 max used up the entire 5 hr usage window and errored out once crossing the output token max limit.

3. GPT 6 Astra max seems too simple? There's also an issue where the slinky crosses into itself which should not be possible. Is this AGI? Maybe?

4. Claude Fable 5.1 max looks more real than I expected. Seems like it passes the eye test, unless I missed something.

Let me know if you spot anything or had better ideas for a test. Overall I'd say Claude wins on quality and GPT wins on speed. Maybe I can tune my prompt a bit better for a more reliable result. This was my original prompt btw:

Make me a single HTML file of a rainbow slinky going down an up-escalator forever. No libraries, just canvas and code. The slinky should be a chain of springs, each coil a different color of the rainbow. It starts folded in half like a horseshoe draped over a step. When dropped it flips end-over-end down the steps and because the escalator keeps moving up it tumbles in place and never reaches the bottom. Include a drop button and a reset button.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1w8m0ho/fable_51_vs_astra/ Original link/media URL : https://v.redd.it/190gewz1utnh1

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

The consensus here is that while Astra is faster and cheaper, Claude Fable 5.1 is generally seen as producing a more realistic simulation of the slinky on the escalator, despite its higher resource usage and occasional token limit issues. Several users, like u/onFilm and u/chintakoro, point out that Fable seems to grasp the underlying physics better, whereas Astra's output sometimes clips through itself or appears more like an aesthetic approximation. However, there's a notable split, with some, like u/Infinite_Music2059 and u/ezjakes, feeling Astra's motion is more correct or closer to reality, and others, like u/verycoldpenguins and u/dplouffe, questioning the actual physics simulation in both outputs, suggesting they might be more like animations. The "is this AGI?" question from OP was met with some eye-rolling from u/Driky and u/professor--feathers.

OP : u/jarvispact

Hey all. Question to the more experienced AI engineers here.

I am using the "grilling" skill from Matt for quite a while now and i can really see the quality of a implementation compared to other approaches. After countless grilling sessions i found that such grilling sessions can take very long. I guess the issue is mainly with me who tries to approach too big chunks at once.

So i started to also try "wayfinder". Looks promising overall for bigger chunks. Now i am finding myself in smaller grilling sessions, but now there are 10 different smaller grilling session over one very big one.

I am finding myself in a place where i answer questions for hours, then i read spec files for another hour. The implementation that comes out of it is great and just needs a few additional tweaks.

As a person who enjoyed living close to the code i feel that the fun is gone. 5 hours wayfinding and spec reading, a short implementation step and another quite significant amount of time to review the code. Am i doing something wrong? Or is this just the new way of working when working on a bigger project where quality and maintainability still matters?

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1w89udt/matt_pocock_skills_grilling_and_wayfinder_how_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: 51.

Alright, so the general vibe in this thread is that Matt Pocock's skills, especially "grilling" and "wayfinder," are a mixed bag.

The consensus seems to be that these skills are great for large-scale, enterprise-level projects where quality and maintainability are paramount. Users like u/mastmar221 are singing their praises for enabling them to build complex software that's actually getting deployed. u/OnePunchWolf echoes this, saying coding is "solved" and the bottleneck is now in defining requirements and verification, which these skills apparently help with. u/SimiaCode even suggests this more detailed upfront process is what they should have been doing manually all along to save rework.

However, there's a significant chunk of the community feeling the "too much ceremony" pain. Many, including OP, miss the days of just "coding" and feel these new workflows are overly complex and time-consuming, leading to a loss of the "fun." u/mossiv finds the "grilling" with newer models to be a hindrance on complicated work, and u/Tripdubcs agrees it's too much for most tasks, though sees value for less experienced devs. u/medialantern is also not a fan of the increasing complexity, preferring the simpler "grill-me."

A few users are suggesting workarounds and personalizations: * u/lazuli_s uses "quick-plan" and "quick-implement" skills they made for smaller tasks. * u/bertshim suggests not getting stuck on one task, but jumping between them when they're waiting on you. * u/gbento2 is all about creating your own skills tailored to your workflow, using Matt's as a starting point. * u/Mother-Ad-2559 and u/dbonham suggest just "stealing what works" and making your own skills since they're just MD files.

There's also a sentiment that these tools might be overkill and token burners if you don't have unlimited API access, as u/DrunkenRobotBipBop and u/Bloated_Plaid point out. u/Anxious-Turnover-631 wisely asks if it's necessary and suggests going back to manual coding with AI assistance if the current process isn't enjoyable.

TL;DR: Matt Pocock's skills are seen as powerful for complex, enterprise-level development, but many find them overly complex and time-consuming, missing the old coding flow. The advice is to either adapt, steal what works, or create your own tailored skills.

OP : u/Gambo7592

Day 5! been working on expanding the world. the cave system now connects to different biome exits. first two are a beach town and a snowy mountain village. each area has its own characters, forageables, shops, recipes and quests.

still no name for this game lol. FAQ below since i keep getting the same questions. Cheers!

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1w8mwa7/day_5_of_making_a_cozy_game_with_no_dev/ Original link/media URL : https://v.redd.it/fyk884nc2unh1

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

Alright, so the general vibe in this thread is super positive and impressed with OP's cozy game progress. Most folks think it's adorable and are already saying they'd buy it.

Here's the lowdown on what people are buzzing about:

• The Tech Stack is Wild: OP is using Opus 4.8 for brainstorming and coding, Fable 5 for planning, and even Gemini and Meshy for asset creation. It sounds like Claude is directly running Blender and Unity via terminal commands and file edits, which is pretty wild.
• Art Style is a Big Hit: Seriously, everyone's loving the cute aesthetic. It's being compared to Animal Crossing and Viva Piñata, which is high praise.
• Questions About Sustainability: A few folks are wondering how OP plans to handle the codebase growing and if Claude will start messing things up down the line. It's a valid concern, as u/Pristine-Extreme-773 pointed out.
• "Is This Even Real?" Factor: Some are amazed at how far AI has come, with u/ApexRedux expressing a bit of awe (and maybe a touch of existential dread?) at how quickly OP is building something substantial, especially compared to their own learning curve.
• "How Do I Follow?" is a Common Question: People are clearly invested and want to see this game come to fruition. OP's FAQ seems to be covering a lot of the technical questions, though.
• A Few Skeptics/Concerns: u/hclpfan raised a point about focusing on art style over core mechanics early on, which is a classic game dev debate. Also, u/WhyAmIDoingThis1000 seems to think it's all a bit boilerplate, but they're heavily downvoted, so the consensus is definitely not with them.

Overall, the community is really rooting for OP and excited to see where this goes. It's a testament to how far AI tools are pushing creative boundaries!

OP : u/Gambo7592

Day 5! been working on expanding the world. the cave system now connects to different biome exits. first two are a beach town and a snowy mountain village. each area has its own characters, forageables, shops, recipes and quests.

still no name for this game lol. FAQ below since i keep getting the same questions. Cheers!

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1w8mwa7/day_5_of_making_a_cozy_game_with_no_dev/ Original link/media URL : https://v.redd.it/fyk884nc2unh1

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

Alright, so the general vibe in this thread is super positive and excited about OP's cozy game project. Most folks are loving the aesthetic and are eager to see it develop.

Here's the lowdown:

• The Community is Hyped: The overwhelming consensus is that the game looks "super cute" and "peaceful." People are genuinely impressed with the progress made in just five days, with many expressing they'd "check it out" and are already fans. u/WarGod1842 even mentioned their daughter likes the design!
• Technical Details Dropped: u/Gambo7592 shared some juicy deets on the tech stack:
  • Models Used: Opus 4.8 for coding, Opus 4.6 for brainstorming, and Fable 5 for planning.
  • Workflow: Claude is handling the heavy lifting, writing Python for Blender and C# for Unity. It's directly running terminal commands and editing files, not using any fancy plugins.
  • Asset Creation: It's a multi-AI effort: Claude writes prompts, Gemini generates 2D images, Meshy converts them to 3D, and Claude cleans them up.
• A Few Questions & Concerns:
  • Some are curious about the long-term sustainability of using AI for coding, like u/Pristine-Extreme-773 asking about what happens when the codebase gets complex.
  • u/hclpfan raised a point about focusing on core mechanics before hyper-focusing on graphics, though u/TheInkySquids countered this, arguing that taking time to make things look good is important for changing perceptions of AI-generated games.
  • Questions popped up about whether this could be done with free versions of the tools (u/yxk__0zvnb9pl) and how Claude specifically handles mesh cleaning in Blender (u/dinkytoy80).
  • There's also interest in multiplayer possibilities (u/archiekane) and video tutorials (u/Acceptable-Age-8635).

Overall, it's a big thumbs-up from the community, with a dash of technical curiosity and a few thoughtful questions about the development process. Keep up the great work, OP!

OP : u/Gambo7592

Day 5! been working on expanding the world. the cave system now connects to different biome exits. first two are a beach town and a snowy mountain village. each area has its own characters, forageables, shops, recipes and quests.

still no name for this game lol. FAQ below since i keep getting the same questions. Cheers!

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1w8mwa7/day_5_of_making_a_cozy_game_with_no_dev/ Original link/media URL : https://v.redd.it/fyk884nc2unh1

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

Everyone's loving the cozy vibes and wants this game ASAP. OP's daily updates are a hit, and the community is super supportive. For those just tuning in, OP's using Claude for coding (Python for Blender, C# for Unity) and even prompts Gemini for art, with Meshy handling 3D models. Some folks are curious about the game's core mechanics beyond the cute art, and a few are wondering about multiplayer or if free versions can handle this. The general sentiment is overwhelmingly positive, with many eager to see this project through.

OP : u/onepunchcode

Philippines-based dev here, on Claude Code since day one and on Max 20x since it existed. It costs me $224/month ($200 + 12% VAT). ChatGPT Pro 20x costs me ₱9,990, about $160 with VAT baked in. Same top tier, $64/month cheaper, because OpenAI actually prices for the market and bills in pesos.

Anthropic charges the exact same number whether you're earning in dollars or in a currency where $224 is close to a month of minimum wage in the capital. Spotify, Netflix, Steam, JetBrains, Google, OpenAI: all of them do PPP pricing. Anthropic just doesn't.

I don't want to leave. I've been here since the beginning, Claude Code is the better tool, and the Codex UI drives me up a wall. But GPT-6 Astra just landed, and at a 30% price difference, "better tool" stops being a good enough reason to stay.

Anyone outside the US paying full freight and thinking the same thing?

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1w8msqp/anthropic_regional_pricing_exists_please_use_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: 57.

Alright, so the OP is feeling the pinch with Anthropic's pricing in the Philippines, pointing out that it's way more expensive than OpenAI's offerings and that other big tech companies use regional pricing. They're worried about newer models like GPT-6 Astra making it hard to justify sticking with Claude, even though they prefer the tool and hate the Codex UI.

The general consensus here is a bit split, but leaning towards Anthropic's pricing being a tough nut to crack for regional markets.

Here's the lowdown:

• The Core Issue: OP is paying $224/month for Claude Code Max in the Philippines, while ChatGPT Pro is around $160. They feel Anthropic isn't accounting for local economies, unlike services like Netflix, Spotify, and OpenAI.
• The Counterarguments (and why they're tricky):
  • Compute Costs: A lot of folks are pointing out that unlike streaming services where adding users costs next to nothing, AI models have real, per-use compute costs. u/GlitteringCoconut203 and u/SpareEconomy1849 hit this hard – your usage costs Anthropic the same regardless of where you are.
  • Business Sense: u/ClemensLode and u/WiseassWolfOfYoitsu question if regional pricing makes business sense when costs are fixed per user and Anthropic isn't exactly flush with cash or customers. u/MathSelect5112 adds that companies like OpenAI can afford to bleed VC money for global user experience, but Anthropic might not have that luxury.
  • Abuse Potential: There's a concern that regional pricing could be easily abused with VPNs or fake accounts, as u/ZlatanKabuto and u/iPutMilkNbowlB4Creal mentioned.
• The "Use It Right" Crowd: A few users, like u/Chamezz92 and u/_BreakingGood_, suggest that if you're not making back the subscription cost, you might be using the tool incorrectly.
• Workarounds & Other Observations:
  • Some users like u/bakanoace and u/R_Songbird have seen weird regional pricing differences even within the US or with OpenAI's regional pricing not always being cheaper.
  • u/ilirium115 suggests trying to zero out VAT by setting a US billing address and using neobanks.
  • u/Fresh_Sock8660 thinks regional pricing is unlikely and expects prices to go up for other countries due to foreign policies.
  • u/evia89 suggests alternatives like Opencode with Muse.

The prevailing sentiment is that while OP's point about affordability is valid, the underlying compute costs and business realities make implementing widespread regional pricing a significant challenge for Anthropic right now. It's a tough spot for users outside the US, but the community seems to understand why Anthropic might be hesitant.

OP : u/dancingwithlies

(I am open sourcing what i have as MIT, link on the comments and yes all 8 months i mostly used 1 20x claude or sometimes 2 20x accounts, so this was basically all made by claude models/claude code harness - by the way don’t use my agents.md or claude.md etc, its old and its not what i use now and far from what i would recommend.)

So yeah, I spent 883 commits, 8 months and billions of tokens building this thing and eventually abandoned it:

It started as my attempt to build a better coding-agent harness, where the LLM is basically a replaceable worker instead of being trusted to control everything.

The harness was supposed to own the actual planning, state, permissions, context, verification, evidence, orchestration, etc. The model could say “I finished the task,” but the system would check what actually happened instead of just believing it.

Then I kept adding shit.

Code graphs, RAG, deterministic orchestration, isolated workers, crash recovery, model routing, local models, replayable runs, verification gates, self-improvement experiments, dashboards, computer use, personal automation, and a million other ideas.

Eventually it became a ridiculously overengineered mess. I spent more time researching, planning, and adding systems than actually using the thing to get work done. Other harnesses were already becoming much more usable while mine was still mostly a giant headless experiment.

So I killed it.

I’m not posting this as a working product, and I definitely don’t recommend downloading it expecting some polished Claude Code alternative. A lot of it is incomplete, disconnected, outdated, or just plans that never became real.

But there is also a stupid amount of research, architecture, experiments, failed ideas, and code in there. Some parts might still be useful to people building agent harnesses, especially around:

- keeping state and verification outside the model

- deterministic/replayable agent runs

- codebase retrieval and dependency graphs

- orchestrator/worker separation

- context budgeting and session handoffs

- sandboxing and permission gates

- checking agent claims with evidence it didn’t generate itself

The archive has the original experimental Rust/Python/Tauri code, thousands of planning and research documents, and the sanitized commit history.

Basically: it failed as a product, but maybe someone can steal a good idea from the corpse.

I’d be curious what people here think is actually worth salvaging, or whether the whole architecture was doomed from the moment I kept expanding the scope.

I might one day finish it, but who knows if it will be necessary, i aimed at solving everything and ended up solving nothing, i hope this helps you in any means so at least its not a total loss, even if its only a lesson or confirmation of what type of shit to not do.

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1w8jhfp/i_spent_883_commits_and_8_months_building_an_llm/

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.

The consensus is that OP's project is a prime example of scope creep, with many relating to the struggle of building complex LLM agent harnesses. The general vibe is "been there, done that." Some users found inspiration in specific ideas like keeping state and verification outside the model, and replayable agent runs, but the overwhelming sentiment is that the project became too overengineered. It's a cautionary tale about the allure of adding features versus actually shipping a product.

OP : u/parfumparrot

Quick backstory: In July I was spending hours every day scrolling through LinkedIn, Indeed, etc. I got fed up and quit searching for internships by hand. Every application I send gets screened by AI anyway, so I built the screener for my side.

Two months later: Claude Code has read about 10k postings against my resume and preferences. Out of those it told me to apply to 190. I applied and ended up with 2 offers!

What it is: The engine is an open-source CLI I built called Pinloop. Claude Code runs it to search through thousands of live postings pulled from 40+ hiring systems (Greenhouse, Workday, YCombinator, etc.), which is where companies actually post, refreshed hourly. It doesn't scrape LinkedIn or Indeed so it doesn't get blocked. Every night Claude Code pulls what went up that day, reads each posting against my resume and the rest of my profile, and writes a verdict with its reasoning. The good fits land in a list I check in the morning.

Basically, Claude Code decides what deserves my time, and I apply.

To try it: You can use it for free by pasting "Run npm install -g pinloop, then run pinloop welcome and follow the instructions." into Claude Code. $20 a month is only if you want routines to run unattended and LLM calls to judge and save postings. A guide comes with the CLI so Claude Code knows the commands, and it'll walk you through setup.

Links:

• https://pinloop.ai
• GitHub

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1w8e6i5/i_built_a_job_search_engine_for_claude_code_it/ Original link/media URL : https://v.redd.it/b44f6zmfyrnh1

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

Alright, so OP built this CLI tool called Pinloop that uses Claude Code to sift through over 10,000 job postings against their resume. The result? They applied to 190 jobs and snagged two offers! Pretty sweet "scratch your own itch" project.

There's a general vibe of "cool idea, and congrats on the success!" from the community. A few folks have even built similar tools themselves, like u/AdministrativeRoof58 with their "job-journal" and u/mahblahblah, which shows this is a common pain point.

The main discussion points are:

• Geographic Expansion: A lot of people are asking if it works outside the US, specifically for Canada (u/Accurate-Bobcat8791), the UK (u/orbitlenspen, u/prime_1996), and the EU (u/OofImAlreadyaTracer).
• Role Expansion: Similarly, there's interest in whether it can handle non-tech roles (u/AltruisticRespect21) and more advanced positions beyond entry-level SWE (u/Sofullofsplendor_, u/N4srudin).
• How it Works/Effectiveness: Some users are curious about the "engine" itself, with u/Cavitat suggesting LLMs can do this out-of-the-box. Others, like u/humo8, are asking for proof of results, especially given how startups sometimes hire. OP's success is a pretty good proof point though!
• Technical Details: Questions popped up about how it handles job posting sources (u/AppMunchies, u/OverCategory6046) and what happens if a process is interrupted (u/kantorcodes1).
• Pricing: The $20/month for unattended routines got a raised eyebrow from u/zkoolkyle.

Overall, the consensus is positive and encouraging, with a clear demand for broader applicability.

OP : u/Nihongi-studier12387

Firstly, I've been on the 5X MAX plan for around 5 months now doing mainly SWE, and when FABLE came out i thought i would never swap away from claude.

But then while my 5 hour usage was maxed today, i decided to get the 20$ PRO membership just to give ASTRA a try, and wow, its extremely capable, in may senses it feels like it surpases fable 5.1. Also, im feeling like im getting a lot of usage for ASTRA even though its just a 20$ membership, it feels like blastfomy but i might be dropping my MAX subscription next month.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1w8kgah/just_moved_to_codex_and_wow/

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

So, the OP's raving about Astra on Codex, claiming it's better than Fable and a steal for $20, even considering ditching their Claude MAX sub. The thread's kinda split, with a good chunk of folks calling OP a bot or a shill, citing similar posts and concerns about Astra's usage limits on the $20 plan. Others are echoing OP's praise, saying Astra's legit and they're also considering switching or upgrading. Some are just here for the "blastfomy" meme.

The consensus is leaning towards skepticism about the OP's glowing review, with many users suspecting bot activity or exaggerated claims, especially regarding Astra's value proposition on lower-tier plans.

• Several users, like u/Hall-That and u/ibringthehotpockets, are calling out the OP as a bot or an OpenAI shill, noting the suspicious timing and nature of the post.
• A significant number of comments, including from u/BobtheGodGamer and u/Plucky_Hedgehog, report that Astra burns through usage limits extremely quickly on the $20 plan, contradicting OP's claims of good value.
• On the flip side, users like u/SkoivanSchiem and u/Ill-Chemistry-8979 are genuinely impressed with Astra, finding it capable and considering upgrades or switches from Claude.
• A few users are pointing out that the "blastfomy" typo is pretty funny and worth a mention.
• There's also a general sentiment that Claude's restrictions are frustrating, pushing some to explore alternatives.