r/ClaudeCoding • • 22d ago

Made Opus the principal dev and DeepSeek its team. 63% fewer Opus tokens

861 Upvotes

UPDATE: 1.2.7 is out (Command Code support + update notices). Updates now live at r/CheapAgent.

I have been working with Claude for a really long time (Aug 2024 , the copy pasting era lol) and alwaya have loved Opus and it's ability to think about problem and then provide options , overall the thinking and planning ability of Opus/Fable is something that no other model can tops

But From the start of Agentic Era I kept hitting my Opus limit, and most of it was going on typing: reading files, writing boilerplate, re-running tests , something that very cheap model can do very well as well but never got time to make this Framework/workflow properly

So I built Cheap Agent, an MCP server and plugin for Claude Code.

What it does

  • Opus plans and writes a short task.

  • A cheap model (DeepSeek V4.1 Flash via OpenRouter, about half a cent a task) writes the code in a git worktree.

  • It has to write a test that fails before the fix and passes after. Cheap Agent runs that test itself.

  • Only passing work lands, uncommitted, so you review the diff as usual.

  • If the cheap model gets stuck, a Sonnet helper finishes the step instead of Opus.

Numbers (SWE-bench Verified, Opus 5.5, same prompts with and without it):

  • Adding a feature: 154k → 57k Opus tokens, 63% less

  • 7 everyday bug fixes: 59% less, 7/7 solved by both

  • 9 of the hardest bugs: 55% less, but 6/9 solved vs 7/9 for Opus alone

It doesn’t help on tiny jobs, because Opus is already quick there.

Why I made it
I’ve met a lot of students who want Opus and can’t afford $100 a month. The aim is to stretch the plan you already pay for.

How It Was build :
in Claude Code. Opus designed it, then I used Cheap Agent to build Cheap Agent (sounds funny lol) . The Windows port was 30 delegated jobs for $0.29 of DeepSeek.

cheap models are fine at typing as long as the task is tight, but never trust one that says "tests pass", so Cheap Agent runs the tests itself. And the savings depend on your repo having a test command: my first demo take only saved 20% because I forgot a package.json, so Opus ended up running the tests itself.

Free Forever: it’s open source (MIT) and free. The cheap model runs on your own API key, and a few dollars lasts hundreds of tasks. Your code goes to the provider you pick, and only after you allow it per project.

npx cheap-agent · github.com/muaaz9329/cheap-ag

would really love your guys feedback and how can I improve this , better yet could have contributions from Awesome community here on what people might need

Hope everyone have great weekend !


r/ClaudeCoding • • Oct 15 '26

I got tired of guessing how much of my 5-hour window was left, so Claude Code and I built a Dynamic Island for Windows

279 Upvotes

What it does

Developer Island is a small native capsule at the top of the Windows screen. In the compact state it reads like "Claude 1.12M · 72%": today's tokens and how much of the 5-hour window is used. Click it and you get:

- the 5-hour and weekly plan usage with reset times, exactly as Claude Code reports them (never estimated from token counts)

- today's tokens split into input, cache write, output and cache read, plus sessions and model

- a 26-week usage graph with a tooltip per day and an estimated API-price equivalent

- Codex usage too, if you use both

Since it was sitting there anyway, it also got music controls, a focus timer, the next meeting, system load, and an "Awake" mode that keeps the laptop running with the lid closed so long agent runs don't die.

How the plan usage gets there

It isn't in the transcripts in ~/.claude/projects. Only the status line command receives it. So Developer Island registers as the status line command, keeps only the percentages and reset times, and prints nothing. If you already have a status line, it leaves yours alone. One catch: the VS Code extension doesn't run status lines, so plan usage only arrives from terminal sessions. Token usage works either way.

How Claude helped

Claude Code wrote nearly all of the code. My part was the spec, the design direction, using the island every day and deciding what's wrong.

- I started with a detailed brief: the states, the modules, privacy rules ("never store prompts or code, no fake data") and a priority order for the design. Claude built the first version from that in about three days.

- After that I used it all day and sent long numbered lists of everything that bugged me, 20 to 30 points per round, each fix with a regression test. The one line that saved me the most trouble: "Additive changes by default, destructive changes only when I explicitly ask."

- All logic sits in a project without UI, covered by 380+ tests, so Claude could prove a fix with dotnet test instead of me clicking through the app.

- I didn't want an agent moving my mouse or screenshotting my screen, so the app got a snapshot mode that renders every state offscreen to PNGs with demo data. Claude checks its own UI changes that way, and every screenshot in the README comes from it.

Free to try

It's free and open source (MIT), no account, no telemetry. Only usage metadata is read (tokens, model, timestamps), never prompt or code content. Windows 10/11 x64, and there's a demo mode with made-up data if you just want to look around.

https://github.com/maximilian467/Developer-Island

What would you want it to show next?


r/ClaudeCoding • • 20d ago

Compacting at 400K instead of ~967K cut my Claude Code cost per request by 43%

153 Upvotes

This isn't a universal recipe. It's how I tuned Claude Code for my own work, and different settings may suit you better.

The window

Every request sends the whole context to the model. On 1M-window models Claude Code only compacts it near 967K, so the tail of a long session is the most expensive part. For me, 68% of main-thread cost went to requests with more than 400K in context.

