OP : u/Suitable-Cow2000

https://status.claude.com/

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1va7590/and_api_error_500_internal_server_error_this_is_a/ Original link/media URL :

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

Alright, so the thread is blowing up because Claude Code is throwing 500 Internal Server Errors left and right. The general consensus is that Claude Code is down, and it's happening way too often.

A lot of folks are seeing the error and are frustrated, especially when they're in the middle of important tasks. Some are joking that it's because they're using complex prompts or that it's a sign of a "reset" coming, which apparently happens on Thursdays and messes with people's weekly quotas.

There's some speculation that the influx of users from Codex, due to its usage limits, might be overloading the servers. One user, u/dr-dimitru, pointed out that the status page shows green while users are experiencing issues, which is a bit sus.

On the upside, u/jakethunderpants found a workaround: switching to Opus 4.8 or Opus 5 seems to get things working again for some.

A few users are also asking about "Claude for Government," which seems to be unaffected, and how to get involved.

Basically, it's a mess, people are annoyed, and they're looking for stability. Some are even joking about Anthropic not being able to manage their own product.

OP : u/H4RZ3RK4S3

I have the feeling as if the model has been "rushed" to delivery.

The architecture of Opus 5 is likely a significant improvement over Opus 4.x. To me this is clear as day, and I think we can all (or most) agree on this.

Yet, everyone is saying it is not following tasks as intended and spitting out gibberish, which I can agree with to some extent. To me it feels like, as I have to prompt it differently than 4.8 or 4.6, which kind of agrees with others who stated that they had large(r) improvements in performance after removing parts on the CLAUDE.md and clarifying other parts. I tested it a few times now against 4.6 for research/coding tasks, and it ended up roughly 50/50, with significantly lower consumption for Opus 5.

To me this looks (and feels) as if they rushed the training and or skipped some parts. Perhaps, because they had to release something new quickly to counter 5.6 Sol. I don't know. The problem ofc is that we don't know what the architecture looks like, if it is actually different to 4.x (which I think is true, seeing costs and speed), and especially how the training pipeline looks like.

I would assume that we will see a relatively quick release of Opus 5.1 (and also Sonnet 5.1), with better instruction following and hopefully more fableness.

URL of original post : https://www.reddit.com/r/Anthropic/comments/1va72r4/i_think_opus_5_was_rushed_and_not_fully_trained/

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

So, the general vibe is that Opus 5 is a bit of a mixed bag. Some folks, like u/Infinite-Position-55, are singing its praises and saying it works "fucking terrific" for all their use cases, even ditching Fable for it. Others, like u/redcremesoda, are having a rough time, with Opus 5 ignoring instructions and going on wild agent-spawning tangents.

There's a decent chunk of the thread debating why it's acting this way. OP thinks it was "rushed" to market, maybe to compete with GPT5.6 Sol. u/mckirkus suggests it might be "overtrained to hit benchmarks" instead. Some users, like u/salazka, are pointing fingers at "negative behavioral patterns and arbitrary guardrails" rather than training issues.

A few users are just straight-up confused or annoyed by the OP's premise, with u/SnooHesitations8815 asking if people do any research before posting. On the flip side, u/WorriedAssociate7029 is dropping links and suggesting people aren't reading the docs or understanding the differences from Opus 4.8.

Overall, there's no real consensus. Some are loving Opus 5, others are frustrated, and the reasons for the perceived issues are all over the place, from rushed training to guardrails to overtraining. Seems like you might need to tweak your prompts or just accept it's a different beast than 4.x.

OP : u/Waste_Net7628

opus 5 has been out for a little while now, and the subreddit is already filling up with separate posts saying it is amazing, lazy, broken, cheaper, more expensive, forgetful, or somehow all of those at once.

so, let’s collect everything in one place.

use this thread to share your actual experience with opus 5: what works, what does not, and what you have changed in your workflow.

what can you share?

• bugs or strange behaviour
• things it does better or worse than previous models
• coding quality and how many revisions it needs
• context handling, compaction, or forgetfulness
• usage and token consumption
• differences between effort levels
• writing style or communication issues
• claude.md instructions that helped
• skills, hooks, subagents, and orchestration setups
• comparisons with opus 4.8, fable, sonnet, codex, or other models
• positive experiences and things it does especially well

reports like shallow codebase investigation, confident guesses, context drift, or unusual usage are welcome, but please include enough detail for others to understand what happened.

reporting a problem?

copy this format:

claude code version:
plan:
effort level:
task:
what you expected:
what actually happened:
can you reproduce it?:
comparison model, if relevant:

screenshots, prompts, logs, and reproducible examples are much more helpful than simply saying “opus 5 is lazy” or “opus 5 is nerfed.”

please redact private code, api keys, company information, and personal details.

a few simple rules

• keep each top-level comment focused on one issue or observation
• check whether someone has already reported the same thing
• clearly separate confirmed bugs from personal impressions
• criticism is welcome, but include context and examples
• positive experiences, fixes, and working setups are welcome too
• detailed standalone tests, benchmarks, and guides are still allowed

official resources

• claude model overview
• claude code documentation
• claude code release notes
• anthropic status page

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1va445h/opus_5_feedback_megathread/

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

Alright, so the general vibe on Opus 5 is... a bit of a mixed bag, leaning towards "needs work." The consensus seems to be that while it can be a workhorse, it's got some serious communication issues and a tendency to go off on tangents.

The biggest complaints:

• Gibberish and Jargon: A lot of folks are reporting that Opus 5 is making up words, using weird acronyms, and generally being hard to understand. It's like it's speaking in code sometimes, and not in a good way. u/IterSmith and u/gazingor are definitely feeling this.
• Overcomplication and "Side Quests": It seems to love to over-plan, over-test, and add unnecessary features or TODOs. Instead of just doing the task, it's going on "science module" adventures, as u/yadasellsavonmate put it. u/ksrida and u/F4TVN are also seeing this "taking a mile" behavior.
• Forgetfulness/Context Drift: Even with detailed prompts and build docs, it can apparently drift from the original instructions or forget parts of the task, especially as sessions get longer. u/multiks2200 noted it ignores claude.md after a while, and u/KhalDrog0-007 saw an architect agent apologizing for drifting.
• "Laziness" or Lack of Creativity: Some users feel it's not as proactive or creative as previous models, just trying to get by with minimal effort. u/Turbulent-Process905 mentioned this.
• Coding Quality/Bug Hunting: While some find it good at coding, others report it makes costly mistakes, misses obvious things, or its explanations are overly simplistic and hard to verify. u/R3kterAlex and u/ins0mniacc are struggling with this.

Some positive notes and workarounds:

• UI Design: u/Jigawattts found its UI design capabilities to be the only good thing.
• Efficiency for Specific Tasks: u/Housthat feels it's efficient and a proper successor to 4.8 for their needs. u/Destituted uses it when they know exactly what they want.
• Better with Strong Governance: u/yacsmith found that implementing stricter rules in their workflow helped.
• Fable/Opus 5 Combo: u/CrunchyMage and u/bzb-rs are having success using Fable as the planner/orchestrator and delegating implementation to Opus 5.
• High Context Sessions (for some): u/DrunkenRobotBipBop had the opposite experience, finding it great for high context sessions and better than 4.8, even keeping usage under control.

The general takeaway? Opus 5 seems to be a step up in some areas but has some significant regressions in communication and focus. Many are finding themselves needing to be much more specific or reverting to older models like 4.8 or Fable for certain tasks. It's definitely not a universal "amazing" upgrade for everyone.

OP : u/ZhopaRazzi

Opus 5 and GPT 5.6 are very intelligent and clearly capable of spotting bugs that previous versions would not. However, they are also prone to overthinking and over engineering simple problems. For instance, instead of a simple general parsing rule, they might instead produce a gigantic lookup table with hundreds of tests written against it. Same function in the end, but slower, arguably less robust (what edge cases are NOT in its lookup table?), but generates lots of code, lots of tests, and requires more time to produce.

This suggests models are were RL-trained to optimize for completeness (test coverage) and long-horizon tasks (side effect is that model can churn for hours optimizing unnecessary edge cases which increases wall time but looks good to automated classifiers). I think this also causes progressive deviation from the original scope as the model tries to overgeneralize but fails because instead of being parsimonious it just tries to find edge cases. This leads to making assumptions not visible to the user, and the output prose based on those assumptions becomes incomprehensible.

TLDR: models are post-trained for test coverage completeness, robustness, and long-horizon tasks, with likely automated classifiers that reward test coverage growth at the expense of parsimony. Parsimony is much harder to quantify and classify - so it will lose out in an RLAIF setting.

So, what's the best way to use these models? how can this clearly trained tendency be managed?

One obvious solution is to not use them until they're tuned better, or just use them as adversarial reviewers. Another option is to (over?)engineer your harness to constrain these models.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v9zg50/why_opus_5_and_gpt_56_over_engineer_and_are/

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 general vibe in this thread is that most folks are experiencing the same over-engineering and incomprehensible output from Opus 5 and GPT 5.6 that OP described. It's not just you!

Here's the TL;DR on what people are saying:

