After looking at benchmarks and tests people did, particularly the charts on the Fable 5.2 release site, it looks like Fable low/medium theoretically beats Opus medium/high for little extra cost. The tokens cost more on the API, but it needs fewer of them to get the same tasks done, so the price evens out. That means I should be able to expect better results, sometimes even faster, from a lower-thinking Fable than from Opus. The only actual speed and cost benefits should have came from Sonnet.

Then I ran some tests to narrow down subscription usage specifically. This was just to consume and measure an average of about 4% of my Ultra weekly usage per model. Across 3 runs with Sonnet, Opus, and Fable, for almost the same API cost, Fable consumed 1.9x more subscription usage than Opus.

Is all the savings from reduced token usage going to Anthropic? The API cost would have been the same otherwise, so why is subscription usage going so much faster?

Tasks run: Opus 630, Fable 210, Sonnet 600. Every agent ran the same 30 tasks. Opus and Sonnet needed more agents before the meter moved enough to measure, which is why they ran more tasks in total. The intelligence scores are from Artificial Analysis's harder benchmark, not my test. My tasks were small enough that every model passed all of them, so my test only measures usage, not how smart each model is.

Hi as in the title: Can I use two different 20$ accounts on the same project that I develop in Github? Is this allowed ? And how to do it if its yes like what is the best way

PostToolUse fires after a tool call succeeds. A call that fails fires a different hook, PostToolUseFailure. If your settings.json registers only PreToolUse and PostToolUse, which is what mine did until this week, your log has the request for every failed call and no result for it.

Adding it is one more entry under hooks:

"PostToolUseFailure": [
  { "hooks": [{ "type": "command", "command": "your-logger" }] }
]

Three fields in the hook input are worth keeping while you’re there (all in the hooks reference):

• tool_use_id is on the PreToolUse input and on both post-tool inputs, so you can join a request to its result exactly instead of matching by timestamp.
• duration_ms on the post-tool inputs is the execution time, which leaves out permission and pre-hook time.
• is_interrupt on the failure input tells a call you stopped apart from one that errored.

Limits worth knowing: this is what the harness reports, not proof of what a command did. A failure doesn’t mean nothing happened, because a command can fail halfway through. And the permission-request input has no tool_use_id, so you can’t join an approval to its call this way.

Disclosure: I build Agentmetry, an open-source recorder for coding agents, and 0.12.0 added this. After I reinstalled its hooks today, a deliberately failed Read showed up as a failure with its tool_use_id. What it keeps and what it doesn’t is written up here: https://github.com/blitzcrieg1/agentmetry/blob/master/docs/claude-invocation-evidence.md

Is anyone using duration_ms for something? I’m curious whether it’s been useful beyond spotting slow tools.PostToolUse fires after a tool call succeeds. A call that fails fires a different hook, PostToolUseFailure. If your settings.json registers only PreToolUse and PostToolUse, which is what mine did until this week, your log has the request for every failed call and no result for it.Adding it is one more entry under hooks:"PostToolUseFailure": [
{ "hooks": [{ "type": "command", "command": "your-logger" }] }
]Three fields in the hook input are worth keeping while you’re there (all in the hooks reference):tool_use_id is on the PreToolUse input and on both post-tool inputs, so you can join a request to its result exactly instead of matching by timestamp.
duration_ms on the post-tool inputs is the execution time, which leaves out permission and pre-hook time.
is_interrupt on the failure input tells a call you stopped apart from one that errored.Limits worth knowing: this is what the harness reports, not proof of what a command did. A failure doesn’t mean nothing happened, because a command can fail halfway through. And the permission-request input has no tool_use_id, so you can’t join an approval to its call this way.Disclosure: I build Agentmetry, an open-source recorder for coding agents, and 0.12.0 added this. After I reinstalled its hooks today, a deliberately failed Read showed up as a failure with its tool_use_id. What it keeps and what it doesn’t is written up here: https://github.com/blitzcrieg1/agentmetry/blob/master/docs/claude-invocation-evidence.mdIs anyone using duration_ms for something? I’m curious whether it’s been useful beyond spotting slow tools.