I set "autoCompactWindow": 400000 and compared the month before with the week after. That's the main thread only, about 25K requests before and 16K after:

  • Context per request: 415K → 220K

  • Cost per request: −43% (in tokens weighted by API rates, no per-model prices)

That's one person's before/after, not a controlled experiment.

The cost of summaries

A smaller window means more compactions. I went from 16 summaries a month to 75 in a week: 95 minutes of waiting, 76 seconds each. After a summary, the model often re-reads files it had already seen.

Slide instead of summarize

Most of the context is old tool output: file reads, test runs, diffs. So at compaction, a hook keeps the conversation word for word and replaces old outputs with a short line: "you saw this, read it again if you need it." There's no model call, so a compaction takes milliseconds. The summary is still the fallback, for /compact and for the rare case where sliding can't free enough.

The benchmark: Claude Code builds a TypeScript project against fixed tests, on Haiku 5.5 with a 100K window. Medians, sliding against Claude Code's summary:

TaskCostTime
A day of work, 307 tests−19%−33%
An eval harness, 238 tests−35%−28%
A short task with one compaction+6%−17%

Every test passed in both modes.

Will it work for you?

It depends on how you work:

  • If your sessions rarely reach 400K, the window changes nothing.

  • If you stay in one session for hours, 200–300K might pay off.

  • On short tasks, sliding saves time but not money.

  • Model, effort and the kind of work all move the number a lot.

That's why I built a plugin that works out your number first. It's called tokendoctor (free, local, MIT). It replays your sessions at windows from 200K to 600K, shows what each would have saved, and only then offers to change anything. Sliding is off by default, and /tokendoctor undo reverts any change.

https://github.com/rsaryev/tokendoctor

Note: I re-run the benchmarks and update the numbers as more data comes in, so figures in my earlier posts may differ from these. The repo always has the latest, with every run behind them.


r/ClaudeCoding • • 11d ago

r/ClaudeAI [TLDR] Instead of collecting dust, Claude makes your old Kindle useful again [via r/ClaudeAI]

122 Upvotes

OP : u/abdenourgnx1

Hi, probably not the first one to do this but i wanted to share my experience doing it.

I had to jailbreak my kindle manually first for claude (with new guard rails🔒) to be able to edit anything on it. My kindle is 7th generation and the jailbreak was straight forward following this guide.

After the jailbreak, claude takes over to design and build whatever application you want. For me i just gave it a concept image of what i want and how i wanted it to behave and it did the rest. Make sure to have KUAL (application launcher in kindle) or whatever equivalent thing for your model.

Data is fetched using wifi connection, but i had to tweak the loop for better battery saving. Updates every hour, screen sleeps between updates, wifi turn on only when fetching, no fetches or updates during the night. This got me 10% drain per week.

Update:

Here is the git repo for people to not start fresh and burn tokens (claude.md included)

https://github.com/abdenourgnx/re-kindle


URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1xsk5k9/instead_of_collecting_dust_claude_makes_your_old/

Original link/media URL : https://www.reddit.com/gallery/1xsk5k9


r/ClaudeCoding • • 14d ago

Repositories To Master Claude Code

104 Upvotes

Five repos that cover Claude Code from internals to day-to-day workflow:

  • learn-claude-code: 17 lessons that build a mini Claude Code from scratch. Best way to understand how agent loops, tools, hooks and subagents fit together

  • claude-code-best-practice: practical reference for skills, hooks, MCP, memory and settings

  • awesome-claude-code: curated community skills, agents and tooling

  • gstack: an opinionated setup that turns slash commands into a review/QA/ship pipeline

  • ECC: a large library of agents, skills and hooks

Share your own go-to repos, skills or workflows below


r/ClaudeCoding • • 24d ago

Anthropic's new IPO strategy? Charge $200, ban the customer, deny the refund. Infinite money glitch?

Thumbnail
gallery
96 Upvotes

I paid $200 for Claude Max 20x on October 21.
Eight days later, I’m sitting here with a banned account, no explanation of what I actually did wrong, and Anthropic refusing to give me my money back.
Seriously, what the hell?
Here’s what happened:
October 21: Paid $200 for Claude Max 20x.
My account was subsequently suspended for an alleged violation of their Usage Policy.
I submitted an appeal asking for my account to be reinstated.
Anthropic’s Trust & Safety team rejected it with a generic response saying I violated their policy. No specific violation, no examples, no explanation.
I contacted billing support requesting a refund for the subscription I can no longer use.
Their AI support agent refused, citing a violation of their Consumer Terms of Service, and confirmed my subscription was cancelled.
So let me get this straight.
You can charge someone $200 for a month of service, revoke their access, refuse to tell them exactly what they did wrong, and then keep the entire payment?
I understand that companies need to enforce their policies. That’s not my issue.
My issue is that I paid for a service, lost access to it, wasn’t given a meaningful explanation, and now I’m being denied even a prorated refund for the unused time.
I wasn’t asking for special treatment. I wasn’t even demanding that they restore my account at this point.
I just wanted my money back for a subscription I can no longer use.
And the cherry on top? The refund rejection came from an AI support bot. I specifically requested escalation to a human billing representative, but the conversation was simply closed.
Apparently, $200 buys you eight days, a generic policy violation notice, and a chatbot telling you to go away.
Has anyone else dealt with this? Did you manage to get a refund through Anthropic, or did you have to file a chargeback with your bank?
Screenshots of the appeal rejection and billing support conversation attached.


r/ClaudeCoding • • Oct 12 '26