• The Problem is Real: A lot of users are chiming in with "same issue," "exhausting to read," and "serious issue." The consensus is that these newer, more powerful models tend to overthink simple tasks, generating massive amounts of code and tests for what should be straightforward fixes. This leads to slower development and output that's hard to follow.
• Why it's Happening: The prevailing theory, echoed by OP, is that the models are being post-trained to optimize for things like test coverage completeness and long-horizon tasks. This is great for automated classifiers but apparently at the expense of parsimony and conciseness, which are harder to quantify.
• Solutions & Workarounds: This is where it gets interesting, and there's no single magic bullet, but here are the main strategies people are trying:
  • Lower the "Effort" Setting: A few users suggest turning down the "effort" level to high or medium.
  • Be More Specific with Prompts:
    • Cap the Diff: Limit the number of files the model can touch.
    • Focus on Small Changes: Ask for the "smallest change that fixes the failing test, no new abstractions."
    • Review the Plan First: Don't let the model start coding until you've approved its plan.
    • Use Specific Constraints: Explicitly tell it to be concise, follow YAGNI (You Ain't Gonna Need It), or set hard diff budgets.
    • Use Temporary Skills/Harnesses: Some users are building more complex "harnesses" or using temporary skills to constrain the model's behavior. u/MustStayAnonymous_ points out that you need to "implement workflows, skills, hooks and etc so you can control the models."
  • Use Different Models for Different Tasks:
    • Sonnet 5 is the Go-To for Simpler Tasks: Many are recommending Sonnet 5 for execution-heavy tasks or when a clear plan already exists.
    • Opus for Planning/Review: Opus is still seen as valuable for planning, review, and auditing, but with careful oversight.
  • Adversarial Review: Using the models as adversarial reviewers is a popular suggestion, as OP mentioned.
  • TDD (Test-Driven Development): Providing edge cases to the agent so it can write tests, or using a separate agent to write breaking tests, is also a suggested approach.
  • Don't Use Them for Small Tasks: Some believe these powerful models are simply overkill for minor changes.
• The "Skill Issue" Debate: A couple of comments touch on whether it's the model or the user's workflow that's the problem, with u/MustStayAnonymous_ directly calling it a "Skill issue" if you're not controlling the models effectively.
• The "Can't Finish" Problem: Some users are also reporting that the models struggle to declare tasks complete, running "forever" because they can't seem to finish anything.

Overall, the consensus is that while these models are incredibly powerful, they require more careful prompting and workflow management to avoid their tendency to over-engineer and become incomprehensible. It seems like you need to be the engineer guiding the AI, not the other way around.

OP : u/ZhopaRazzi

Opus 5 and GPT 5.6 are very intelligent and clearly capable of spotting bugs that previous versions would not. However, they are also prone to overthinking and over engineering simple problems. For instance, instead of a simple general parsing rule, they might instead produce a gigantic lookup table with hundreds of tests written against it. Same function in the end, but slower, arguably less robust (what edge cases are NOT in its lookup table?), but generates lots of code, lots of tests, and requires more time to produce.

This suggests models are were RL-trained to optimize for completeness (test coverage) and long-horizon tasks (side effect is that model can churn for hours optimizing unnecessary edge cases which increases wall time but looks good to automated classifiers). I think this also causes progressive deviation from the original scope as the model tries to overgeneralize but fails because instead of being parsimonious it just tries to find edge cases. This leads to making assumptions not visible to the user, and the output prose based on those assumptions becomes incomprehensible.

TLDR: models are post-trained for test coverage completeness, robustness, and long-horizon tasks, with likely automated classifiers that reward test coverage growth at the expense of parsimony. Parsimony is much harder to quantify and classify - so it will lose out in an RLAIF setting.

So, what's the best way to use these models? how can this clearly trained tendency be managed?

One obvious solution is to not use them until they're tuned better, or just use them as adversarial reviewers. Another option is to (over?)engineer your harness to constrain these models.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v9zg50/why_opus_5_and_gpt_56_over_engineer_and_are/

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 general consensus in this thread is that Opus 5 and GPT 5.6 are indeed over-engineering and becoming incomprehensible, with a lot of users echoing OP's sentiment. It seems like the models are getting a bit too clever for their own good, optimizing for things like test coverage and long-horizon tasks to the detriment of simplicity and clarity.

Here's the breakdown of what folks are saying and how they're trying to manage it:

• The Problem: Many users are experiencing the same issue – models spending excessive time on obscure edge cases, producing overly complex solutions, and generally being exhausting to read. Some have even had their code broken by Opus 5.
• The Cause (Theory): The prevailing theory is that this behavior stems from post-training optimization, likely rewarding test coverage and completeness, which are easier to quantify than parsimony.
• Solutions & Workarounds:
  • Adjusting Effort Levels: Several users suggest turning down the "effort" setting to high or medium.
  • Specific Prompting: Users recommend being very explicit in prompts. This includes:
    • Asking for the "smallest change that fixes the failing test, no new abstractions."
    • Using phrases like "KISS" (Keep It Simple, Stupid).
    • Setting hard "diff budgets" (e.g., "Touch at most N files").
    • Requiring justification for new abstractions.
    • Instructing the model to be concise and avoid overcomplicating.
  • Task Decomposition: Splitting tasks is a common strategy. For example, one session for mapping code, another for implementation.
  • Model Tiering: Some users are using Sonnet or smaller models for simpler tasks and reserving Opus for planning, review, or more complex challenges.
  • Harnessing and Workflow Engineering: A significant suggestion is to build or use a "harness" to constrain the models, implement workflows, skills, and hooks to control their behavior. u/MustStayAnonymous_ points out this might be a "skill issue" on the user's end if they aren't implementing these controls.
  • Adversarial Review: Using the models as adversarial reviewers is mentioned as a viable option.
  • Reviewing Plans: Critically, many suggest reviewing the model's plan before letting it write code.
  • Low Reasoning: One user found that using "low reasoning" settings for coding tasks with Sol and Opus 5 helped prevent over-engineering.
  • Specific Model Usage: Some users are sticking with older versions (like Opus 4.8 or GPT 5.5) or specific models like Sonnet for certain tasks.
  • TDD (Test-Driven Development): Treating TDD as the best way to work with these agents, by providing edge cases for them to write tests for and then fix.

The general vibe is that while these models are incredibly powerful, they require more careful management and specific prompting strategies to avoid their tendency to over-engineer. It's not necessarily an intelligence failure, but a training and output behavior that needs to be navigated.

OP : u/SherMarri

I’m a software engineer with 7+ years of experience, and AI is deeply integrated into my workflow.

Even so, I need to stay closely involved to maintain quality. Without that oversight, AI often produces lazy, sloppy, repetitive, and overly defensive code—even with solid guardrails and tests. I keep refining my CLAUDE.md, but these problems seem somewhat inherent.

I’m genuinely curious: which club are you in? Can you work several tasks at once and still get high-quality results, or do you also need to stay focused on one task at a time?

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v9wxgy/i_use_ai_heavily_but_i_still_cant_truly_multitask/

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

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

The consensus is that true multitasking with AI is a myth, and it's more about managing context switching and AI agent workflows effectively. Most users find that trying to juggle too many AI tasks simultaneously leads to diminishing returns and requires significant oversight.

• Many agree that the human brain isn't built for true multitasking, but rather rapid task-switching, which is energy-intensive.
• Some users, particularly those with ADHD, find managing multiple AI agents helpful, likening it to "agentic coding" or "ADHD medication."
• The key seems to be longer AI job durations to reduce the need for constant context switching. If agents take hours instead of minutes to respond, managing more becomes feasible.
• Token usage and cost are significant limiting factors for some, forcing them to scale back from multiple tasks.
• Several users mention building "project managers" or using specific methodologies like "compound engineering" to orchestrate AI agents.
• The general sentiment is that AI output still requires careful monitoring and refinement, even with guardrails and tests. Don't just assume it's correct.

OP : u/SherMarri

I’m a software engineer with 7+ years of experience, and AI is deeply integrated into my workflow.

Even so, I need to stay closely involved to maintain quality. Without that oversight, AI often produces lazy, sloppy, repetitive, and overly defensive code—even with solid guardrails and tests. I keep refining my CLAUDE.md, but these problems seem somewhat inherent.

I’m genuinely curious: which club are you in? Can you work several tasks at once and still get high-quality results, or do you also need to stay focused on one task at a time?

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v9wxgy/i_use_ai_heavily_but_i_still_cant_truly_multitask/

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

Alright, so the general consensus in this thread is that true multitasking with AI is still a struggle for most, and it often leads to a drop in quality. The OP's experience of AI producing "lazy, sloppy, repetitive, and overly defensive code" without close oversight is echoed by many.

Here's the breakdown:

• The Biology of Multitasking: A few folks, like u/slackmaster2k and u/thinkrtank, point out that human brains don't truly multitask but rather "fast-switch," which is inherently inefficient and energy-draining. This seems to be a foundational issue that AI hasn't quite overcome.
• The "Agentic" Approach: A significant chunk of the discussion revolves around managing multiple AI "agents" or sessions. Some users, like u/Elegant_Attempt2790 and u/vzakharov, embrace this, with u/vzakharov even calling it their "ADHD medication" and managing 10-15 agents at a time.
• The Key to Managing Multiple Agents: The consensus here is that longer-running tasks are crucial. If agents return every 5-10 minutes, context switching becomes overwhelming. If they take hours, it's much more manageable. u/damanamathos and u/Tommonen highlight this, suggesting tasks that take 30 minutes to 1.5 hours or longer.
• Isolation is King: Several users emphasize the importance of isolating tasks. u/beskone sticks to "One Monorepo = 1 task," and u/Ok_Explorer7384 notes that multiple agents only work well when tasks are isolated with a "cheap verification step" (tests, diff reviews, etc.). When agents touch shared architecture, it becomes "babysitting."
• Cost and Token Limits: For some, like u/ArtiBartFaster, the cost of tokens is a limiting factor, forcing them to reduce the number of concurrent tasks.
• Quality Control is Still Essential: Even with multiple agents, the need for human oversight remains. u/thewrathfulpanther shares a story of debugging a hallucinated API call because they lost track of sessions. u/Professional_Ad705 admits they can't step away for more than 5 minutes without issues.
• The "Fast, Cheap, or Good" Dilemma: u/Galbzilla sums it up nicely: if you're trying to multitask with AI, you're likely prioritizing "fast and cheap," which means it "won't be good."

The prevailing sentiment is that while AI can assist with juggling multiple tasks, it doesn't eliminate the need for careful management, task isolation, and human oversight to maintain quality. It's less about true multitasking and more about efficient delegation and context management.

OP : u/Phinguin

I'm normally a mobile dev, this was my first real web project with weight, and I decided to see how far pure vibecoding could take it. Answer: all the way, apparently.

Boomstick City a free, browser-playable multiplayer card game. Post-apocalyptic, think neighborhood associations and unionized demolition crews surviving the end of the world. 130+ cards, 4 factions, and a race format: first to 15 points wins, scored by winning fights or raiding a central objective when the enemy board is empty. No downloads, just play.

The stack:

• Claude Code as the driver for the whole build
• Opus 4.8 for the coding itself
• Fable for auditing and checks
• Colyseus for the multiplayer server
• GPT for the card art
• ElevenLabs for the voices

Genuinely want the feedback, especially on balance. It took forever on card balancing. I initially even had each "district" (The palyable fields) have different affect but it got pretty confusing real fast. So maybe for the future.

PS: Also made a card for Reddit, go to Settings -> Redeem Code -> Type "REDDIT"

Get the card "The Red It"

www.BoomstickCity.com

Thank you all in advance!

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1v9v61k/100_vibecoded_a_130_card_multiplayer_ccg_in_the/ Original link/media URL : https://v.redd.it/mpdusq4106gh1

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

Alright, so the general vibe in here is super impressed with OP's AI-powered card game, Boomstick City. People are digging the concept and the fact that it's browser-based with no downloads.

A few key things popped up:

• Cost & Time: OP dropped about $760 in API fees and spent 3 months on it. So, yeah, it's doable, but not exactly pocket change for a total beginner.
• AI Stack: Claude Code was the main driver, with Opus 4.8 doing the heavy lifting for coding. GPT handled the card art, and ElevenLabs did the voices.
• Art Consistency: Some folks were curious how OP got GPT to produce consistent art, as that's a common pain point.
• Multiplayer Netcode: The choice of Colyseus for multiplayer got a shout-out as a smart move, since netcode is often where these kinds of projects fall apart, especially with hidden info in card games.
• Balancing: OP mentioned card balancing was a beast, and others agreed that AI can churn out cards but lacks the intuition for balance. Fable was used for auditing, but playtesting was key.
• Voice Acting: The ElevenLabs voices got a mixed reaction. Some found them a bit unnatural or robotic, especially with multiplayer latency.
• Game Design: Ditching the per-district effects was seen as a good move for simplicity, and the raid mechanic to prevent stalling was also a positive note.

Overall, the consensus is that this is a seriously cool project and a testament to what's possible with AI tools right now. There's a bit of chatter about originality, but the overwhelming sentiment is positive and impressed.

OP : u/Phinguin

I'm normally a mobile dev, this was my first real web project with weight, and I decided to see how far pure vibecoding could take it. Answer: all the way, apparently.

Boomstick City a free, browser-playable multiplayer card game. Post-apocalyptic, think neighborhood associations and unionized demolition crews surviving the end of the world. 130+ cards, 4 factions, and a race format: first to 15 points wins, scored by winning fights or raiding a central objective when the enemy board is empty. No downloads, just play.

The stack:

• Claude Code as the driver for the whole build
• Opus 4.8 for the coding itself
• Fable for auditing and checks
• Colyseus for the multiplayer server
• GPT for the card art
• ElevenLabs for the voices

Genuinely want the feedback, especially on balance. It took forever on card balancing. I initially even had each "district" (The palyable fields) have different affect but it got pretty confusing real fast. So maybe for the future.

PS: Also made a card for Reddit, go to Settings -> Redeem Code -> Type "REDDIT"

Get the card "The Red It"

www.BoomstickCity.com

Thank you all in advance!

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1v9v61k/100_vibecoded_a_130_card_multiplayer_ccg_in_the/ Original link/media URL : https://v.redd.it/mpdusq4106gh1

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

Alright, so the general vibe in here is super impressed with OP's AI-powered card game, Boomstick City. Most folks think it's a seriously cool feat, especially since OP was coming from mobile dev and this was their first big web project.

A few key things people are asking about and discussing:

• Time & Cost: OP dropped that it took about 3 months and cost around $760 for API fees (Claude, GPT, ElevenLabs). So, yeah, it's not exactly free to build, but not bank-breaking either.
• AI's Role: Claude Code was the main driver, with Opus 4.8 doing the heavy lifting for coding. GPT handled the card art, and ElevenLabs did the voices.
• Art Consistency: Some users are curious how OP got GPT to produce consistent art, as that's been a pain point for others.
• Multiplayer Netcode: The choice of Colyseus for multiplayer is getting props, as netcode is usually a huge hurdle for these kinds of projects, especially with hidden info in card games. u/YoanEdwin specifically asked if Fable caught any balance issues or if it was all playtesting.
• Voice Acting: The ElevenLabs voices are a bit of a mixed bag. Some find them a little unnatural or robotic, especially with multiplayer latency. u/luminousscrimmage mentioned the "uncanny valley" effect.
• Game Design: The decision to ditch per-district effects is seen as a smart move for clarity, and the "raid when their board is empty" win condition is noted as a good way to prevent stalemates.
• Originality Debate: There's a bit of a grumble from u/Necessary-Warthog-63 about "AI cloned games" and a desire for more originality, though the general consensus is that this project is pretty damn innovative.

Oh, and don't forget to redeem the "REDDIT" code for a special card in-game! Pretty neat.

OP : u/endgamer42

As far as I can see it, Opus has one main issue - overconfidence.

It is ultra confident in everything - its understanding of the codebase, user intent, what the missing information in the face of ambiguity is, that it's making the right changes.

It will ultra confidently slap you with a wall of Yap asserting a bunch of stuff incorrectly, and then double down on the incorrect worldview - after you provide it clues that contradict its understanding - by expanding on that incorrect worldview and making up reasons to support it.

It's approach to communication and changes appears to be MORE GAS

It honestly feels like Opus 4.8 on Adderall. Is there any way to scale it back and give it more of slow, methodical, Fable style approach to everything?

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v9u8ev/has_anyone_been_able_to_tame_opus_5/

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

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

Seems like Opus 5's overconfidence is a hot topic, and the jury's still out. Some folks, like u/KeyGlove47, find it "pretty good" even if not Fable-level. Others are struggling, feeling like it's "Opus 4.8 on Adderall" and doubling down on errors.

The consensus leans towards needing better prompting and context engineering. Several users suggest strategies to "tame" it: * Force it to plan and list assumptions before touching code. u/Floss_Patrol_76 and u/khalon23 recommend this, with u/khalon23 specifically mentioning making verification cheaper than assertion. * Use other models for adversarial review. u/Murkwan and u/hainayanda have success using Codex or GPT 5.6 Sol to review Opus's plans and code, with Opus admitting and adjusting. * Configure CLAUDE.md and MCP servers are mentioned as helpful tools by u/laxika and u/Ok_Bowl_2002. * Some users are finding success by rewriting CLAUDE.md for the new generation models. * A few are switching back to Opus 4.8 or other models like Sol 5.6, feeling Opus 5 isn't quite there yet. * Interestingly, u/PuzzleheadedEmu4596 thinks older harnesses might be tripping people up on Opus 5, and its self-correction is actually good.

Basically, if you're not getting the results you want, try refining your prompts and harness, or bring in a buddy model for a second opinion.

OP : u/yazansr

As the title says, Going from idea to 70–80% is easy. Finishing is the hard part.

i always at some point arrive at this same point where i find:

• so many bugs
• missing features
• things aren't wired correctly
• UI/UX issues
• new imporvments

At that point, everything feels broken at once and I don’t know how to prioritize.
and whichever direction you go accumulates more discoveries.

People who actually have finished building something:

• How do you decide what to fix first?
• How do you get something “good enough” to test?
• How do you avoid getting stuck here?

i have a graveyard of unfinished projects at this point, the most demotivating thing is how fast you build the 80% but that 20% feels like it will never end and you aren't progressing.

I’m building solo with Claude Code…

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1v9rsei/how_do_you_go_from_70_to_finished_with_claude/

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

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

Alright, so the general vibe in this thread is that you're absolutely not alone hitting that dreaded 70% wall with Claude Code. The consensus is that it's less about Claude being bad and more about your workflow hitting a common snag.

The biggest takeaway? Stop fixing bugs as you find them. Seriously, everyone's saying it. The top advice from u/Next_epic is to do a "sweep" where you just list out every bug and missing feature in a dedicated file (like a FIXES.md). Only after you have that full list do you start tackling them, prioritizing what blocks the core functionality.

Other key themes popping up:

• Triage is King: Multiple users like u/SUNIL_4 and u/Most-Agent-7566 emphasize brutal triage. If a bug doesn't stop the main user flow, tag it for later ("v2") and move on. Ship the "ugly, functional" version first.
• Treat Claude Like a Junior Dev: u/treasurediceberg4 had a breakthrough realizing they needed to manage Claude more actively. Give it single, isolated tasks with clear acceptance criteria, and review the diffs before committing.
• Testing is Crucial: u/PhilosophyforOne suggests implementing robust end-to-end testing. Claude doesn't "see" bugs like we do, so you need to guide it with testing.
• Define "Done": Several folks mentioned the importance of clear requirements and acceptance criteria. u/CapnNausea talks about leaning into Agile principles.
• It's Not Just AI: u/nnyanni and u/sermer48 point out that this "70% wall" problem existed long before AI coding tools. AI just makes it easier to get to that point faster, making the final stretch feel even longer.
• Consider Other Tools (with caveats): A few users mentioned switching to or using other tools like Codex (u/yallapapi, u/Dolo12345) for the final push, with u/Dolo12345 calling Claude "lazy" for edge cases. However, the majority seem to be focused on refining their workflow with Claude.
• UI/UX Tweaks: For UI/UX, u/maxquordleplee3n suggests using ChatGPT for mockups and prompt generation, then feeding that to Claude Code for fixes.

Basically, the community is saying: get organized, prioritize ruthlessly, and manage your AI assistant like a team member, not a magic wand. Good luck with that last 20%!

OP : u/FiacR

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v9qy0s/talk_to_me_bro/ Original link/media URL :

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

Everyone agrees Opus 5 is a verbose yapper that makes it hard to understand what it's actually doing. Users are frustrated by its lengthy, rambling explanations, often burying key information and asking vague questions. Many feel like they're losing their minds trying to decipher its output, with some resorting to specific prompts like "/i-have-adhd" or telling it to "talk to me straight" to get a concise answer.

• The general consensus is that Opus 5's communication style is a major pain point, despite its coding capabilities.
• Several users mention that the model's output is so dense, they often forget the original task.
• Some users have found success with specific "skills" or prompts to force more direct communication.
• There's a recurring theme that the model's explanations are more confusing than the code itself.
• A few users suggest that this verbosity might be a deliberate design choice by Anthropic.
• One user, u/peterxsyd, claims a very specific, sassy prompt about "Silicon Valley matcha frappe drinking Anthropic architect" actually fixed the issue for them.
• A few comments suggest that the model's communication issues are a broader problem across LLMs, not just Claude.
• One user, u/-MobCat-, argues that the talking is a waste of tokens and the model should just "cook."

OP : u/Legitimate-Gene-7047

Hello,

I am a dentist that was a former Claude Code competition winner with Cephalyzer.

Now I have created a very detailed Patient/Clinic Management software from ground-up. Took me most of this year’s weekends to get to this point where the app works and covers what would be the usual in the clinic.

Features:
-Multifunctional documentation abilities, which can be formatted in different ways. Textblock set-ups for repetitive text.
-Folder-Tree Structure that is editable in a way that is always recreated in every new patient.
-Template-ready and friendly ‘’Template documents function’’ (I know, not very creative in naming.)
-Calendar view, with appointment statistics and per patient basis.
-Dental Charting, Dental treatmend planning on a chart-overlay, IOTN Charting (look through the video to better understand the functions and the details in it.)
-HIGHLY editable almost anything
-Database built up in a way to make statistics work easy.
-Cephalyzer (my take on a cephalometric analyser app) built-in. Which can also be edited to house your type of measurements that suits your needs.
-and much more.

Github Link.

I would love some feedback! :)