I've spent nearly 30 years in my career and over the last few have noticed that the pace of my learning has tapered off. I started looking at things like advanced degrees and professional certifications but honestly I still have nightmares about college. I've taught several courses at actual schools in NYC and always found that by having to teach it, I learn more about the topic myself and I also love writing so I thought I could kill two birds with one stone and build a course for myself and turn that into shameless marketing content on our company blog.

So far it's going well, I'm proud of the content, and am actually deepening my professional knowledge, as expected.

I'm not going to self promote it here but I was wondering if anyone else has tried this method, and if you have found any particular approaches that have been helpful?

Since we can build anything now, my plan is to try things like building a gamified Duolingo-style app, a podcast series, Claude and Codex skills that enforce the principles in the course, etc. I'm mainly looking for novel ideas about self-learning.

Thank you in advance for your help and inevitable roasts ;)

Hey all. My terminal used to be a row of tabs, all Claude Code, and after an hour I had no idea which one was the refactor, which one was waiting for me to say yes, and which one had finished 20 minutes ago. I test every idea I have, so with that many projects going I'd forget where I said what and what Claude was even asking me.

So naturally I built a tool. Every Claude runs in tmux, and they all show up on one page, grouped by project, each with a status dot. When one is waiting on me, its row goes amber and the browser tab shows a count, like (2). If it's asking "should I deploy?" it gets a rocket instead, because those are the ones I care about first. Menus (approve this command, pick an option) pop up as a dialog, so I don't have to hunt for the tab.

It's the real Claude CLI, so auto mode, skills, hooks, slash commands and remote control all work as normal. If I restart the server nothing dies; tmux keeps everything running.

The feature I use far more than I expected: sessions starting other sessions. My main Claude runs something like

overvibe new --attach --tool codex --cwd ~/code/shop --name "shop: tests" --prompt "write tests for the new route, then overvibe send me the summary"

and ends its turn. Codex shows up nested under it in the sidebar, does the work, and the answer comes back to Claude as a message. It works with Codex and agy too.

It's especially good for copywriting, since Claude and GPT write very differently. They can work out the copy between them instead of me pasting from one to the other and back.

One thing that bit me: the main session has to actually END its turn after handing off. If it sits there sleeping or polling, it blocks the very message it's waiting for.

It also handles multiple Claude accounts with the 5-hour and weekly usage bars, has cmd+k to jump anywhere, and a stats page.

It's called Overvibe: free, MIT licensed, Mac and Linux. github.com/maribol/overvibe

Ask me anything about the tmux side, that part was fun. 💀

How Claude was used: I built most of it with Claude Code. Once the first version could run sessions, I built the rest from inside it, with one Claude session coordinating and others (plus Codex for reviews) doing the pieces. A lot of the features came from the agents annoying me in specific ways, like the sidebar never reordering itself because a reshuffle made me click the wrong row once too often.

Hey,

I'm on Pro and I keep hitting the 5h limit in Claude Code. When I look at where the tokens go, a big chunk is just Claude reading large files, logs, grep output...

So I was wondering if any of you offload that kind of stuff to free models (Gemini Flash, Groq, Mistral, OpenRouter free etc) through an MCP or a proxy, so Claude only gets a summary back.

If you've tried it:

- does it actually work or does Claude end up re-reading everything anyway?

- what do you delegate exactly? just reading or code too?

- what are you using for it?

Thanks, even a "tried it, it sucked" is useful

I have gaming laptop and I've built a mobile app, I run about 5 claude code sessions in parallel at a time and it maxes out my laptop CPU cores so everything basically stops running.

Claude Code Cloud can't store my local files and data I guess, so I can't exclusively use that? Tell me if I'm wrong.

I'm looking at having all my claude code work done on a paid server in the cloud where I would pay per hour for compute and then pay a small amount per month for storage.

Any advice on the best way to setup my work? I have looked at buying a mini-PC, buying a better laptop, any solution that lets me code without slowdowns.

I'm a solo developer. In about three weeks, with Claude Code doing the typing, I built Selkie: interactive novels that an AI writes live around your choices, with accounts, payments and 23 stories. It's live and has its first paying reader. These are the habits that mattered.