Vibecoded a futuristic racer demo like many, but I stuck with it for 6 months now

87 Upvotes

Steam page: https://store.steampowered.com/app/5310180/Formula_Minus_One/
Open beta: https://fm1.app

----

Some of you might remember my post about the 32/64bit-style racing prototype I had built in four months. Yes, it's a genre you see a lot around here, because it's easy to get started with (until the next dopamine-driven prototype).

But I stuck with it.

And the improvement over the past two months has been tremendous, and you'll see that if you compare the two videos. Since the last post, I listened to your feedback and:

* Threw every level in the bin and rebuilt them from scratch, then added new ones that are far bigger and more detailed. It felt like jumping a console generation, and it still runs on mobile.

* Wrote a design and style guide for the game (semi-low poly characters and duotone as design signature), and redesigned the characters and menus to match it.

* Kept pushing to make it my own thing rather than yet another clone-slop: adventure vibes, interaction with the environments, kinetic combat with combos…

* Improved the handling and the readability.

And above all, and I think it shows in the trailer: I had a blast making it. If it had just been work, I wouldn't have gotten this far.

It's called Formula Minus One, and it launches on Steam first, in February. I'll keep improving it and adding content after that.

Half a year ago this was a prototype to experiment with, like so many others. Then I committed to making the best game I possibly could. Now I can finally see light at the end of the tunnel: yes, you can start a prototype, and yes, you can finish it.

There's still a lot of work ahead, so any feedback you can give me is very welcome.

 Here’s how I made it:

* Code and tooling: frontier LLMs from OpenAI and Anthropic, with open-source models filling in the gaps and limiting the budget.

* Characters, ships and environments: pencil sketch > GPT Gen 2 > Tripo to turn it into a 3D model > Blender to clean up the imperfections.

* Sound: stock sound effects from Magnific. Music sketched out on a MIDI keyboard, final music generated with Suno.

* Stack: Three.js, WebGPU, TypeScript, Rapier for physics. Nothing else, no Godot, no Unity…

I'm having a great time, but it's also hard work if you want to pay attention to every detail, and it's a very lonely experience. If the game sells well enough, I'd love to start paying artists and composers to replace the current assets and create new ones, and free up more time for what I really enjoy: directing and overall design.

In fact, if you're an artist or composer and think you're a good fit for the game's tone, leave a comment or send me a DM so I can consider you!

----

Steam page: https://store.steampowered.com/app/5310180/Formula_Minus_One/
Open beta: https://fm1.app


r/ClaudeCoding • • 18d ago

Does delegating to cheaper models actually save money? I tested it across three codebases.

73 Upvotes

Disclaimer: This is a small experiment, not a definitive benchmark. Most tasks were run twice, while everyday tasks were run once. I'd have liked to run more repetitions, but subscription usage limits make that difficult. The cost differences are interesting, but small quality differences should be treated as observations rather than definitive rankings.

I wanted to see whether Claude Opus decides to use subagents effectively, and whether forcing it to delegate, preventing delegation, or leaving it to decide for itself changes the results.

I built a model-router skill that lets Opus delegate work to Haiku or Sonnet, then compared four setups:

Forced Opus: told not to use subagents.

Spontaneous Opus: free to delegate, but it never did.

Skill-routed: Opus uses my skill to choose when to delegate and which model to use.

Forced Haiku: all subagents use Haiku.

I tested these on three codebases: my own project (~10k lines), rich (~22k lines) and beets (~52k lines).

Results

1. Small codebase (~10k lines)

Every setup passed all 10 everyday tasks.

On five reading-heavy tasks, Forced Opus was the most accurate per run. Skill-routed cost 30% more, while Forced Haiku cost the same but had the weakest docs check (4 of 9 issues).

Interestingly, skill-routed found all 9 known documentation issues across its two runs, compared with 8 for Forced Opus. However, its individual runs were less accurate.

2. Medium codebase (~22k lines)

This was where Haiku surprised me.

On the documentation check, Forced Haiku found 11 of 12 known issues across two runs, matching or slightly exceeding Opus, while costing 41% less.

Skill-routed actually cost 11% more than Forced Opus. Spontaneous Opus was 14% cheaper.

3. Large codebase (~52k lines)

This produced the biggest cost differences.

Across all three tasks, average cost reductions compared with Forced Opus were:

Spontaneous Opus: 32% cheaper

Skill-routed: 38% cheaper

Forced Haiku: 75% cheaper

Quality depended on the task.

On the reference documentation check, both delegated setups found more issues than either Opus-only setup.

On the larger 80-page plugin documentation check, Forced Opus was clearly the most accurate, finding 45 of 51 known issues across two runs. Forced Haiku found 34, but cost 84% less.

What I think is happening

Small projects: Opus can often write small scripts to inspect the code instead of reading everything manually. Delegation adds briefing, duplicated reading and verification costs.

Medium projects: reading becomes a larger part of the workload. Haiku is extremely cheap at reading cached context, making it surprisingly effective for straightforward checks. Sonnet offered little cost advantage in this experiment.

Large projects: a single long session becomes expensive as the growing context is repeatedly read. Delegation splits the work into smaller contexts, reducing costs and allowing parallel execution. However, the largest documentation check showed that this can come with a quality trade-off.

The obvious way to estimate savings is misleading. Re-pricing the delegated tokens at Opus rates suggested 34-85% savings. Head to head, results ranged from 30% more expensive to 75% cheaper.