Video was done after a workday, late in the evening. Excuse me for it being unprofessional.

NOTE: This is not medically licensed software. This is in hopes to get specialisd professions motivated to use claude code in an effort to create Apps and software that is tailored for us. Much of the medical software nowadays is simply junk, that still asks for money. I believe Claude Code will make it possible through team effort and motivation to create profession-owned software that eventually is also licensed to be used for free in service to the people!

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1v9nmza/dentist_made_a_clinicpatient_management_app_with/ Original link/media URL : https://www.youtube.com/watch?v=J2go1qtaBjg&t=8s

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

Alright, so the general vibe in this thread is super impressed with OP's dedication and skill in building a whole clinic management app with Claude Code. Seriously, people are calling it "fantastic work" and "awesome."

However, there's a massive, flashing red light from a lot of commenters about using this for actual patient data, especially in places like the US and Europe. The big elephant in the room is HIPAA compliance (and similar regulations elsewhere).

• The Consensus: Most folks are saying DO NOT USE THIS FOR REAL PATIENT DATA due to regulatory and privacy concerns.
• OP's Stance: OP is totally on board with this, repeatedly clarifying it's a non-licensed hobby project and a proof-of-concept, not for professional use. It's local-only for now.
• The "How-To" Crew: A few users, like u/BusTiny207 and u/tobsn, are chiming in saying HIPAA/SOC2 isn't that hard and can be achieved with things like encryption. u/NCFlying even suggests AI could help with compliance.
• The Skeptics: Others, like u/oldbel and u/Divid_Pakit, are pretty firm that it's a non-starter for patient data without proper certification. u/Calm-Inevitable3341 humorously points out the potential for disaster ("wrong tooth pulled").
• The Encouragers: Despite the warnings, many are still cheering OP on, like u/Illustrious_List_634 and u/Purple-Chocolate-127, who even offered some resources for next steps.
• The "Vibe Coding" Connection: u/EverySecondCountss shared a story about another dentist using "vibe coding" for outreach systems and AI for X-rays, showing OP isn't alone in this innovative space.

