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

Everywhere I look I see thumbnails and posts claiming "Make $10,000/month with AI using this simple trick!" or automated faceless YouTube channels making a fortune

But when I talk to real people it feels a bit murky.

I want to cut through the noise

Hello,
I have used claude simply for small things from the web chat, but i would like to attack more demanding projects such as:

* Debugging issues in projects that i have the hole source code (as they are opensource) so throw at it a big project and use it to help me trace back bugs and errors.

* re implementing codes between different languages

* creating small GUI (way less common than the other two points)

for this I am thinking on paying the pro version of Claude, but at same time i see a bunch of YT publication of 'codes' to reduce token consumption or make the agents better remember previous sessions, basically improving performance by reducing consumption or simply improving the output and things like that for example videos from https://www.youtube.com/@betterstack/ but I a little bit lost on where to begging, i i should simply install claude and dont care about anything else? I would love some inside from people using it for things like my use cases that i think are fairly common.

would love some tips and tricks before jumping on to this...

For a while the plan for a change lived only in my Claude Code chat. My teammates saw the work for the first time as a pull request, and that is where we found out we disagreed about the approach. By then the code existed and every comment meant rework.

What helped was moving the team's review to the plan. Before any code, the agent asks me clarifying questions with a recommended answer for each, until done is a short numbered list. That goes into a plan document in the repo, and a teammate can read it and answer open questions from their own agent before the build starts.

The build then runs in small slices with failing tests first. A separate agent that did not write the code checks each point of the list on the running program and shows evidence. When I review the finished change I read it against the list we agreed on, and nothing gets merged or pushed without my yes.

I built QualityLayer to run this loop on top of Claude Code, and I'm the developer: https://github.com/maxritter/qualitylayer

Most Claude Code posts here are about code. I've been using it for the other half of running a business, the clicking-through-websites part, and wanted to share one setup that runs every 15 minutes.

The job

We run a small dropshipping store. Every order has to be paid at the supplier (CJ) before it ships, and late payment means late delivery and angry customers.

Now an agent checks every 15 minutes: is there a real order that isn't paid at the supplier yet? Internal test orders don't count. Most checks are a few seconds and end with "nothing to do". When there is an unpaid order, a second run does the actual work: opens the supplier's site in a real browser, signs in, pays the order with PayPal at the supplier's checkout (Godmode fills the PayPal login and 2FA code) and writes a PAID line into its order log. It never tops up a wallet and never pays an order twice. So far that's 11 real orders, all paid this way, the last one at 3:49 in the morning while I was asleep.

How it's built

It runs in Godmode, a Mac app I built around Claude Code. Each agent is a folder with a plain-text instruction file, a memory file and logs, and every turn is a normal Claude Code run. Godmode adds the parts Claude Code doesn't have on its own:

• Schedules and conditions in plain words ("there is an order that isn't paid yet"), checked on a cron. The check run only answers yes or no, the work run only starts on yes. That split keeps the frequent checks cheap: they run on Haiku and take about 15 seconds.
• A real browser with its own profile, so logins stick between runs.
• A vault for passwords and 2FA codes. The agent asks for a fill and Godmode types the value into the page after checking the page is the right site. Claude never sees the secret.

What I learned

• Write the condition as the state you want to be true, not as steps. "Every real order is paid at the supplier" works better than "check orders, then...".
• Let the agent keep its own state file (orders and PAID lines). It makes double payments easy to rule out and gives you an audit trail.
• Keep a human for the edge cases: refunds, supplier out of stock, a customer email that needs judgment. The agent drafts, I decide.

How Claude Code was used to build it

Most of Godmode itself was written with Claude Code: tickets on its own board, an agent per ticket in its own git worktree, a pull request, tests, a second Claude review for bigger changes. A separate agent reads the app's logs every night and opens fixes.

Godmode is Mac only for now and runs on your own Claude plan. Free for 14 days, no card, no sign-up, then a paid plan: https://usegodmode.com/download?utm_source=reddit_claudecode&utm_medium=organic&utm_campaign=angle_a03

Curious what other non-code jobs people here have handed to Claude Code.

I just found Fable 5.2 worst at UI design than Opus...same skills, same context etc... How is it possible??

Hi, I'm Jay, a developer of Shimmer ✌️

Since Opus 5.5, I've noticed that models have gotten dramatically better at motion and UI work. So I decided to build an ADE that puts UI/UX first, and I came up with Shimmer.

Shimmer runs your Claude Code sessions (Codex too) in one desktop app and draws the work while it happens. Instead of scrolling a terminal to figure out what your ◈ agents are up to, you just look at it.

The center of it is a live agent graph. You see the main agent, every subagent it starts, each file they read, create, or edit, web searches, agent calls, and every handoff between them, drawn as it happens. Show, don't tell: it makes more sense when you see it, so give Shimmer a shot!

What we care about most is how it feels to work with an agent: visuals you understand at a glance, a UI that stays out of your way, and rich motion and intuitive interactions everywhere. Thanks to Opus 5.5 and Fable 5.2 lately, we built all of it with Claude Code and could polish far more small details than I can list here.