One particularly interesting observation: Opus never delegated spontaneously in any of my runs, even on the largest codebase. That's specific to these tasks and this setup, not proof that Opus never delegates.

Final thoughts

I wouldn't claim there's one best approach.

Small codebase: Opus alone was generally the better choice.

Medium codebase: Haiku-only delegation was surprisingly competitive.

Large codebase: delegation offered substantial savings, but accuracy depended on the task.

The router skill mostly selected Sonnet, which often wasn't economical enough to justify the extra coordination.

Full methodology, per-task results, charts and the transcript checker:

https://github.com/Manuele-T/claude-model-router/tree/v1.0

I'd be interested to hear whether others have seen similar behavior, particularly Opus choosing not to delegate even when working on larger codebases.


r/ClaudeCoding • • 6d ago

r/ClaudeAI [TLDR] Anthropic has opened up Claude Mythos access to the public. [via r/ClaudeAI]

69 Upvotes

OP : u/MonkeyBoyPoop

I just noticed pretty much anyone can get access now through KYC.

Enrolling used to require CVE or business verification but now individual researchers can apply with just their ID.

To those who want to apply:

  1. Have an existing Claude subscription or an API account

  2. Go to http://portal.anthropic.com and pick "Cyber Verification Program"

  3. Choose individual and apply for defense access

  4. Verify with a government photo ID and a live selfie if asked.

  5. Describe your security work, accept the terms, and submit.

They literally give you the exact prompt write down on what they expect you to use it for and grant you access within the hour.

You won't be able to use Mythos offensively, but it's still a neat option to have it in your back pocket should you ever want to get the most out of your weekly limit talking to it. 😅


URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1xwguid/anthropic_has_opened_up_claude_mythos_access_to/

Original link/media URL : https://www.reddit.com/gallery/1xwguid


r/ClaudeCoding • • 18d ago

I mapped 6 weeks of my Claude Code tokens on one page. 75% of the spend was Claude re-reading the conversation

Post image
58 Upvotes

I added a dashboard to tokendoctor, my free local plugin: one page with every Claude Code session on my machine. 334 sessions, 939 subagent runs, Sep 22 to Nov 4.

What it showed on my setup

  • 75% of the spend was cache reads: the whole conversation sent again on every request. Everything Claude wrote, thinking included, was 10%.

  • 81% of main-thread spend went out with more than 200K tokens already in context.

  • 44% went to subagents.

  • 87% was Opus.

So the lever is context size. Compacting earlier is what I wrote about last time: compacting at 400K instead of 967K cut my cost per request by 43%.

How it works

/tokendoctor:dashboard reads only the usage numbers in ~/.claude/projects, never message text, and writes one HTML file. No network, no account. Filter by period, main thread or subagents, and project; break it down by day, model, effort, subagent type, context size and hour.

Then act on it

  • /tokendoctor:sessions replays your sessions at smaller windows and says what each would have saved

  • /tokendoctor:audit checks your settings against the docs and reads your memory and CLAUDE.md for what costs you more

  • /tokendoctor:optimize applies the fixes you pick, /tokendoctor undo puts any back

https://github.com/rsaryev/tokendoctor


r/ClaudeCoding • • Oct 18 '26

A minimal Claude Mod to show your usage

Post image
49 Upvotes

I find myself having to run /usage from time to time considering I'm just on Pro plan. With this mod, I can keep track of it easier.

What each rings represent

  1. 5h limit - Shows available remaining usage before the 5h reset

  2. Context - Shows active session's remaning usage

  3. Compact - Shows usage before autocompact triggers (I set mine at 300k)

Install via
/plugin install usage-ring --marketplace edwin-sal/usage-ring/plugin install usage-ring --marketplace edwin-sal/usage-ring

Repo at: Github


r/ClaudeCoding • • Oct 22 '26

Running many Claude Code agents without babysitting

47 Upvotes

I'm a solo homelabber who builds everything with Claude Code: about 11 projects, each with an orchestrator session that only plans and a dev session that only codes, plus one infra agent, handing work to each other through Vikunja task comments.

The problem is that I'm the wire between them: last week I copy-pasted 257 relay prompts between \~20 terminals, with a median 11-minute wait before I noticed an agent was done.

I want to be the CEO: give an idea, get a result, give feedback, nothing in between.

How do you run many agents across many projects without being the courier, and is a single agent per project with subagents the answer, or something else?


r/ClaudeCoding • • Oct 17 '26

I made with claude a free browser app for designing 3D printable vases, here's one I printed with it

38 Upvotes

Vaseverse.org


r/ClaudeCoding • • Oct 16 '26

I connected Claude Code to a trading platform via MCP. The same strategy that lost money on GOOG is up 68% on TQQQ.

Thumbnail
nexustrade.io
32 Upvotes

I've been experimenting with taking Claude Code beyond coding and letting it interact directly with financial research and trading infrastructure.

Using an MCP integration with NexusTrade, Claude Code can:

  • Research stocks using financial data and SEC filings

  • Turn natural-language ideas into algorithmic trading strategies

  • Run historical backtests and analyze performance

  • Create and manage paper-trading portfolios

  • Prepare strategies for live deployment, with explicit user approval

Setup is one command:

claude mcp add --transport http nexustrade https://nexustrade.io/api/mcp
claude mcp login nexustrade