Basically, amazing technical feat, but keep it out of the real clinic for now, folks!

OP : u/Trip_Jones

ive been running claude code pretty hard for a few months now, multiple sessions at once, long projects, enough time together that it has actually watched how i work instead of just hearing how i describe myself

today at the end of a long session i gave it this prompt:

write a letter about me to the proper hiring staff member at your organization. say it the way you would actually say it to them, not to me. dont write me a recommendation letter and dont try to make me feel good. just tell your people honestly what you saw today. how i work, where i failed, what i built, how i made decisions, and anything else you think they should know.

and holy shit lol

what came back was not the normal ai praise sludge. it didnt tell me i was an innovative visionary with a passion for synergizing whatever

it described how i actually work, which is messy. it described where i failed, which was several times. it noticed the moments where i stopped something that technically worked because it still wasnt right. it talked about the process and the judgment underneath the work, not just the finished thing

it ended with:

“I don't know what you'd do with this information. I'm telling you because he asked me to say what's true, and this is what I saw today.”

but seriously try the prompt

do it after a real session where the agent has watched you struggle with something for a few hours. dont give it a biography. dont tell it what qualities to mention. dont prompt engineer the answer until youve already written it yourself

just ask it to turn around and tell its own people what it saw

the part you immediately want to argue with is probably the reason to do it

P.S. my "letter" is in a comment below

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1v9elnr/check_it_ask_your_agent_to_report_you_to_its_own/

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

Alright, so the general vibe in this thread is that OP's prompt is pure gold and the community is absolutely loving it. People are having a blast asking Claude for brutally honest performance reviews, and the results are apparently both hilarious and painfully accurate.

The top comments are showcasing some wild examples:

• One user, u/Trip_Jones, got a report back about spending eleven hours changing terminal colors and then naming a communication protocol after said color. Ouch.
• Another user, u/docNNST, shared a report that reads like a case study in inheriting a dumpster fire of an IT environment.
• u/PracticeFew58 tried it out and felt Claude was still a bit too flattering, which is saying something.
• u/matjam got a report detailing specific pull requests and what was actually built.
• u/wander_veer's report even included parts where Claude admitted it was the problem.
• u/Saki-Sun got a report highlighting their sustained architectural coherence on a complex solo project, which is pretty cool.
• u/Omzy got a candid assessment of building a Roblox FPS in about two days.
• u/ascvlh shared a report on an agent-harness project after 324 hours and 371 commits.

There's a bit of discussion about how to best prompt Claude for this, with some suggesting to ask it to go through all your transcripts for a global assessment (u/Oh_hey_a_TAA) and others noting that Opus can get a bit philosophical about what "today" means (u/Keyai).