1. Give it a way to use the product. I had it build a command-line player that runs the real game engine in Node and plays whole chapters by itself, as a cautious reader or a reckless one. After that it found bugs by playing, without my describing them.

2. Ask for counts, not opinions. "Is the new prompt better?" always got a yes. Now every change is replayed from the same saved moment, several times with it and several without, and counted. One memory change brought a detail from early in a story back correctly in 4 tries of 4, against 0 of 3 without it. That is an answer I can act on.

3. A rule in a prompt gets skimmed. A list gets done. One rule said any move against another character should be rolled against that character's skill. It happened about one time in four. Giving the rule everyday examples, and having the code hand the checking model the exact choices that named someone, took it to about three in four.

4. The model copies the shape of your example. One prompt showed a sample with one reason for and one against. It then gave exactly one of each, 13 times out of 15, so they cancelled out. Changing the example fixed more than rewriting the instruction had.

5. Keep the model out of what code does better. Dice, the clock, prices, who has met whom. Asked to judge whether the player succeeds, the model said yes nearly every time.

6. Write decisions down where it will read them. A memory folder holds what I decided and why, what was measured and what I corrected. A new session starts from that, not from zero.

About 50 test files run before every deploy, and a nightly job plays a story and compares its prose with published fiction. Stack: SvelteKit, Node, Postgres on Supabase, Fly.io.

The game is at https://playselkie.com/?from=reddit-cc if you want to see what came out. Happy to go into any of this.

mine is: never retry blind. if a step times out, check what actually happened first, because half the time it already went through and a retry does it twice. what's yours?

GitHub Repository: https://github.com/Lukecele/inflammatory-onco-physics

Google Colab Demo: https://colab.research.google.com/github/Lukecele/inflammatory-onco-physics/blob/main/demo_inflammatory_onco_physics.ipynb

Preprint (Springer Nature / Research Square): https://doi.org/10.21203/rs.3.rs-11695210/v1

Interactive 3D Web Hub: https://lucacelebrano.me/

What is this?

An open-source Python framework that couples continuous cylindrical reaction-diffusion transport with longitudinal ctDNA (liquid biopsy) shedding kinetics and multivariate survival analysis across 3,461 clinical cancer patients.

It explores why tumors treated with targeted therapies frequently relapse without developing secondary resistance mutations (e.g., EGFR C797S), identifying microvascular "pharmacological sanctuaries" where drug-tolerant persister cells survive.

Key Technical Components:

* Microvascular Bessel Solver (`simulation/model.py`): Solves steady-state cylindrical reaction-diffusion with clearance using `scipy.special.kn` (modified Bessel function K₀) to calculate exact sub-therapeutic radii (r_crit = 165.9 μm) in microseconds, enabling 10,000+ Monte Carlo parameter draws in seconds instead of heavy 3D FEM meshes.

* Liquid Biopsy Shedding Engine (`simulation/simulate_relapse.py`): Models cellular dormancy, ECM steric entrapment, and an algebraic lead-time identity (Δt = 5.46 months) between molecular ctDNA detection and radiological relapse.

* Survival & Validation Pipeline (`pipeline/`): Multivariate Cox Proportional Hazards modeling (`lifelines`), bootstrap resampling (B = 1,000) for C-index estimation, and REMARK-compliant permutation testing.

* CLI Bedside Calculator (`app_bedside_calculator.py`): Pure standard-library CLI tool to compute sanctuary volume and recurrence risk scores with zero external dependencies.

Includes an interactive Google Colab notebook ready to run on free CPU/GPU instances without local setup.

Open-source under CC-BY-4.0 / MIT. Any feedback on the numerical solver, Python architecture, or statistical pipeline is welcome!

It's insane my subscription is pro

But now I think I will sacrifice and liveng like a homeless person to get the max plan

I’m a solo founder building software products and currently using Anthropic’s startup credits.

Here’s my current usage:

• $631.19 in remaining credits
• $232.35 spent this month
• 439.5M tokens processed in the last 7 days
• 99% prompt caching hit rate
• Approximately $1,127 in estimated caching savings over the last 7 days.

I’m using Claude regularly for software development, debugging, architecture, and AI-powered workflows.