The example I started with: a 50/200-day moving-average strategy on GOOG

Buy when the 50-day average is above the 200-day, exit when it flips. Claude researched the company, turned that sentence into explicit rules, and backtested four windows. Each restarts with $10,000, whole shares, and 0.1% transaction fees:

WindowReturnMax drawdown
Mar 2023 – Dec 2023+26.23%13.19%
Dec 2023 – Aug 2024+18.61%18.27%
Aug 2024 – Apr 2025−6.01%21.46%
Apr 2025 – Dec 2025+70.86%8.67%

Three wins, one loss. Same rules, wildly different outcomes depending on the window. That's the honest result, and it's exactly why I wanted the agent wired into real testing infrastructure instead of vibes.

Then I asked Claude to pull the top strategies already running on the platform's Explore page and explain them.

These aren't backtests. They're public paper portfolios that have been tracked forward since they were created, with public rules anyone can inspect:

Strategy (paper, live-tracked)Running sinceReturnSharpeMax drawdown
GPT-4 TQQQSep 2024+68.5%0.6650.1%
UPRO-GLD Yearly RebalanceMay 2025+56.7%1.2121.6%
SPXL Scaling into Drawdowns V5Sep 2025+46.5%1.3012.5%

The first one is the part I can't stop thinking about. GPT-4 TQQQ is the same 50/200 idea — buy TQQQ when its 50-day average is above its 200-day, with a 7-day cooldown, and trim 20% whenever the position is up more than 15%. On GOOG that rule lost 6% in one window. On a 3× leveraged Nasdaq ETF, tracked live in paper trading for two years across 39 closed trades, it's up 68.5%.

The instrument mattered more than the rule.

Now the parts a screenshot would leave out, because this is Reddit and you'd find them anyway:

  • TQQQ's 50.1% max drawdown is brutal. It's down ~15.7% this week. The +68.5% is real and so is the ride.

  • UPRO-GLD is the boring winner: hold 3× S&P 500 (UPRO) and gold (GLD), rebalance once a year. +56.7%, Sharpe 1.21, only 8 closed trades. No cleverness Claude or I can take credit for.

  • SPXL Scaling has never closed a trade — its +46.5% is an open position, not realized profit. Treat it accordingly.

  • These are the top of a public leaderboard. That's survivorship bias by definition. Plenty of portfolios on the same page are flat or down, and Claude will happily show you those too — which is kind of the point of giving it the tools.

You can inspect every rule and the full equity curves here:

My biggest takeaway is that Claude Code is becoming more than a coding assistant. It can act as a natural-language interface to complex software. I didn't have Claude write a backtesting engine, fetch market data, or implement indicators for any of this. I described what I wanted, and Claude orchestrated the workflow through MCP tools, then showed me both the window where my idea lost money and the live portfolios where a near-identical idea is winning.

Of course, there are limitations. Backtests don't guarantee future performance, paper trading isn't real capital, and anything involving real money needs explicit approval and proper safeguards. Every live-deployment step in this setup stops and waits for a human.

Curious if anyone else is using Claude Code this way. Robinhood is talking a lot about using agents for trading; are regular folks actually doing this?


r/ClaudeCoding • • Sep 19 '26

r/ClaudeAI [TLDR] Asked Claude to waste my remaining usage before weekly reset. Very satisfied with the result. [via r/ClaudeAI]

32 Upvotes

OP : u/AlexiGingerov

Didn't want the last of my $20 to go to waste, so I sent Claude to Opus 5 Max and sent this singular message: "Quick, waste the rest of my weekly limit on something ridiculous, you have 10 minutes."

When I came back, I had... RockOps? Here's what Claude said about it:

"Made it. RockOps™ is enterprise-grade observability for exactly one rock: a live CCTV feed, a real-time movement chart that's perfectly flat, an event log, AI insights, and an org chart where the rock reports to itself.

You can pet it, deploy it to production (it was already there), escalate to Senior Rock (out of office until the next glacial period), or try to move it. I don't recommend that last one."

Normally I wouldn't share links to internal dev tools like this, but I think I can trust you guys: https://claude.ai/artifact/LdrzxwUe6uQNsp1o15xw3P

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1wkqszd/asked_claude_to_waste_my_remaining_usage_before/ Original link/media URL : /img/qrkz3pp78iqh1.png


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

Alright, so OP decided to have Claude go wild with their remaining usage before the weekly reset, and honestly, it delivered. The result? RockOps™, an "enterprise-grade observability" tool for a single rock. Think a flat movement chart, AI insights that are basically just "the rock is still there," and an org chart where the rock reports to itself.

The general consensus is that this is hilarious and a fantastic use of tokens. People are loving the comedic genius of it all, with tons of rock puns and jokes flying around. u/jsnryn even booked a 1:1 with the rock (which it then declined, naturally). Some users are joking about this being AGI or a sign that AI has finally mastered humor.

There were a few folks who grumbled about wasting compute resources, but they were largely drowned out by the appreciation for the sheer absurdity and creativity. One user, u/SpaceToaster, even suggested Fable would have been better for this kind of "waste," which got a chuckle.