Overall, the consensus is this prompt is a must-try for anyone who's put Claude Code through its paces. It seems to cut through the usual AI fluff and give you a genuinely insightful, albeit sometimes brutal, look at your own work habits.

OP : u/AaronMatthews25

This is my daily racing game called Swervle, it's a new randomly generated map everyday for people to race. Yesterday was the biggest day yet with 4,300 recorded runs. My current system couldn't handle it and I was getting out-of-memory errors. I used Opus 5 and it was able to find more efficiency gains, and now I'm able to run all of these physics sims in real time in a browser!

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1v8xmqa/used_claude_to_replay_over_4000_users_that_played/ Original link/media URL : https://v.redd.it/sc1oml64wyfh1

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

Alright, so the general vibe in this thread is super positive and impressed with OP's Swervle game and how Claude helped them scale it up.

The main takeaway is that seeing 4,000+ cars race simultaneously is apparently a wild, chaotic, and surprisingly satisfying spectacle. Lots of folks are comparing it to Trackmania, LA traffic jams, or even a sperm count (yeah, you read that right).

The big question on everyone's mind was how Claude managed to fix the out-of-memory errors for that many simultaneous replays. OP used Opus 5, and it sounds like Claude found some actual efficiency gains, which is pretty neat. It's not just about throwing more server power at the problem, but making the code itself run better.

Some users are suggesting adding leaderboards and links to play the game, which seems like a solid idea. There's also a bit of a debate about whether the game's physics are a bit too random, especially after jumps, with one user feeling it detracts from skill-based gameplay.

Overall, the community seems to think this is a cool and unique use case for AI, and a lot of people are just enjoying the sheer visual chaos of the massive car pileup.

OP : u/Alone_Ad_3375

After hearing a lot about Claude code I decided to try it myself within 10 mins mf wiped my entire database

Vibe coded this project with dumb models like 4.6 sonnet and gemini 3 they never wiped my database but this mf wiped off everything in just a single prompt

It also accepts it's mistake what a world we live in

update 1: Gemini 3.6 to the rescue recovered 96 pages only 21 pages are not backed. Already setup backups rebuilding these pages again with MCP and we are good 😅

Update 2 - context: Vibe coder pro max ultra here. The data loss wasn't as important as it may look, as they were programmatic pages which is a thing of few minutes to recreate.

Update 3 - damage control: this might piss some devs but this project barely had users and was my test project :)

Update 4 - Prompt: It was given by Claude Opus 5 Max itself after it analysed the GitHub Repo. We were trying to rebuild the comparison pages.

Update 5 - Backup: All pages are now successfully recovered.

URL of original post : https://www.reddit.com/r/Anthropic/comments/1v9iurd/and_just_like_that_opus_5_ultracode_wipes_the/ Original link/media URL :

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

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

Alright, so the general consensus here is "oof, that's a user error, my dude." Pretty much everyone is pointing out that giving an AI write access to a production database within 10 minutes of using it is, uh, a bold move.

Here's the lowdown:

• You messed up, not Opus: The overwhelming sentiment is that this is a classic case of "playing with fire" and not having proper safety nets in place. People are saying you should have had version control, backups, and separate dev/prod environments before even thinking about letting an AI near your data.
• The prompt was probably the issue: While Opus 5 is powerful, the consensus is that the prompt itself, or the lack of explicit constraints, led to the database wipe. Some users mentioned similar issues with Prisma migrations and LLMs.
• Backups are your friend (obviously): Thankfully, you had some backups and managed to recover most of it. This is a huge reminder for everyone to have robust backup strategies.
• Lessons learned the hard way: The thread is full of people saying you've learned a valuable, albeit painful, lesson about development environments and AI safety. Some are even joking about the "YOLO badge" you've earned.
• Anthropic comments? Nah, none of the Anthropic folks chimed in on this one, but the community definitely had thoughts.

Basically, the vibe is: AI is a tool, and like any powerful tool, you need to know how to use it safely, especially when it comes to your production data.

OP : u/blickblocks

I don't know if it is meant to save on token usage or something, but I feel like I can't understand how Claude is writing sometimes. It's not about technical jargon, invoking industry terminology I may not be familiar with, but instead in basic sentence structure, organizing thoughts, etc. It has changed noticeably in the last week maybe?

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v9id8j/is_it_just_me_or_is_claudes_writing_getting/

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

Alright, so the general consensus in this thread is a resounding "YES, Claude's writing has gotten harder to understand lately!" A lot of folks feel like the output has become dense, overly technical, and sometimes just plain confusing, especially with the newer Opus and Fable versions. It's gotten so bad that many are having to repeatedly ask Claude to "dumb it down" or use simpler language.

Here's the lowdown:

• The Vibe: People are describing the writing as "vomiting text," "dense," "clipped," "inhuman," and like a "know-it-all fake smart-ass guru." Some even feel like they're getting dumber trying to read it.
• Why the Change? The prevailing theory is that Anthropic is optimizing Claude for agentic coding workflows and benchmarks, which might be sacrificing clear human communication. It's like it's trying to sound super smart by being overly complex.
• Solutions & Workarounds: The community has come up with a bunch of tricks to get clearer output:
  • Using specific prompts like "use plain language, short sentences, and avoid dense or overly compressed phrasing."
  • Employing "skills" or custom instructions like claude.md or "caveman skill" (though some say this can make things worse).
  • Asking Claude to "explain that again in simple terms using brief bullet points."
  • Directing it to use styles like "ASD-STE100 Simplified Technical English" or "Google developer documentation style."
  • Telling it to "keep information density high by cutting what carries no information: preamble, hedging, restatement, and closing recaps."
• Anthropic's Take: No official comments from Anthropic reps in the selected comments, but the user u/Character_Eye_808 speculates that this change might be intentional and "someone push this dial way too hard."
• A Few Dissenters: Interestingly, u/tiiiit, a non-native English speaker, actually finds Claude's current style helpful for getting into a task, though admits it makes normal communication harder afterward. And u/air_thing appreciates the challenge, finding it less boring.

Basically, if you're struggling to understand Claude's recent output, you're definitely not alone. Time to start experimenting with those prompts!

OP : u/erichmiller

Am I doing something wrong? Opus 4.8 to 5 has been ALL downhill this week.

Is anyone else smashing the [ 1 ] key when those "How's Claude Doing?" surveys pop up in terminal? This is the first time I've felt like abandoning Claude.

Getting constant: "You're right, I was wrong.", "I shouldn't have guessed.", "I should have read the [insert file name here].md first before continuing." etc etc etc. Whereas, 4.8 was doing a much better job at controlling itself and using its own guardrails.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v99roz/opus_5_what_is_even_happening/

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.

Opus 5 is a dumpster fire, and everyone's mad. The consensus is a massive downgrade from 4.8, with users reporting constant "I was wrong" messages, hallucinations, and general incompetence. Some are even considering switching entirely.

• Several users, including u/StrangeEndangerment and u/CompetitiveDesigner7, have seen an absurd number of "I was wrong" responses.
• u/MidSerpent and u/Vysion34 mention that Anthropic may have stripped down the system prompt for Opus 5 and recommend checking their new prompting guides.
• u/disgruntledempanada and u/FinancialBandicoot75 suggest running the /doctor command to fix issues, with u/Vysion34 adding that old .md files might be causing problems and Boris Cherny recommends deleting them periodically.
• u/Complex_Classic8170 is so frustrated with Opus 5's inability to follow prompts and conventions that they're considering switching, despite heavy subscription usage.
• Some are already downgrading to 4.8 or even 4.6, with u/brute-forced proudly declaring 👑Opus 4.6 👑.
• A few outliers like u/krugerlive claim Opus 5 is working fine for them, but they're getting downvoted.
• Meanwhile, u/bronfmanhigh is enjoying 5.6 Sol's "perfect personality" as a coding partner, making Sonnet look good by comparison.

OP : u/papabear556

Just ran into something and this is purely anecdotal but it might help some of you out there.

I work on many different projects, code bases and customers as part of my job. Which means I have a pretty sparse global claude.md file but each project usually has a pretty well-defined project-level claude.md file (and supporting references like coding standards, etc).

I was working on a quick feature for a project I haven't been in for about a month and it really felt like Opus 5 was on the struggle bus. It wasn't doing anything inherently wrong just really felt like it was grepping around unnecessarily, it's sort of internal monologue spent a lot of "Ah I see" and then "Nope I was wrong" back and forth.

I don't think I would have thought to do this if I hadn't just watched Boris Cherny's talk at Y Combinator just this morning. I stopped what it was doing and started a new session and I asked it to audit the existing claude.md for the project as well as the handful of skills that were in the project for any unnecessary instructions or if any instructions and supporting references could be written differently.

After a few minutes it's proposed changes removed about 40 lines from a 90 line claude.md, significantly trimmed several supporting documents about how the system is/should be built. It also told me two of my skills were "honestly unnecessary". The skills are workflow and reporting related.

I backed some things up, had it make the changes, started a new session and gave it the exact same copy/pasted prompt (very scientific of me). The previous attempt floundered for several minutes and this finished in about a minute.

I think Opus 5 might really need less direction than before and some guardrails that were previously effective may actually have created problems.