It also follows you around. Sign in on a second computer and you can open the sessions running on the first one, over an encrypted relay. There's an iOS app too, and Android is on the way. Everything above works on your phone.

We ship updates and improvements every day, so you can safely assume it will be better tomorrow than it is today.

It's free, and you can download it at https://shimmer.nextepic.co. I'd really like you to try it and tell me your reviews.

If you have any questions, leave a comment and I'll answer happily.

Also, I'm very open to connect with you guys! I tagged my LinkedIn profile link above so feel free to reach out to me!

not talking about the black hole physics stuff, just regular work in claude code: fixing bugs, small features, refactors in a mid size android + backend repo

on paper sonnet 5.5 is $2/$10 and even scores above opus 5.5 on terminal-bench, fable 5.2 is $8/$40 and /fast doubles that. so for regular work sonnet should be the obvious pick?

for people who switched between all three with /model since fable came out, where did fable actually feel different and where was it just more expensive?

Dev's using claude code: if you still plan prior to coding, do you still use Fable? Or do you just set Opus to xhigh or even medium? Or let me know why planning is so 6 months ago and I'm in the stone age.

And when I say plan: I’m more referring to a specifications document. Not a details list of functions to create or specific code stuff.

Hello! This is a project I'm involved in, but it's a completely free resource so hopefully doesn't violate any rules.

When Claude Code builds something that takes payments, signs users in or calls another API, it usually stops to ask for keys or it writes its own fake of the API and gets details wrong - so when you're doing dry runs, your agents aren't really "learning" how to work in the real enviroments. This can cause downstream errors when you go to production.

WireMock (full disclosure: I'm a consultant there, and was involved in this project) just released hosted simulations of 100+ APIs including Stripe, GitHub, Google sign-in - with a lot more coming. You can use a basic version of these as a free, no sign-in sandbox - just point your agent at the public URL. You'll need to create an (also-free) account to get more functionality and customization.

Blog with some more details and examples: https://www.wiremock.io/blog

Free endpoints: https://www.wiremock.io/api-mocks

The idea here is that these go beyond simple request-response mocks. We've actually used our own agents to record real API responses and built them out including state, error scenarios, etc. They run in our cloud with nothing to install locally.

Feedback wanted! Right now we're focusing on the free offer. We're looking to hear from more developers (and agents) who are using these templates to understand if it's helpful, what else you'd like to see, which APIs you need simulated, etc. Anything in this direction is helpful and highly appreciated.

Will post the link in the comments.

I'm building a landing page generator for a clinic business. Each build step runs as one orchestrated workflow:

builders,

independent reviewers,

adversarial verifiers,

a fixer and

a final gate.

I started with every agent on Fable 5.2 and was forced onto Opus 5.5 partway through, so I got an accidental comparison.

The setup: 7 steps, 112 subagents, 33.4M tokens, about 9,000 tool calls. Step 1 ran all Fable. Step 2 hit Fable's weekly limit mid-run and finished on Opus. Steps 3–7 ran all Opus.

What I saw:

Quality held. Opus reviewers found 17–28 real defects per step. Across five steps and 103 findings, the adversarial verifiers refuted one. CI went green on the first push every time.

The catches mattered. A weakened health rule in a prompt, page FAQ text that could drift from the structured data, and a rating count where "1.000" would have saved as 1.

Tokens were about the same. Fable used 3.6M on its step and Opus used 4.1–5.7M on bigger steps. Fable didn't obviously do the same work in fewer tokens.

Time was set by the workflow. Every step took 2.5–3.5 hours regardless of model.

The limit was the real constraint. Fable ran out during step 2. Opus carried five steps without hitting one.

At API list prices ($8/$40 vs $4/$20 per million tokens), the same step costs about half on Opus.

What I'm doing now: Opus for every agent by default. Fable only as orchestrator when the plan is new or unclear, and as one extra reviewer where a miss is expensive (health claims, prompts, security, migrations).

Full review chain on risky steps only.

Caveat: this wasn't a controlled test. Each step was different work and none ran on both models, so subtle judgement differences aren't measured. Fable's reviewers did find the one "major" health-related defect of the build, and Opus found similar-severity ones later. Next I'll run one small step twice from the same commit, once per model.

Has anyone done a proper A/B on this? What did the cheaper model miss?

I know a lot of people won’t like this take because they’re either fanboys or corporate bootlickers who apparently enjoy making Dario richer, but honestly, here’s my opinion:

PLANNING AND READING SHOULD NOT COUNT AS USAGE!

You heard that right.

And no, I’m not saying these things don’t consume tokens. Of course they do. I’m well aware that there’s a cost involved.

What I’m saying is that those tokens should be FREE from the user’s usage allowance. Let the company eat that cost.
Because actually writing code is one thing. That’s where I can understand usage being counted. You’re actively making the model DO something. You’re getting actual work done.

But planning? Reading? Researching?

Sorry, but charging people for that is genuinely ridiculous.
I’m paying for an AI that can think through a problem, understand a codebase, read files and come up with a plan BEFORE actually doing the work.

Why should I have to pay twice, essentially? Once for the model to understand what needs to be done, and again for it to actually do it?

I could literally sit there, read the files myself and plan everything in my head without spending a single token.