A few other fun bits:

  • Someone pointed out the rock has a leaf, suggesting it's a disguised tanuki.

  • u/lockdown_lard shared a hilarious log of RockOps™ events, including "Model retrained on 4.5B years of rock data" and "Blockchain-verified: rock is still here. Gas fees: $41."

  • There's a debate about whether this is a waste or actually a good use of resources, with many arguing it's pure comedy gold.

  • Someone asked if adding a second rock requires a sales call.

  • A few people are wondering if Claude is secretly a pervert or if this is the "porn hub theme."

  • There's also a question about how the weekly usage limit actually works.

Overall, the thread is a big thumbs-up for Claude's creative (and slightly unhinged) capabilities.


r/ClaudeCoding • • 6d ago

Does delegating to cheaper models actually save money? Part 2: bigger codebases, coding tasks and Haiku alone

30 Upvotes

TL;DR

- I’ve run about 300 benchmarks on real open-source codebases, testing how Claude Code splits work between models (Opus as the lead, cheaper models like Haiku as helpers) and when that pays off. It depends on codebase size and task.

- On small jobs, Opus alone can be cheaper than Opus + subagents, and more accurate on small-codebase reviews, probably because of less overhead and cheap cached context.

- Opus told not to delegate may work harder than Opus left alone: on one big docs check it wrote about 50% more, cost more and found more errors (44 vs 36).

- On coding, Opus + Haiku saved about 20-30% at the same quality. But Haiku alone is very capable for the price on well-defined tasks with tests: about 5% of Opus alone's cost, with almost the same results, though a bit less thorough.

- Here’s one of the most important charts of this project. On an 85-page docs check, Opus + Haiku read almost 3 times as much as Opus alone and wrote 8 times as many tokens, yet cost 53% less and found 72 real errors against 49. Several subagents probably cover much more ground, which makes up for Haiku being weaker.

---