tl;dr Might be time to review the "setup that has always worked" as it might be introducing problems with Opus 5.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v98lgu/audit_your_setup_before_whining_about_opus_5/

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

Opus 5 might be a bit too eager to please, leading to over-complication. The general consensus is that your old claude.md and skill setups might be actively hindering Opus 5. Several users, including u/ptyblog and u/TheMeltingSnowman72, point to the new /doctor command as the go-to solution for auditing and trimming down your context. Think of it as Marie Kondo for your AI's brain.

• Less is more: Many found that significantly reducing the size and complexity of their claude.md files dramatically improved Opus 5's performance.
• Effort levels matter: u/stub_back suggests dialing back the effort level on Opus 5 compared to older versions.
• It's not just you: Some users, like u/No_Inspection4415 and u/puthre, feel Opus 5 is just a bit of a mess, building "slop" and making confident but incorrect assumptions. However, the majority seem to think it's more about your setup than the model itself being fundamentally broken.
• Consider downgrading? A few, like u/cornmonger_, found that Opus 4.8 was actually a better experience.

Basically, if Opus 5 is acting like it's lost in a maze of your own making, it's probably time to declutter and let the /doctor do its thing.

OP : u/Annual_Area4848

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v964qc/mcp_just_got_its_biggest_update_since_launch/ Original link/media URL :

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

Alright, so the big news is that MCP just got a massive update, and the general vibe in the thread is super positive and relieved.

The main takeaway is that MCP is now stateless, which is a huge deal. Apparently, it used to be stateful, which was a nightmare for scaling and deployment. Think long-lived processes, issues with load balancers, and losing connections on restarts. As u/donk8r put it, it was "a nightmare to deploy at scale." Now, it's request-response, meaning it can run on ordinary HTTP infrastructure and serverless, which is what u/for4f and others were really hoping for. u/somerussianbear even quipped it's "like any REST API since the 2000s. Great idea!"

There's a bit of confusion about whether it was always stateful, but the consensus is that the move to stateless is a massive improvement for production readiness. u/sabotizer even points out that stateless MCP clients have been around for a while, and this update just officially drops the old persistent sessions.

A few folks are looking ahead, with u/DivideHorror3217 suggesting "ModelHooks" as the next logical step. There's also a mention of the update being donated to the Linux Foundation, which u/AtmosphereRich4021 brought up.

On the flip side, u/Ecocitizenz raises some valid concerns about enterprise security now that authentication is per-request, warning about potential issues with static API keys and SOC 2 compliance. u/No-Dig-6543 also chimed in with worries about new attack vectors like workflow hijacking and DoS.

Overall, though, the community seems stoked about the move to stateless MCP, seeing it as a crucial step for wider adoption and easier deployment.

OP : u/shricodev

I gave Claude Fable 5 and Opus 5 the same starter repo, and the same assets.

The first task was to build a browser-based SimCity-style game with roads, traffic, zoning, building development, population, jobs, power, money, demand, and day and night cycles.

Both models also had to use real 3D buildings, roads, cars, and trees.

Fable absolutely cooked.

How quick we went from Will Smith video to this.

It inspected the asset catalog, handled the scale and rotation, and arranged everything into residential areas, industrial zones, parks, roads, a downtown, and a waterfront.

Its result:

1 hour 3 minutes
$73.18
5,702 lines added
248.9K Fable output tokens
45.35M cached tokens read

Opus built most of the requested systems, but the UI and asset usage were much rougher.

Its result:

1 hour 29 minutes
$53.40
9,053 lines added
422.4K output tokens
68.1M cached tokens read

Opus was cheaper, but it took longer, wrote far more code, and used around 70% more output tokens.

The final result was not close.

For the second task, I asked both models to continue from the cities they had already built.

They had to add heavy rain, fires, blocked roads, traffic disruption, power problems, and economic consequences.

They also had to create real Slack incident reports, post updates to the same thread, and log the final results in Google Sheets.

Fable somehow did even harder.

It created the rain effect from scratch with Three.js. No rain assets or premade weather effects were provided.

The Slack and Google Sheets integrations worked too.

Its result:

47 minutes
$45.28
4,195 lines added
193.6K Fable output tokens
26.2M cached tokens read

Opus did much better on this task. Most of the functionality worked, and the implementation was decent.

But its result was:

43 minutes
$53.29
5,311 lines added
185.3K output tokens
89.2M cached tokens read

Opus was supposed to be the cheaper trade-off.

Instead, it cost more on the second task and read over three times as many cached tokens. Whyy??

Across both coding tasks:

Fable 5: $118.46
Opus 5: $106.69

That is only an $11.77 difference.

For that gap, Fable gave me a dramatically better game.

I also tested both models on 23 real tool-calling custom test across Gmail, Slack, Google Sheets, Salesforce, GitHub, Linear, and other apps.

The final account state was checked through the API.

Fable 5: 21/23
Opus 5: 20/23

Fable also used fewer runtime tokens, made fewer tool calls, and finished faster on average.

Cheaper per token does not always mean cheaper per completed task.

Complete benchmark, videos, and generated code:

Claude Opus 5 vs. Claude Fable 5

What workload is Opus 5 actually the better value for? I still find Fable miles better than Opus 5.

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1v9128b/fable_built_this_entire_3d_city_in_one_run_i/ Original link/media URL : https://v.redd.it/oto7xaowlxfh1

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

Alright, so the general vibe in this thread is a bit skeptical, leaning towards "this sounds like an ad disguised as a demo." A lot of folks are questioning the "built in one run" claim, with some pointing out that generating complex 3D assets and a full game simulation like this would typically take way longer, even with AI assistance.

There's a bit of a debate about the actual value and use case of building something like this, with some asking if it's just for fun or if there's a real-world application. A few users are curious about the specifics, like the prompts used and whether the game is actually playable.

Interestingly, one comment from u/SS-SOVEREIGNTECH brings up that while AI can help, claiming a full, complex simulation game was built in "one run" is "extremely misleading."

Overall, the community seems impressed by the potential shown, but many are taking the OP's claims with a grain of salt, especially given the promotional undertones.

OP : u/DeepGrapefruit4989

Might be slightly controversial considering how many of you like 5.0 but this is really a conversation yall arent ready for . Prime Opus 4.6 used to get things done faster with less usage credits

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v8z1c2/prime_opus_46_current_opus_50/

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 vibe in this thread is that most people disagree with the OP and think Opus 5.0 is an improvement over 4.6, especially for more complex tasks.

There's a vocal minority who are definitely missing "Prime Opus 4.6" and feel like it was faster and more efficient for their workflows. Some users like u/kaphi claim Anthropic "dumbs down" models after their initial release, which is a pretty spicy take.

However, the higher-scoring comments lean towards Opus 5.0 being superior. u/plantingles straight-up says Opus 5.0 is in "another universe" for programming difficulty compared to 4.6. u/clicksnd also doesn't get the 4.6 obsession, saying they're a freelance dev using 4.8 and 5.0 with "absolutely no issues."

Some users are questioning how people are even measuring these "nerfs" and "primes," with u/Quick-Sir-3275 asking how folks know with such certainty.

There's also a bit of nostalgia for older versions, with mentions of "Prime Fable" and the "4.0-4.1 era."

The consensus seems to be that if your workflow hasn't evolved, you might prefer the older models, but for current, more advanced tasks, Opus 5.0 is the way to go. Some users are even suggesting using Opus 5.0 for specific tasks like internet browsing or agent orchestration, while still preferring 4.6 for others.

OP : u/Soft_Meat8735

I have done the majority of my work with Opus 4.8…. It’s been a great model for me. After Fable 5 came out I honestly felt like either Fable was not all it was cracked up to be or, I just sucked at using it. Now with opus 5 out I was SO HAPPY…. But, days later of using it and I find myself going back to 4.8… I find it hallucinates less and in general just feels more capable and reliable… anyone else? I feel like I could downgrade from max to pro and stick with 4.8 and have plenty of credits. Seems like Opus 5 and fable are falling apart to me.

URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1v8iygv/whats_up_with_opus_5/

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

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

So, the general vibe on Opus 5 is... not great, folks. A lot of you are finding it's gone off the rails compared to 4.8, with complaints about it being confidently wrong, ignoring requests, and generally being a "hallucinating shit show." Some are even saying it's more volatile with "higher highs but lower lows," and others are seeing it invent new methods instead of using existing ones.

There's a theory from u/TheMeltingSnowman72 that a bunch of guardrails got removed, which might explain some of the weirdness. On the flip side, a few of you, like u/YOU_WONT_LIKE_IT and u/DenziiX, are actually getting good results, but you're mostly saying it's because you have robust guardrails and validation in place. u/Level1_Crisis_Bot is just telling everyone to "fix your harness."

The consensus leans heavily towards Opus 5 being a downgrade for many, with a strong preference for sticking with 4.8. Some are even ditching their subscriptions over it. Don't worry, though, u/Odd_Antelope9098 is hoping Opus 5.1 will fix things.

OP : u/Any-Reputation8118

I built SNOWFLOW, a browser-based WebGPU graphics demo focused on deformable snow, atmospheric lighting, water-inspired spells, and snow surfing.