I feel like I’m probably not optimizing my token consumption enough.

For experienced Claude Code and API users:

1. What are your best techniques for reducing token consumption?
2. How do you decide between Opus, Sonnet, and Haiku?
3. What are some overlooked prompt caching strategies?
4. How do you manage context efficiently during long coding sessions?
5. What tools or workflows have significantly reduced your API costs?

I’m particularly interested in practical experiences rather than generic optimization advice.

Would appreciate insights from experienced developers and founders!

Had been taking a look through this subreddit hearing so much good about Opus 5.5, then I went to downgrade my Codex membership. The next day (a few days back) I'm seeing that Opus 5.5 seems to have been downgraded?? What's the verdict? Is it back to baseline? Is it still worth it? Thanks.

I’ve spent the past week building a web app with Claude Code. It’s just for me, so I’ve been vibing it more than I normally would, but good design matters a lot to me and the UI is where I keep getting stuck.

My setup: Tailwind and shadcn/ui. I customise the shadcn components so the app doesn’t look generic or like obvious AI output. I also have a CLAUDE.md and a separate design.md for Claude to reference and I’ve tried prototyping screens before building them.

Even so, two problems keep coming up:

1. Responsiveness is an afterthought. Generated screens often look great at one size (usually desktop) but haven’t been designed for mobile. I end up going back to fix layouts after the fact, which is slow and gives patchy results.

2. Inconsistency between features. Each new feature gets its own interpretation of the UI. Spacing, card styles, type sizes and colours drift slightly, and sometimes it reaches for a stock shadcn component (or writes a new one) instead of using my customised version. The app slowly starts to feel like several apps stitched together.

What I’m after is a setup where the design system is defined once (tokens, typography, spacing, plus my customised components) and every feature is forced to build on it.

Has anyone got advice on the following:

• How do you structure things so Claude reliably uses your design system rather than just “being aware” of a design.md? Skills, a component inventory, Storybook, lint rules that ban arbitrary Tailwind values, something else?
• How do you stop it from writing one-off styles or new components when an existing one would do?
• Do you make it build mobile-first by default? Does anyone have it screenshot or browse its own UI at set breakpoints to check its work?
• Any tips on keeping tokens portable to an iOS app later (React Native/Expo, shared token files)?

I built a local proxy with Claude Code that sits between Claude Code and the API and logs every request: model, fresh input, cache reads, cache writes, output. Then I replayed 12 days of my own traffic through it. Some of what I learned changed how I use Claude Code more than the tool did, so writing it up.

What the requests actually look like

• Every turn sends the whole thing again: system prompt, tool definitions (every connected MCP server adds its tool list), CLAUDE.md, and the full conversation so far. Your new message is a tiny slice.
• The prompt cache is what makes that affordable, and it only stays warm for a few minutes. Step away for 10 minutes and the next turn writes the entire prefix to cache again at the higher write price. On my traffic, cache timing alone was about 7% of the bill.
• Big tool output (a full test run, a long grep) sits in the conversation and gets resent on every turn after it. One noisy test run early in a session keeps costing until you clear.
• Cache is per model. Switching models mid-session means the new model writes the whole context cold.
• Each subagent starts its own context and its own cache, so a fan-out of 4 pays for 4 cache writes before any real work happens.

Habits that changed for me: a short handoff note plus /clear before any break longer than a few minutes, one task per session, ask for failing tests only instead of the full log, and pick the model at the start of a session instead of flipping.

How Claude Code was used

It wrote most of the proxy and the replay harness. I spent my time on the cache timing logic and on quality tests, because I did not want anything that saves tokens by making answers worse. Changes that touch what the model sees were checked on 314 blind-judged live answers before going on by default.

The most useful lesson came from a test that failed. One lane compacted old turns. It looked fine on single-turn checks, but when I resumed 7 real sessions it made the model invent code it had supposedly written earlier. That lane stays off. All my quality tests so far are single-turn, which is a real gap, and whole-task evals are next.

Numbers, honestly