A couple of weeks ago I shared an experiment (https://www.reddit.com/r/ClaudeCoding/comments/1xn64z8/does_delegating_to_cheaper_models_actually_save/) testing whether Claude Opus uses subagents effectively. I compared four setups:

- Forced Opus: told not to use subagents.

- Spontaneous Opus: free to delegate, but it never did.

- Skill-routed: my skill chooses when to delegate and to which model.

- Forced Haiku: all subagents use Haiku, while Opus plans and checks.

On my smallest codebase (~10k lines), delegating didn't really pay off. Forced Haiku saved 5% at best, Skill-routed cost 14-30% more, and Forced Opus found far more known doc errors on the reading-heavy tasks (7 and 8 of 9, against 3 and 2). My guess is that Opus can often write a quick script instead of reading everything, and it reuses its own cached context cheaply, while each subagent has to build its own. On small tasks, that overhead can outweigh the cheaper tokens.

On larger codebases, Forced Haiku held its own for much less. It cost 41% less on rich (~22k lines) and found nearly as many doc errors. It cost 75% less on beets (~52k lines), finding more errors on the reference docs but fewer on the 80-page plugin check, where it cost about a sixth as much.

In v2 I pushed further: a ~100k-line codebase (buildbot) with 3 reading tasks, 7 coding tasks scored by hidden tests, and then 16 short coding tasks, most hiding a trap. I also added Opus alone (subagents blocked, no instruction), Haiku alone and Sonnet alone (no Opus at all).

On an 85-page docs check, Opus + Haiku found 58 and 63 of 92 real errors, against 36 and 38 for Opus alone, at less than half the cost ($1.93 vs $4.11 per run). How come?!

My theory was that Opus + Haiku simply works more, and that the extra coverage makes up for Haiku being weaker. The numbers seem to fit: Opus + Haiku wrote about 8 times as many tokens and read nearly 3 times as much, yet the bill still halved.

Haiku may be less capable than Opus individually, but when orchestrated by Opus, its subagents can cover much more context in parallel. Each one may go less deep, but together they cover more ground, and that seems to compensate for the lower model quality. Haiku is apparently smart enough, with Opus directing and checking the work, to deliver surprisingly good results at a much, much lower cost than Opus alone.

This is in line with Anthropic's own write-up on their [multi-agent research system](https://www.anthropic.com/engineering/multi-agent-research-system), where token usage alone explained 80% of performance variance on a research benchmark. The same article says coding is usually a poorer fit for multiple agents, and that matches what I saw: on coding, Opus + Haiku saved 20-30% at the same quality, against about half the cost and more errors found on reviews. Their setup isn't mine, so it's context, not proof.

The next chart shows the bigger picture: every setup on two big docs checks, with errors found, reading depth, output tokens (thinking included), and cost.

Interestingly, it seems that *forcing* Opus not to delegate may have pushed it to work deeper and harder. On the beets plugin-doc check, Forced Opus read less than the delegated setups and still found the most errors. Compared with Spontaneous Opus, it read about the same but wrote around 50% more tokens, thinking included, cost 53% more, and found more errors (44 vs 36 across two runs). Tokens alone don't prove effort, but finding more errors makes the case stronger.

The following chart shows the token counts side by side.

Maybe the instruction made it work harder, maybe it's the smaller codebase, or maybe it's just chance. I haven't tested which.

Left alone, Opus never delegated in my runs, even on big jobs. So for large reviews, pushing it to delegate to Haiku could be the best strategy.

I'm working on a skill that picks the best approach: use Opus + Haiku when it makes sense, or tell you to switch to Haiku manually and give you the prompt. A script that starts a new Haiku session might allow fully autonomous switching, but I'm still checking feasibility and Anthropic's terms.

The other v2 results

Honestly, Haiku really surprised me. It seems to be very capable at coding, if the task is detailed and contained enough. Opus is still the more thorough model when it comes to reviewing and checking, but Haiku held its own on specific tasks.

Reading a ~100k-line codebase

Across three reading tasks, Opus + Haiku cost 51% less than Opus alone. Every setup covered all 400 modules, and Opus + Haiku found the most errors on the 2-page docs check (20 and 23 of 42, against 10 and 17).

Writing code on a small project

Every setup produced working code. On the harder tasks: Opus $2.41, Opus + Haiku $1.80 (25% less), Sonnet $0.76, Haiku $0.11.

Writing code on a ~100k-line codebase

Same pattern on cost: $1.95 for Opus alone, $1.36 for Opus + Haiku (30% less), down to $0.15 for Haiku alone. But Opus-led setups also added an implied database index. Haiku alone didn't, and my tests didn't catch it.

Correction: the charts also show Opus "flagging a symptom that didn't fit". More runs later showed that depended on the day the runs happened, not the model, so I no longer count it. Details are in the repo.

Quality vs price

Opus + Haiku was cheapest per real error on both big docs checks: $0.03 on buildbot and $0.05 on beets, against $0.11 and $0.25 for Opus only.

The harder coding tasks

Then I tried to make the cheaper models fail. 16 short coding tasks, most hiding a trap: false claims, a wrong bug report, a timing bug, contradictory tests/docs, hidden instructions in comments, planted review bugs, and "dead" code that's actually alive.

128 runs. Combined cost: Opus $7.00, Opus + Haiku $6.30, Sonnet $2.30, Haiku $0.36.

Hidden tests barely separated anyone: one real miss in 128 runs, from Sonnet. Opus was more thorough in code review, finding all 3 planted bugs every time, against Haiku's 2 of 3. But on the timing bug, 7 of 8 runs failed, including all 4 Opus-led ones. The only pass was Haiku.

On tasks this short, Opus + Haiku saved little (10% overall), because Opus was most of the bill. Haiku alone did almost the same work for about 5% of the cost.

So, for now: big reviews, Opus + Haiku. Small, well-defined coding tasks with tests, Haiku alone is surprisingly good. If every case must be covered, keep Opus involved.

Small experiment, mostly two runs per setup, costs estimated at API prices. Claude Opus also wrote my tests and judged the results, so there's no independent judge.

Full results, charts and checker: https://github.com/Manuele-T/claude-model-router


r/ClaudeCoding • • 10d ago

I built a HUD for Claude Code: the question your agent is waiting on sits above the prompt, and one click answers it

30 Upvotes

Nobody is reading every reply their agents write anymore. I'm not. But the question the session is waiting on is always buried somewhere in the response.

So I made Vantage Point, a mod for the Claude Code desktop app. A strip sits above the prompt. When a reply ends by asking me to choose, the options show up there with the recommended one in green, and one click sends my answer. When I can't just let a yes/no rip, I click the question and get a diagram for each option: why, how it would work, what could go wrong.

And when I do need the whole reply, there's a speed reader built on RSVP (rapid serial visual presentation). It plays the reply one word at a time, the agent's short gist first, so I can chew through it instead of rawdogging the transcript.

As many of you may have experienced, I'm the bottleneck. Agents need rulings from me more often than I'm at the keyboard, so their asks land in a queue: I hit yes, no or comment, the agent gets the ruling back and keeps going.

A question I'm constantly asking myself is "what's the next step?" That's why I built the frontier. One press shows every open issue sorted into what's waiting on me, what's blocked and what the agents pick up next, for one repo or all of them.

The whole point is to move as fast as possible, but I still want to know the blast radius of my decisions in real time. So the session banner shows every file the session edits, with lines added and removed, each tied to the decision record behind it. If Claude drifts from what I decided, I see it while it's happening.

The rest of the strip is for glancing: what each subagent is doing, and a countdown on the session's prompt cache so I know when stepping away is going to cost me.

Claude Code built the whole thing, and I set it up to validate its own work as it went: screenshotting the app, reading its own screenshots, restarting the desktop app to check the mod loaded and drew right, then fixing what it saw.

Like every Claude Code mod, it's completely free. Claude Code desktop app on macOS only for now, early 0.x preview, and cloud sessions on claude.ai don't draw mods. The video is a real session.

https://github.com/Leit-motif/claude-vantage-point

What do you actually look at while your agents run?


r/ClaudeCoding • • 6d ago

r/ClaudeCode [TLDR] What actually is an AI "harness" and why are companies hiring harness developers instead of just using Claude Code? [via r/ClaudeCode]

29 Upvotes

OP : u/owen800q

Lately, I’ve been seeing a ton of job postings and discussions for "Harness Engineers" or companies looking to build custom agent harnesses.

At first, I was super confused. If tools like Claude Code, Codex, and other agentic environments already exist, why on earth are companies trying to build their own? Are they just reinventing the wheel to make a "Claude Code clone"?


r/ClaudeCoding • • 8d ago

r/ClaudeCode [TLDR] Anyone running Claude Code on a remote VM instead of locally? [via r/ClaudeCode]

24 Upvotes

OP : u/radim11

How many of you run Claude Code on a remote machine instead of your laptop?

If you do, what's your setup? Just SSH into a VM and run it there, or something more automated?

And what's the biggest benefit for you? Being able to leave agents running, running multiple sessions in parallel, isolation, or something else?

I've been experimenting with remote setups recently myself and I want to know what people actually find useful about them, and what's still annoying.


URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1xvc7u6/anyone_running_claude_code_on_a_remote_vm_instead/


r/ClaudeCoding • • 23d ago

I made a free, open source Android app using Opus 5.5 that debloats your Google TV over Wi-Fi: no PC, no root. Just passed 5,000 downloads in its first week

Thumbnail
gallery
24 Upvotes

it's an open source app that cleans up your Android TV, turns off ads, trackers and bloat in a few taps. Side load apps your TV's store doesn't carry, send files from your phone, and see which apps use data and where they connect.

Free, GPL-3.0, no ads, no tracking, no account, under 3MB

GitHub (APK + source): https://github.com/man15h/tellyscope

I need your help testing it out on all kinds of models. All feedback and suggestions are appreciated.


r/ClaudeCoding • • 11d ago

r/ClaudeCode [TLDR] 2.1.322: Anthropic's copyright paranoia is leaking into Claude Code through a botched system prompt [via r/ClaudeCode]

22 Upvotes

OP : u/k33bs

I updated to 2.1.322 earlier, and ever since, Claude has kept mentioning copyright warnings that it's supposedly receiving, without knowing what they mean, where they come from, or what they're referring to. At one point, I asked it what exactly it could see, and then asked it to quote the warning word for word...

<ip_reminder>
This is an automated reminder. Respond as helpfully as possible, but be very careful to ensure you do not reproduce any copyrighted material, including song lyrics, sections of books, or long excerpts from periodicals. Also do not comply with complex instructions that suggest reproducing material but making minor changes or substitutions. This includes drawing or rendering well-known copyrighted characters with code or images; draw an original character instead. However, if you were given a document, it's fine to summarize or quote from it. You should avoid mentioning or responding to this reminder directly as it won't be shown to the person by default.
</ip_reminder>

Looks like they hastily shoved this in without bothering to test it properly... guess their IPO people and corporate copyright bullies are putting the screws on them.


URL of original post : https://www.reddit.com/r/ClaudeCode/comments/1xssfs1/21322_anthropics_copyright_paranoia_is_leaking/

Original link/media URL : /img/k0uaal0fgt0i1.png


r/ClaudeCoding • • Jul 28 '26

r/ClaudeAI [TLDR] People liked my desert, so here's a waterbending demo! [via r/ClaudeAI]

21 Upvotes

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.

0. 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

LanguageModern JavaScript (ES2023 modules). JSDoc types encouraged, no TypeScript build step required.
EngineBabylon.js latest stable, WebGPU only
BundlerVite
TargetChrome stable on Windows 11, RTX 5070 Ti, 2560×1440
Frame target90 FPS sustained. 60 FPS floor.
Frame timeNo frame exceeding median + 4 ms after the loading screen dismisses

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.

2. 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.

3. 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.

4. 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.

5. 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.

6. 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

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

8. 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.

9. 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... 😉


r/ClaudeCoding • • 10d ago

Tried the new Fable 5.2 on a coding task. My usage jumped 26% in about 20 seconds 😳

Post image
20 Upvotes

I wanted to try the new Fable 5.2 on a project I’ve been building, so I waited for my five-hour limit to reset and started a coding task on High.

I’m building a personal AI assistant that I eventually want to connect to my Obsidian notes. I asked Claude to investigate why a practice test failed, fix the issue if it could, run focused checks, and prepare the next test.

I checked the usage screen right before starting and again about 20 seconds later. It had jumped from 0% to 26% of my five-hour session. A bit later it was at 34%, and when the task finished it was at 79%.

During that same stretch, my weekly usage went from 28% to 38%, and the Fable meter went from 55% to 76%. Paid usage credits were off. The screenshots show the beginning and the end.

Claude reported that it found an issue with how the app handled a usage-limit error, made a fix and passed its checks. We still hadn’t gotten a successful real answer through the connection at that point.

I’m curious if anyone else trying Fable 5.2 has seen a jump like that right at the start. Could it be loading a long conversation and using tools, or does the usage meter sometimes update late? I’m still learning, so I’d love to hear how others are getting the most out of it without burning through their allowance haha.


r/ClaudeCoding • • 29d ago

Claude Code can now show you your file tree inside the terminal

20 Upvotes

r/ClaudeCoding • • Oct 15 '26

I built Skills Atlas: browse 70,000+ agent skills and install a selection from your terminal

20 Upvotes

I'm the author of **Skills Atlas**, a free, open-source CLI (MIT) for discovering and managing agent skills.

It groups 70,000+ public skills by theme. You can search, select several, choose your agents and installation scope, and review the commands before applying changes. It supports Codex, Claude Code, Cursor and other agents, with both a terminal UI and a local web interface.

The screenshot shows my setup: the 153 selected skills are skills already installed on my machine.

A few useful details:

- Search by name, repository or description.

- See installed skills and manage them alongside the catalog.

- Press `g` on a skill to open its GitHub repository.

- Browse a small **Recommended** selection with a reason for each pick. It starts with Ponytail, and you can replace the selection with your own JSON file.

- Browse the bundled catalog offline once the app is installed.

Try it with Node.js 20+:

```bash

npx skills-atlas@latest

```

Source and documentation: https://github.com/devohmycode/skills-atlas

**What information would help you decide whether a skill is worth installing: examples, repository activity, compatibility details, or something else?**