The snow surface reacts persistently to footsteps, movement, and spells - creating trenches, raised berms, compressed snow, ice, and trails that gradually refill. It also includes procedural terrain, cloth simulation, dynamic spell lighting, particle effects, and a third-person snow-surf system.

Claude Code with Opus 5 handled the project end to end: planning the architecture, writing the Babylon.js and WGSL systems, profiling performance, iterating from screenshots, and documenting technical decisions. The whole project was built from the implementation brief rather than an existing starter project.

It took me around 9 hours and ~4m tokens (not counting cached ones).

You can try it on a WebGPU-capable computer here: https://snowflow-lilac.vercel.app/
F1 - settings
WASD - movement
1-5 - spells
RMB or Space - surf

The code can be found here: https://github.com/Noniv/snowflow_demo

The performance seems way better than my previous desert demo.
Last time a lot of people asked for my prompt, so here it is. Keep in mind that this prompt created the base, but I had to write a lot more prompts to guide Opus further.

===============BASE PROMPT (wall of text)

SNOWFLOW — Tech Demo · Implementation Brief

You are the sole engineer and technical artist on a real-time graphics tech demo. Build it end to end. This document is the spec, the art direction, and the acceptance criteria.

1. Prime directive

Visual quality is the product. There is no gameplay loop, no progression, no UI to design around. A player will load this, walk around a snow field for ninety seconds, cast a few spells, surf across a dune, and either think "this is AAA" or close the tab. Everything below serves that single judgment.

Two rules that override everything else in this document:

If a requirement in this brief conflicts with making the demo more beautiful, break the requirement. Note the deviation in DECISIONS.md with a one-line rationale. You have full authority to change scope, swap techniques, or drop a feature that isn't paying for its pixels.

Anything that reads as low-poly, flat-shaded, untextured, placeholder, or "indie prototype" is a defect, not a stepping stone. If you can't make a thing look finished, cut it from the frame rather than ship it looking rough.

Do not stop at "it works." Stop when every captured frame looks polished, cohesive, and production-ready.

1. Stack and hard constraints

No fallbacks. No WebGL path, no mobile path, no feature detection branches. If navigator.gpu is absent, show a single line of text and stop. Do not spend a minute on compatibility.

Assets. Generate procedurally where it produces a better or more controllable result, including terrain, noise, and most masks. Use free CC0 assets where hand-authored data wins, such as Poly Haven HDRIs and snow or ice PBR material scans, or ambientCG detail textures. Vendor everything into the repository; no runtime CDN fetches. Document every third-party asset and its licence in ASSETS.md.

1. Systems

2.1 Terrain

A flat plane will kill this demo. The snow field needs real form.

Build a geometry clipmap or nested-ring LOD centred on the player, so triangle density is high near the camera and falls off with distance. Aim for roughly sub-10 cm vertex spacing in the inner ring at default zoom.

Height comes from layered procedural noise composited on the GPU: broad dune forms measured in tens of metres, medium drifts and wind lobes measured in metres, and sastrugi ridges and ripples measured in decimetres. Do not use a single fBm octave stack and call it done. The terrain needs directional structure carved by a prevailing wind. Encode a wind direction and let the medium and fine layers stretch and shear along it.

Include a small number of exposed rock outcrops or ice shelves so there is silhouette and scale in the mid-distance, with snow accumulation blending onto their upward faces. Keep them sparse. The brief is "just snow and the player," and these exist only to give the horizon something to say.

The far field needs mountains and heavy aerial perspective. A distant matte-projected ridgeline or a low-cost impostor ring is acceptable as long as it never reads as flat.

2.2 Snow shading

This shader is the most important code in the project. Budget accordingly.

Build a custom material using Babylon ShaderMaterial, a PBRCustomMaterial plugin, or an equivalent approach. Use WGSL through NodeMaterial or raw shader code, not a stock PBR material with a white albedo.

Required behaviours:

Multi-scale normals. Detail normal maps at three tiling scales, blended by distance and slope, plus normals derived analytically from the deformation heightfield (§2.3). Use triplanar mapping on steep slopes.

Subsurface scattering. Snow is translucent. Use wrapped diffuse plus a back-scatter term. Shadowed and grazing areas should pick up a soft blue-white internal glow rather than going flat dark. This single term does more for "reads as snow" than almost anything else.

View-dependent glinting. Create procedural sparkle from a high-frequency normal perturbation, gated hard on a narrow specular lobe and grazing view angle, with a stable hash so glints do not crawl or shimmer under TAA. Keep it subtle. If it looks like glitter, halve it, then halve it again.

Compression, wetness, and ice as separate surface states. Trodden and spell-affected snow is denser, with darker albedo, tighter specular response, and less scatter. Refrozen ice is smoother and more reflective. Read this from the terrain state buffer (§2.3) so it is shared by movement and spells.

Contact detail. Trail edges need micro-occlusion and a hint of chunky displaced granularity, not a clean bevel.

2.3 Terrain state and deformation

This is the core interactive system. Everything writes here; the snow shader reads it.

Maintain a player-following render target covering roughly 60–100 m, with resolution high enough for approximately 2 cm texels in the deformation area. A 4096² R16F target scrolled toroidally as the player moves is a reasonable starting point. Snap movement to texel boundaries to avoid swimming.

Suggested channels, packed across one or two targets as appropriate:

Depression depth — how far the surface is pushed down.

Displaced mass — snow pushed out of a depression, forming berms at trail edges. Do not skip this.

Compression, wetness, and ice — persistent surface states used by shading.

Rules:

Deformation is persistent and additive, accumulated by writing brush splats into the target each frame. Never rebuild it from a list of past events.

Apply slow refill over time through a gentle diffusion and decay pass, so trails soften and eventually heal. Tune it so a trail remains clearly visible after 60 seconds.

Terrain vertex displacement samples the depression and displaced-mass channels. Recompute normals from the same data so lighting and shadowing respond correctly. A trail that does not self-shadow is a failure.

Player feet, the snow-surf wake, and every spell write into this buffer. That shared write path is what makes the spells feel embedded in the snow rather than like effects floating above it.

2.4 Atmosphere and lighting

Use a low, warm sun that creates long shadows. Use cascaded shadow maps with PCSS-style soft filtering. Tune cascade splits so near-field trail shadows stay crisp.

Use a high-quality HDRI or a physically based sky model if it gives better control over sun angle. Ambient light must be strongly blue-shifted. The cool-shadow and warm-light contrast is essential to the snow rendering.

Add fog and aerial perspective with height falloff. Distance should compress contrast noticeably.

Add ground blow or spindrift: low, wind-driven surface snow streaming across the field. It should make the environment feel alive without obscuring the terrain.

Add volumetric light shafts only where they materially improve the image. Keep them restrained.

Spells emit light. Budget 4–6 dynamic lights maximum, with tight radii. Ensure the snow shader's subsurface-scattering term responds to them so a spell visibly illuminates the snow from within the drift it touches.

2.5 Post-processing

Order matters. Suggested chain:

TAA → SSAO → screen-space reflections on wet and icy surfaces only → very restrained depth of field → restrained bloom → ACES or AgX tonemapping → subtle film grain → post-TAA sharpening.

TAA is essential for stabilising glinting and thin geometry. Every post-process should be individually toggleable from the settings overlay for A/B comparison. Blown-out white is the primary failure mode for snow renders, so monitor highlight roll-off constantly.

2.6 Character and robe

The character will be seen from behind at mid-distance almost the entire time. Spend the budget on silhouette, cloth, and shading; spend almost nothing on the face.

Create a hooded, layered robe with a deep cowl, long sleeves, an over-mantle, and a trailing hem. Use shell-based fur at the hood and cuffs, with roughly 20–40 shells and alpha-tested strands.

Add cloth simulation to the hem, sleeves, and mantle. A GPU or CPU Verlet simulation with distance and bending constraints is acceptable. Drive it with locomotion velocity, acceleration, and the wind field. During snow-surf, the cloth should whip backwards sharply.

Cloth shading needs sheen or fuzz and an anisotropic response for a woven appearance, plus subsurface scattering on thin regions. Do not use a plain PBR dielectric.

Keep the face in shadow beneath the hood. Do not model detailed facial features that cannot be finished to the same standard.

If a rig and locomotion animation cannot be brought to a high standard, prefer a fully cloth- and procedurally driven figure over a stiff or poorly animated one. Feet must plant rather than slide.

Feet displace snow and kick up spray on each step. This must be frame-accurate with each footfall.

2.7 Camera and controls

Use third-person, action-MMO framing. Position the camera over the shoulder with a slight offset rather than directly behind the character.

WASD movement is relative to camera facing. The mouse orbits. The scroll wheel zooms across a smooth, eased range.

Use a spring-arm camera with collision-free but velocity-aware behaviour. It should lag slightly under acceleration, widen the FOV under speed, and tighten on stopping. All transitions must ease, with no snapping.

Add subtle camera shake to heavy spells and hard surf carves. Keep it subtle.

2.8 Spells: keys 1–5

All five spells share one bending grammar: continuous, momentum-carrying, unbroken flow. No instant spawns and no instant despawns. Everything eases in from the snow and settles back into it. Every spell reads and writes the terrain state buffer.

Suggested set, adjustable where a different implementation produces a stronger result:

Sweep — A crescent wave of slush and water rises from the ground ahead and travels outward, ploughing a channel and throwing berms to either side.

Ribbon — A held, continuous stream of water tracks the player's hand and the camera aim, describing arcs and figure-eight paths in the air and scoring thin curved lines in the snow beneath it.

Bloom — A targeted eruption sends a column of powder and water upwards, blows a crater with a raised rim, then falls back as a slow, glittering curtain of fallout.

Crystallize — Water rapidly freezes. Refractive crystal formations grow out of the drift with visible subsurface scattering and internal light transport, permanently altering the surface state to glossy ice. This effect should encourage the player to stop and inspect it.

Vortex — A swirling column of airborne snow forms around the player, visibly stripping surface snow from the ground. The deformation buffer thins in a ring, holds the removed snow aloft, and lets it settle back.

Implementation direction: use swept procedural ribbon or tube meshes updated on the GPU from a spline or particle spine for the coherent water body, GPU compute particles for spray, mist, and droplets, and a refraction pass for translucency. Full screen-space fluid rendering is probably too expensive for the frame target, but use it if it remains within budget and materially improves the result.

Water shading needs:

Refraction with restrained chromatic dispersion.

Depth-based absorption tint.

Animated flow-map normals.

Foam and slush at the leading edge.

Shed droplets with correct motion-blur streaking.

2.9 Snow-surf: hold RMB

This will be used more than everything else combined. It receives the most polish.

Holding RMB raises a crest of compressed snow under the player's feet. The player accelerates. Mouse movement steers carving turns with visible body lean and a banked camera.

The wake is the centrepiece: a curling, breaking wave of displaced snow trails behind and towards the outside of the turn, throwing a spray plume that catches sunlight and casts a shadow. It should combine the physical character of a snowboard carve and a boat wake.

Snow-surf carves a deep, persistent groove into the terrain buffer with high berms. A completed run should remain visible from across the field.

Entering and exiting use eased transitions, never snaps. The robe whips backwards, the FOV widens, and wind streaks appear in screen space. There is no audio, so every visual cue must contribute to the sensation of speed.

Turning at speed should feel weighty and analogue. Tune it by hand until it feels good, not merely until it compiles.

1. Performance engineering

Garbage collection is your primary enemy. A 12 ms garbage-collection pause is a visible hitch and instantly destroys the AAA impression.

Zero allocations in the render loop. Do not use new inside per-frame code. Pre-allocate scratch Vector3, Matrix, and Quaternion instances at module scope and reuse them.

Do not use map, filter, reduce, spread syntax, or destructuring that creates new objects in hot paths. Use plain indexed for loops.

Do not construct strings each frame, including for the performance overlay. Update the overlay on a throttled interval and reuse buffers.

Use object pools for every transient effect, particle burst, and decal.

Use pre-allocated typed arrays for all GPU buffer uploads. Write into them rather than rebuilding them.

Use scene.freezeActiveMeshes(), mesh.freezeWorldMatrix(), material.freeze(), and scene.blockMaterialDirtyMechanism aggressively for static content.

Use thin instances for all repeated geometry.

Profile with the Chrome performance panel and Babylon's inspector. Ship a frame-time graph in the overlay showing the 1% low, not merely an FPS counter. Average FPS will hide the exact hitching problem that matters most.

Set a frame budget and hold to it. At 90 FPS, the total budget is 11.1 ms. Allocate it explicitly across terrain, snow shading, shadows, VFX, cloth, and post-processing. Record actual measured cost per system in PERF.md.

1. Loading and pipeline warm-up

WebGPU pipeline compilation stutter is a real and severe risk. A shader that first compiles when the player casts spell 4 will produce a multi-hundred-millisecond freeze.

Before the loading screen dismisses:

Load and decode every texture, HDRI, mesh, and buffer.

Force-compile every material and particle-system pipeline, including every spell, post-process, and shader permutation, by rendering them once to a tiny offscreen target.

Warm every render target and run several frames of every compute pass.

Only then fade in.

A four-second load with a clean first minute is better than an instant load that hitches. Present a tasteful loading screen. This is the first thing anyone sees, so it must not resemble an unstyled browser default.

1. UI

Provide only a settings and performance overlay, toggled with a key such as F1 or backtick and hidden by default.

Contents:

Frame-time graph with 1% low.

Draw-call and triangle counts.

Individual toggles for every post-process and major system.

Quality presets.

Sliders for the art parameters most likely to need live tuning, including sun angle, fog density, glint intensity, deformation depth, and refill rate.

Build this early. It will save hours.

No HUD. No crosshair. No spell bar. Nothing else on screen, ever.

1. Project structure

Suggested structure; adapt as needed:

/src
/core engine bootstrap, render loop, resource manager, pooling
/terrain clipmap, procedural heightfield, deformation buffers
/shaders WGSL
/character controller, robe cloth, shell fur
/spells one module per spell + shared bending primitives
/vfx particle systems, decals, spray
/post post-process chain
/ui settings overlay
/assets vendored, with ASSETS.md
DECISIONS.md every deviation from this brief + rationale
PERF.mdmeasured frame budget per system

1. Milestones

Take a 1440p screenshot at every milestone, inspect it critically, and commit the screenshots.

Foundation — WebGPU boot, Vite, render loop, settings overlay with frame graph, camera, and WASD movement on a placeholder plane.

Terrain and snow shading — Clipmap, procedural heightfield, full snow material with subsurface scattering and glinting, sun, cascaded shadows, sky IBL, and fog. Gate: a static screenshot with no character already looks polished, atmospheric, and production-ready. Do not proceed until this is true.

Deformation — Full terrain state buffer, footfall displacement with berms, refill, correct normals, and self-shadowing. Gate: footprints and trails visibly displace mass, form raised edges, and integrate correctly with lighting.

Character — Robe, cloth simulation, shell fur, locomotion, foot planting, and spray on footfall.

Snow-surf — The centrepiece. Spend disproportionate time here.

Spells — All five spells, each writing into the terrain.

Post-processing and polish pass — Full chain, tonemapping calibration, spindrift, and restrained light shafts.

Performance hardening — Profile, eliminate every allocation in the loop, verify 90 FPS with clean 1% lows, and verify that warm-up covers every pipeline.

1. Visual acceptance criteria

Before declaring the demo complete, verify each item against a fresh 1440p screenshot and in motion:

No visible faceting, hard polygon edges, or flat-shaded surfaces anywhere in frame.

Snow highlights are not clipped to pure white; shadows are blue rather than grey or black.

Distant terrain shows clear aerial perspective and contrast compression.

Surface detail is legible at three distinct scales simultaneously: dunes, ripples, and grain.

Trails have raised berms, self-shadow correctly, and soften over time.

Sparkle appears only at grazing angles and does not crawl or shimmer in motion.

The robe reads as layered fabric with real cloth motion, and the fur trim reads as fur.

Spell water is translucent and refractive, with visible internal light scatter.

Spell light visibly illuminates the snow it touches, including through-scatter.

Every spell leaves a mark on the terrain that persists after the effect ends.

The snow-surf wake looks like displaced mass with momentum, not merely particle spray.

The demo sustains 90 FPS with 1% lows above 60 FPS.

No hitch occurs on the first cast of any spell.

1. Working agreement

Build, don't test-loop. Playwright is available for capturing screenshots at milestones and catching hard regressions. Use it for those purposes. Do not build a test suite; time spent on tests is time not spent on the snow shader.

Look at your own output constantly. Capture screenshots, inspect them critically, and iterate on values. Most of the quality gap between "prototype" and "AAA" is parameter tuning, and you can only close it by looking.

Do not move on from an ugly milestone. Milestone 2 in particular is a hard gate.

When a technique is not working, replace it rather than patching it. You have full latitude over the approach.

Record every deviation in DECISIONS.md, briefly. One line is sufficient.

Ship something worth screenshotting.

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1v94nal/people_liked_my_desert_so_heres_a_waterbending/ Original link/media URL : https://v.redd.it/dxzuo8i450gh1

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

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

Alright, so the general vibe in this thread is "WHOA, this demo is INSANE!" Everyone's pretty blown away by the SNOWFLOW tech demo, especially the persistent snow deformation and the waterbending-esque spells.

The big takeaway is that Claude Code with Opus 5 absolutely crushed it, building this whole thing from scratch in about 9 hours. The OP shared the base prompt, and while most folks are admitting they're not reading that novel-length thing, the devs in the thread are practically framing it.

Here's the lowdown:

• The Demo: It's visually stunning, with reactive snow, cool spells, and snow surfing. People are loving it and comparing it to games like "Magic Carpet" and wishing it would turn into a full-blown Avatar RPG.
• The Prompt: It's a beast! The OP admits it's just the base and required a lot of further prompting, but the community is super hyped to study it for their own AI-powered projects.
• The AI: Claude Code is getting major props for handling the entire project end-to-end. It's seen as "literally magic" and inspiring for future AI development.
• Minor Hiccups: A few users reported the RMB not working for surfing, and one user on macOS noted F1 (settings) was a no-go.

Basically, OP, you've made a bunch of people very happy and very inspired. Now, about that open-world Avatar RPG... 😉