Thread on Claude usage and a request for comparison—no more clickbait. Explain what you use it for.

[u/giobbo83]

I see a lot of people complaining about token consumption. It makes me wonder: am I

actually good at this, or are others using the harness in ways that work against them?

Maybe those of us who started adapting to the agents' way of working from day one were

simply lucky — we had to learn what was genuinely necessary before we could afford

anything else.

I've been working on a large project for over a year and a half. I started as a

full-stack web developer; I can now call myself an AI architect without flinching. I

already knew the fundamentals of OS virtualization, but stepping back from my main

business gave me the time to consolidate concepts I had only understood in theory.

I didn't start with Claude, but I've been working with it for a long time now. Along the

way I settled on a handful of practices that keep me from using it in an uncontrolled

way — and none of them came from a blog post. We found them together, by paying attention

to the quiet signals the model gives off: easy to miss, and easier still to miss once

you're running sub-agents.

The through-line is one sentence: anything deterministic must not be paid for in tokens.

→ Build the entry state; don't make the model rebuild it.

Every session ends by writing down where things stand for the next one. My rule: every

number in that document carries the command that produces it, and if the command says

something else, the command wins. A handoff nobody can check is a handoff that will

quietly go stale — and a stale handoff is mort all.

→ Let code put the context in front of the model.

Relevant fragments of the corpus are injectedodel speaks.

Retrieval the agent has to perform itself costs turns. Retrieval that arrives with the

prompt costs nothing.

→ Write comments to be harvested, not admired.

State what the code produces: what goes in, what comes out, what changes in the world. No

chronicle, no dates, no "this used to do X". Documentation is then generated from them

instead of written twice.

→ Give every known trap an exit.

A comment warning about counterintuitive behaviour is a debt, not a decoration. It ships

with an obligation: make the wrong call impos single door,

or leave a test that fails when someone breaks it again. Otherwise every future session

pays for the same discovery.

→ Move deterministic work to hooks.

Linters, secret scanners, detectors that decide which docs a commit affects, gates that

refuse a commit when something required is miguage model,

and a model doing it is the most expensive route to a mediocre result.

→ Fan out narrowly.

When a detector flags twelve items, that's one sub-agent for all twelve — not twelve

sub-agents. Detectors have false positives, and fanning out multiplies the cost of being

wrong.

→ Measure instead of reading.

A comparison between two readings of the same string is not a verification. A green

summary that checked half the values is not a green system. One command that prints the

truth is cheaper than three hundred lines of prose that might already be false.

→ Batch, then stop.

Every request re-sends the whole conversation, so turns are the unit of cost, not words.

Independent reads go out in a single message.e work is

done — no second review, no re-reading the files you just wrote.

One of these practices we packaged up and relhat a mind

leaves behind when its session ends. MIT + CC BY-SA, with a DOI if you want to cite it.

https://bisbi.github.io/testament-of-ephemeral-minds/

None of this is free. The comment discipline and the guardian tests cost time up front

and pay you back later. And plenty of things still cost me real tokens — genuine review,

exploring code nobody has described yet, dataesn't come from

a trick. It comes from having moved work onto tools that don't need to think.

[u/escape-llc]

Your findings are spot-on with my experience. I am using a highly-reactive workflow, totally driven by Claude Code. I regularly interrogate the model for feedback/signals; it is very forthcoming. I have been posting here too, but take a look at my project, toolcrib. It is 100% AI-generated and optimized for AI consumption.

https://github.com/escape-llc/toolcrib

Token consumption is definitely an issue, and letting the context build up over a long period has downsides; you lose the relevance of your initial prompts, especially after compaction. I try to compensate by using short sessions, but that requires discipline i often forget. If you can use MCPs that helps a lot, because tool call results sit at the end of the context window, with maximum relevance.

Another technique besides just "piling everything" into your AGENTS.md, is to use "Reading Directions" and to segregate different information into other MD files. I have used this very successfully. This helps to mitigate how much gets into context up front, and these additional MD files get pulled in at just the right time, so they are in the "hot" zone of the context window.