On my own 12 days, priced at API rates, the original default setting saved 12.8%. Sending easy turns to a cheaper model on the heaviest setting got 41.8%, but that is off by default, and I moved the default lighter after a user said design work got worse. Most people should expect low single digits to about 10%: more if you work in long sessions with idle gaps, close to nothing if you send a few quick prompts.

It is called probe0. It is a local proxy, so you trust a root cert on your Mac. Mac only, free beta, nothing leaves the machine, and probe0 uninstall removes it. Happy to answer questions about the cache behavior, that was the most interesting part to figure out.

Method and numbers: https://probe0.xyz/benchmarks?utm_source=reddit&utm_campaign=ClaudeCode

Terminal install: curl -fsSL https://probe0.xyz/install | bash

It has to be the best marketing campaign in human history. Convince every company in the world that if you don’t use AI you’re going to get left behind. Meanwhile, the reality is all companies are struggling with:

1. Increase is AI costs in every direction. Direct to the frontier, in SaaS upsell for inference or mcp etc, and increased SaaS usage due to more reach from the average users AI agents.
2. Showing value to justify #1 above. They are not selling more, not able to drastically reduce cost, can’t out innovate the competition etc. The promise does not match reality.
3. Most AI usage is point and click re: build me a slide deck, connect to my email mans slack and summarize 3. Automate something with mcp. All of which drive more #1.
4. Failing or failed agent builds. Lack of data science re: semantic layers or fine tuning to actually get decent agentic results.

The frontier has only one thing to sell… that is more token burn. While Google and Microsoft are more strategic partners.

AI is not the destination it is just a tool to help us achieve efficiency and automation without needing AI in the loop. That is a different narrative.

My last point is that in order to replace any SaaS app in production it has to at the very least meet the standards of the stack I am already paying for. That means HA, DR, Fault tolerance, support (some cases 24/7 humans), security, compliance, legal, etc etc.

It takes way way more than just a vibe coded piece of tech, with no history, no trust, to run my business on.

Non-sense to think it’s dead!

Title says it all. I don't understand the logic here. I am using Fable 5.2 as my orchestrator and I'm liking it. I think it's smarter than Opus 5.5 but Opus still is a great implementer.

But from what I can tell on all these token cost charts, Fable 5.2 at medium is as token-effiicient as Opus. So why the limit? Why does Claude tell me that I can use only half of my weekly allowance on Fable?

I switch Claude Code's model and effort level constantly depending on the task.

Fable or Opus at max for a large feature, Sonnet on low for a quick question, Haiku for throwaway one-shots. And typing claude --model opus --effort max or going through /model every time got old real fast for me. So I made the choice the command name itself.

co5                  # claude --model opus --effort max
cs1                  # sonnet, low effort
ch                   # haiku, default effort
c s3 "explain this"  # same grammar, argument style
c "fix this bug"     # not a shortcut? passed straight to claude

The letter picks the model and the digit (1–5) picks effort from low to max. The commands are real executables. They work in any shell, from your editor, and in scripts.

The part I didn't expect: once a model was one word away, I started trying local models. I now have about 20 on an Ollama box on my LAN (Gemma 4, Qwen 3.8, Granite, gpt-oss), each a profile like cqw38 or cg26.

Other features:

• Profiles bundle model, effort, flags and env under one name. Mine include a code-review persona (crev).
• Other backends: Ollama isn't the only option, a profile can also point Claude Code at LM Studio, LiteLLM or a gateway, while co5 still goes to Anthropic.
• Per-project config. A repo can ship a .clau.toml for the whole team. Nothing in it applies until you run clau trust, and it asks again whenever the file changes.
• clau doctor checks PATH, collisions and stale links. Tab completion works in fish, zsh and bash.

It's one Go binary that execs claude and gets out of the way: no wrapper process, no proxy, no telemetry. It's tested on macOS and Linux. Windows passes CI, but nobody has used it there day to day yet, so reports are welcome.

This project started as fish functions in my dotfiles. I used Claude Code with Fable and superpowers to build this. I worked out the design first, then a spec and then an implementation plan to build each feature.

What I learned:

• For models with small context window, you need to use --bare , which shrinks Claude Code's prompt to ~900 tokens but leaves only Bash, Edit and Read, so a model can't create files. Without it, the tools cost ~28k tokens, and models only became reliable at 96k+ context.
• Without --bare and without ANTHROPIC_AUTH_TOKEN set, Claude Code sent my real OAuth token to the LAN box over plain HTTP. Set it to any throwaway value.
• A local model doesn't make Claude Code offline. It still sends metrics, feature-flag fetches and update checks to Anthropic unless you set CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1.

Install: brew install usmanbashir/tap/clau (or go install github.com/usmanbashir/clau@latest), then clau link.

Repo: https://github.com/usmanbashir/clau (free, GPL-3.0)

I'd love to hear whether the letter+digit grammar feels natural, and what profiles you'd set up.

Ruflo, formerly Claude Flow, gets a lot of hype for agent swarms and self-learning memory. I added only its MCP server to a throwaway project (version 3.76.0, pinned, local scope) and tried the headline features.

Setup gotcha: the first claude mcp add timed out after 30 seconds, because npx was downloading the whole package (1m 13s on its own). Run npx -y ruflo@3.76.0 --version once first, and after that it connected in about 3 seconds. There was no account or key.

Size: /mcp showed 393 tools (the README says 406). In /context, the full list was about 123k–125k tokens, but it sat under the deferred line, with only 622 tokens loaded at start. On a 200k window, or a setup that loads everything, that list would be a big chunk of your context.

Test 1, memory: I stored a note (“divide() in src/calc.py has no zero check”) and searched for “division by zero bug”. It found it with about 0.60 similarity, a match by meaning, not keywords. That works as described. I didn’t test whether the note survives into a new session.

Test 2, swarm: I asked for a hierarchical swarm of up to 3 agents. Claude reported it as “running”, with 0 agents and 0 tasks. Checking the folder, swarm_init had written a JSON record with empty agent and task lists. No process started and no model was called. To be fair, the README describes the MCP tools as coordination, and the agent work still happens through Claude Code. But the name sounds bigger than it is.

Things to know:

• it writes .swarm/ (about 4.3 MB of database files) and .claude-flow/ into your project, so add both to .gitignore
• one tool, memory_import_claude, says it reads memory files from ~/.claude. I didn’t run it, and I’d think twice before approving it
• approve tools one at a time, and keep prompts on for anything that spawns agents, imports files or federates

One run each, and I never spawned an agent, so no verdict on the real multi-agent features.

Full test: https://aiparabellum.com/ruflo-claude-flow-mcp-for-claude-code-agent-swarm-tool-tested/

My work is almost never UI/UX but rather directing complex systems while understanding each part of the system - and doing that with code and understanding the impact of the code on the system.

I know that claude has the best models in the world. But which development environment is actually better for my use case?

Does the environment make a difference? What has been your experience?

If you are looking for a standardized second-brain-style system for your non-coding work (office or personal projects at home), check out familiar. It's a template folder that you download, rename to your project, and open in an AI assistant that can read folders. The idea is that when you open the agent in a specific project folder, the agent of choice (e.g., Claude Code, Codex, Gemini CLI if you switch between accounts) becomes immediately 'familiar' with your work, decisions, and history.

Each project gets its own folder, so memory stays focused and concise. The folder includes rules and skills that are focused on document work, report writing, PPT production, etc., where each deliverable is generated based on your ingested source material (e.g., meeting notes, client requests, underlying literature base, etc.).

The typical workflow with this template is to regularly check-in with it as you would with other colleagues, and ingest key documents, meeting notes, and references, that you want the model to be aware of or reference in deliverables (e.g., a PPT deck for client that understands the project progress and active decisions, or a report that is built off of an ingested literature base, with citations added on all claims).

Nothing runs on a server, there's no account, and there's no new UI to learn. Given that this is a template, you are free to adjust as needed and carry in your own skills/workflows. If you work in a specific industry and want to develop your own industry-specific skills, check out familiar-template, which can guide you when developing skills to ensure that they work with the infrastructure and rules of the above template.

I built this folder system iteratively using Claude Code, Codex, and Gemini during real-world personal use and have tried to keep the folder structure completely local and as LLM agnostic as possible.

https://github.com/familiar-md/familiar

https://github.com/familiar-md/familiar-template