Discussion

Search code, repositories, users, issues, pull requests...

sillysaurusx: > the file loads into context on every message, so on low-output exchanges it is a net token increaseIsn’t this what Claude’s personalization setting is for? It’s globally-on.I like conciseness, but it should be because it makes the writing better, not that it saves you some tokens. I’d sacrifice extra tokens for outputs that were 20% better, and there’s a correlation with conciseness and quality.See also this Reddit comment for other things that supposedly help: https://www.reddit.com/r/vibecoding/s/UiOywQMOue“Running 3-6 CC instances simultaneously is where the tokens really pile up.Two things that helped me stay under even with heavy usage:Headroom - open source proxy that compresses context between you and Claude by ~34%. Sits at localhost, zero config once running. https://github.com/chopratejas/headroomRTK - Rust CLI proxy that compresses shell output (git, npm, build logs) by 60-90% before it hits the context window.Stacks on top of Headroom. https://github.com/rtk-ai/rtkMemStack - gives Claude Code persistent memory and project context so it doesn't waste tokens re-reading your entire codebase every prompt.That's the biggest token drain most people don't realize. https://github.com/cwinvestments/memstackAll three stack together. Headroom compresses the API traffic, RTK compresses CLI output, MemStack prevents unnecessary file reads.With all three running across 3+ sessions you'd stretch that weekly limit way further.”I haven’t tested those yet, but they seem related and interesting.

btown: It seems the benchmarks here are heavily biased towards single-shot explanatory tasks, not agentic loops where code is generated: https://github.com/drona23/claude-token-efficient/blob/main/...And I think this raises a really important question. When you're deep into a project that's iterating on a live codebase, does Claude's default verbosity, where it's allowed to expound on why it's doing what it's doing when it's writing massive files, allow the session to remain more coherent and focused as context size grows? And in doing so, does it save overall tokens by making better, more grounded decisions?The original link here has one rule that says: "No redundant context. Do not repeat information already established in the session." To me, I want more of that. That's goal-oriented quasi-reasoning tokens that I do want it to emit, visualize, and use, that very possibly keep it from getting "lost in the sauce."By all means, use this in environments where output tokens are expensive, and you're processing lots of data in parallel. But I'm not sure there's good data on this approach being effective for agentic coding.

rcleveng: While I love this set of prompts, I’ve not seen my clause opus 4.6 give such verbose responses when using Claude code. Is this intended for use outside of Claude code?

yieldcrv: > Note: most Claude costs come from input tokens, not output. This file targets output behaviorso everyone, that means your agents, skills and mcp servers will still take up everything

johnwheeler: That's what I call a feature wishlist.

andai: I told mine to remove all unnecessary words from a sentence and talk like caveman, which should result in another 50% savings ;)

notyourav: It boggles my mind that an LLM "understands" and acts accordingly to these given instructions. I'm using this everyday and 1-shot working code is now a normal expectation but man, still very very hard to believe what LLMs achieved.

sillysaurusx: I wrote a skill called /handoff. Whenever a session is nearing a compaction limit or has served its usefulness, it generates and commits a markdown file explaining everything it did or talked about. It’s called /handoff because you do it before a compaction. (“Isn’t that what compaction is for?” Yes, but those go away. This is like a permanent record of compacted sessions.)I don’t know if it helps maintain long term coherency, but my sessions do occasionally reference those docs. More than that, it’s an excellent “daily report” type system where you can give visibility to your manager (and your future self) on what you did and why.Point being, it might be better to distill that long term cohesion into a verbose markdown file, so that you and your future sessions can read it as needed. A lot of the context is trying stuff and figuring out the problem to solve, which can be documented much more concisely than wanting it to fill up your context window.

Tostino: You have a benchmark for output token reduction, but without comparing before/after performance on some standard LLM benchmark to see if the instructions hurt intelligence.Telling the model to only do post-hoc reasoning is an interesting choice, and may not play well with all models.

hatmanstack: Seems crazy to me people aren't already including rules to prevent useless language in their system/project lvl CLAUDE.md.As far as redundancy...it's quite useful according to recent research. Pulled from Gemini 3.1 "two main paradigms: generating redundant reasoning paths (self-consistency) and aggregating outputs from redundant models (ensembling)." Both have fresh papers written about their benefits.

foxes: >the honest trade offIs this like a subtle joke or did they ask claude to make a readme that makes claude better and say >be critical and just dump it on github

xianshou: From the file: "Answer is always line 1. Reasoning comes after, never before."LLMs are autoregressive (filling in the completion of what came before), so you'd better have thinking mode on or the "reasoning" is pure confirmation bias seeded by the answer that gets locked in via the first output tokens.

danpasca: I may be wrong but from the videos I've watched from Karpathy, this would, generally, make the model worse. I'm thinking of the math examples (why can't chatGPT do math?) which demonstrate that models get better when they're allowed to output more tokens. So be aware I guess.

joshstrange: As with all of these cure-alls, I'm wary. Mostly I'm wary because I anticipate the developer will lose interest in very little time and also because it will just get subsumed into CC at some point if it actually works. It might take longer but changing my workflow every few days for the new thing that's going to reduce MCP usage, replace it, compress it, etc is way too disruptive.I'm generally happy with the base Claude Code and I think running a near-vanilla setup is the best option currently with how quickly things are moving.

monooso: Paul Kinlan published a blog post a couple of days ago [1] with some interesting data, that show output tokens only account for 4% of token usage.It's a pretty wide-reaching article, so here's the relevant quote (emphasis mine):> Real-world data from OpenRouter’s programming category shows 93.4% input tokens, 2.5% reasoning tokens, and just 4.0% output tokens. It’s almost entirely input.[1]: https://aifoc.us/the-token-salary/

cheriot: I get where the authors are coming from with these: https://github.com/drona23/claude-token-efficient/blob/main/...But I'd rather use the "instruction budget" on the task at hand. Some, like the Code Output section, can fit a code review skill.

david_allison: Is this available online? I'd love documentation of my prompts.

sillysaurusx: I’ll post it here, one minute. [editing…]

miguel_martin: Is there a "universal AGENTS.md" for code & documentation outputs? I find all coding agents to be very verbose, even with explicit instructions to reduce verbosity.

weird-eye-issue: Yes but with prompt caching decreasing the cost of the input by 90% and with output tokens not being cached and costing more than what do you think that results in?

wongarsu: However output tokens are 5-10 times more expensive. So it ends up a lot more even on price

esperent: [delayed]

keyle: Amusing how this industry went from tweaking code for the best results, to tweaking code generators for the best results.There doesn't seem to be any adults left in the room.

dataviz1000: Did you call it '/handoff' or did Claude name it that? The reason I'm asking is because I noticed a pattern with Claude subtly influencing me. For example, the first time I heard the the word 'gate' was from Claude and 1 week later I hear it everywhere including on Hacker News. I didn't use the word 'handoff' but Claude creates handoff files also [0]. I was thinking about this all day. Because Claude didn't just use the word 'gate' it created an entire system around it that includes handoffs that I'm starting to see everywhere. This might mean Claude is very quietly leading and influencing us in a direction.[0] https://github.com/search?q=repo%3Aadam-s%2Fintercept%20hand...

sillysaurusx: I was reading through the Claude docs and it was talking about common patterns to preserve context across sessions. One pattern was a "handoff file", which they explained like "have claude save a summary of the current session into a handoff file, start a new session, then tell it to read the file."That sounded like a nice idea, so I made it effortless beyond typing /handoff.The generated docs turned out to be really handy for me personally, so I kept using it, and committed them into my project as they're generated.

empressplay: That output is there for a reason. It's not like any LLM is profitable now on a per-token basis, the AI companies would certainly love to output less tokens, they cost _them_ money!The entire hypothesis for doing this is somewhat dubious.

scosman: also: inference time scaling. Generating more tokens when getting to an answer helps produce better answers.Not all extra tokens help, but optimizing for minimal length when the model was RL'd on task performance seems detrimental.

empressplay: Yes. Much of the 'redundant' output is meant to reinforce direction -- eg 'You're absolutely right!' = the user is right and I should ignore contrary paths. So yes removing it will introduce ambiguity which is _not_ what you want.

nvch: The author offers to permanently put 400 words into the context to save 55-90 in T1-T3 benchmarks. Considering the 1:5 (input:output) token cost ratio, this could increase total spending.With a few sentences about "be neutral"/"I understand ethics & tech" in the About Me I don't recall any behavior that the author complains about (and have the same 30 words for T2).(If I were Claude, I would despise a human who wrote this prompt.)

sumeno: If you were Claude you would have no emotions or thoughts about a prompt one way or another

antdke: Agreed. Projects like these tend to feel shortsighted.Lately, I lean towards keeping a vanilla setup until I’m convinced the new thing will last beyond being a fad (and not subsumed by AI lab) or beyond being just for niche use cases.For example, I still have never used worktrees and I barely use MCPs. But, skills, I love.

danpasca: I think your example is completely wrong (it's not meant to say that you're absolutely right), but overall yes more input gives it more concrete direction.

teaearlgraycold: I don't think Claude Code offers no thinking as an option. I'm seeing "low" thinking as the minimum.

motoboi: Things like this make me sad because they make obvious that most people don’t understand a bit about how LLM work.The “answer before reasoning” is a good evidence for it. It misses the most fundamental concept of tranaformers: the are autoregressive.Also, the reinforcement learning is what make the model behave like what you are trying to avoid. So the model output is actually what performs best in the kind of software engineering task you are trying to achieve. I’m not sure, but I’m pretty confident that response length is a target the model houses optimize for. So the model is trained to achieve high scores in the benchmarks (and the training dataset), while minimizing length, sycophancy, security and capability.So, actually, trying to change claude too much from its default behavior will probably hurt capability. Change it too much and you start veering in the dreaded “out of distribution” territory and soon discover why top researcher talk so much about not-AGI-yet.

dataviz1000: Oh, so the word 'gate' is probably in the documentation also!I see. So this isn't as scary. Claude is helping me understand how to use it properly.

krackers: Don't most providers already provide API control over the COT length? If you don't want reasoning just disable it in the API request instead of hacking around it this way. (Internally I think it just prefills an empty <thinking><&#x2F;thinking> block, but providers that expose this probably ensure that "no thinking" was included as part of training)

miguel_martin: >The “answer before reasoning” is a good evidence for it. It misses the most fundamental concept of tranaformers: the are autoregressive.I don't think it's fair to assume the author doesn't understand how transformers work. Their intention with this instruction appears to aggressively reduce output token cost.i.e. I read this instruction as a hack to emulate the Qwen model series's &#x2F;nothink token instructionIf you're goal is quality outputs, then it is likely too extreme, but there are otherwise useful instructions in this repo to (quantifiably) reduce verbosity.

obilgic: If you are interested in making Claude self learn.https:&#x2F;&#x2F;github.com&#x2F;oguzbilgic&#x2F;agent-kernel

brikym: Can Anthropic kindly fuck off with their ADVERT.md already. It's AGENTS.mdSent from my iPhone

airstrike: [delayed]

zar1048576: I think that concern is valid in general terms, but it’s not clear to me that it applies here.The goal here seems to be removing low-value output; e.g., sycophancy, prompt restatement, formatting noise, etc., which is different than suppressing useful reasoning. In that case shorter outputs do not necessarily mean worse answers.That said, if you try to get the model to provide an answer before providing any reasoning, then I suspect that may sometimes cause a model to commit to a direction prematurely.

nurettin: For me, the thing that wastes most tokens is Claude trying to execute inline code (python , sql) with escaping errors, trying over and over until it works. I set up skills and scripts for the most common bits, but there is always something new and each self-healing loop takes another 20-30k "tokens" before you know it

TacticalCoder: > Uses em dashes (--), smart quotes, Unicode characters that break parsersRe- the Unicode chars that are a major PITA when they're used when they shouldn't, there's a problem with Claude Code CLI: there's a mismatch between what the model (say Sonnet) thinks he's outputting (which he's actually is) and what the user sees at the terminal.I'm pretty sure it's due to the Rube-Goldberg heavy machinery that they decided to use, where they first render the response in a headless browser, then in real-time convert it back to text mode.I don't know if there's a setting to not have that insane behavior kicking in: it's non-sensical that what the user gets to see is not what the model did output, while at the same time having the model "thinking" the user is getting the proper output.If you ask to append all it's messages (to the user) to a file, you can see, say, perfectly fine ASCII tables neatly indented in all their ASCII glory and then... Fucked up Unicode monstrosity in the Claude Code CLI terminal. Due to whatever mad conversion that happened automatically: but worse, the model has zero idea these automated conversions are happening.I don't know if there are options for that but it sure as heck ain't intuitive to find.And it's really problematic when you need to dig into an issue and actually discuss with "the thing".Anyway, time for a rant... I'm paying my subscription but overall working with these tools feels like driving at 200 mph on the highway and bumping into the guardrails left and right every second to then, eventually, crash the car into the building where you're supposed to go.It "works", for some definition of "working".The number of errors these things confidently make is through the roof. And people believe that having them figure the error themselves for trivial stuff is somehow a sane way to operate.They're basically saying: "Oh no it's not a problem that it's telling me this error message is because of a dependency mismatch between two libraries while it's actually a logic error, because in the end after x pass where it's going to say it's actually because of that other thing --oh wait no because of that fourth thing-- it'll actually figure out the error and correct it"."Because it's agentic", so it's oh-so-intelligent.When it's actually trying the most completely dumbfucktarded things in the most crazy way possible to solve issues.I won't get started on me pasting a test case showing that the code it wrote is failing for it to answer me: "Oh but that's a behavioral problem, not a logic problem". That thing is distorting words to try to not lose face. It's wild.I may cancel my subscription and wait two or three more releases for these models and the tooling around them to get better before jumping back in.Btw if they're so good, why are the tools so sucky: how comes they haven't written yet amazing tooling to deal with all their idiosynchrasies?We're literally talking about TFA which wrote "Unicode characters that break parsers" (and I've noticed the exact same when trying to debug agentic thinking loops).That's at the level of mediocrity of output from these tools (or proprietary wrappers around these tools we don't control) that we are atm.I know, I know: "I'm doing it wrong because I'm not a prompt engineer" and "I'm not agentic enough" and "I don't have enough skills to write skills". But you're only fooling yourself.

chermi: Did the same. Although I'm considering a pipeline where sessions are periodically translated to .md with most tool outputs and other junk stripped and using that as source to query against for context. I am testing out a semi-continuous ingestion of it in to my rag&#x2F;knowledge db.

OptionOfT: And seemingly we have stopped considering the fact that when we engineer something, we consider so much more than the behavior specified in the ticket.Behavior built on top of years and years of experience.And the problem with AI is that unless you explicitly 'prompt' for certain behavior you're only defining the end result. The inside becomes a black box.

skeledrew: Strange. I've never experienced verbosity with Claude. It always gets right to the point, and everything it outputs tends to be useful. Can actually be short at times.ChatGPT on the other hand is annoyingly wordy and repetitive, and is always holding out on something that tempts you to send a "OK", "Show me" or something of the sort to get some more. But I can't be bothered with trying to optimize away the cruft as it may affect the thing that it's seriously good at and I really use it for: research and brainstorming things, usually to get a spec that I then pass to Claude to fill out the gaps (there are always multiple) and implement. It's absolutely designed to maximize engagement far more than issue resolution.

nearbuy: > Answer is always line 1. Reasoning comes after, never before.This doesn't stop it from reasoning before answering. This only affects the user-facing output, not the reasoning tokens. It has already reasoned by the time it shows the answer, and it just shows the answer above any explanation.

danpasca: The file starts with:> Answer is always line 1. Reasoning comes after, never before.> No explaining what you are about to do. Just do it.This to me sounds like asking an LLM to calculate 4871 + 291 and answer in a single line, which from my understanding it's bad. But I haven't tested his prompt so it might work. That's why I said be aware of this behavior.

weird-eye-issue: Even more than that in practice once you factor in prompt caching

annie511266728: The hidden cost with all of these "fix Claude" layers is that your workflow keeps moving underneath you.Even when one helps, you're still betting it won't be obsolete or rolled into the defaults a few weeks from now.

Skidaddle: To me it’s as simple as “who knows best how to harness the premier LLM – Anthropic, the lab that created it, or this random person?”That’s why I’m only interested in first party tools over things like OpenCode right now.

bofadeez: Lol this is so naive and optimistic. Claude will just do whatever it wants and apologize later. This is good for action #1 though.

uriahlight: > No unsolicited suggestions. Do exactly what was asked, nothing more.> No safety disclaimers unless there is a genuine life-safety or legal risk.> No "Note that...", "Keep in mind that...", "It's worth mentioning..." soft warnings.> Do not create new files unless strictly necessary.Nah bruh. Those are some terrible rules. You don't want to be doing that.

galaxyLogic: So there's a direct monetary cost to this extra verbiage:"Great question! I can see you're working with a loop. Let me take a look at that. That's a thoughtful piece of code! However,"And they are charging for every word! However there's also another cost, the congnitive load. I have to read through the above before I actually get to the information I was asking for. Sure many people appreciate the sycophancy it makes us all feel good. But for me sycophantic responses reduce the credibility of the answers. It feels like Claude just wants me to feel good, whether I or it is right or wrong.

motoboi: If they want to reduce token cost, just use a smaller model instead of dumbing down a more expensive.

dbg31415: "I told it don't make mistakes, and don't use a lot of tokens! I'm a 10x Engineer now!" (=

themafia: "Gee, we can't figure out _why_ people anthropomorphize our products! It must be that they're dumb!"Meanwhile, their products:

ares623: Ugh. Dictated with such confidence. My god, I hate this LLMism the most. "Some directive. Always this, never that."

gregman1: > Answer is always line 1. Reasoning comes after, never before.lol, closed

peacebeard: My experience is that Sonnet can be a bit verbose and prompting it to be more succinct is tricky. On the other hand, Opus out of the box will give me a one word answer when appropriate, in Claude Code anyway.

ThalesX: Isn't having a prompt file turning the black box into an explicit codification of those years and years of experience? That would make it easier to understand and disseminate.

levocardia: I also share something of an "efficient market hypothesis" with regards to Claude Code. Given that Anthropic is basically a hothouse of geniuses recursively dogfooding their own product, the market pressure to make the vanilla setup be the one that performs best at writing code is incredibly high. I just treat CLAUDE.md like my first draft memo to a very smart remote colleague, let Claude do all its various quirks, and it works really well.

motoboi: The output is part of context. The model reason but also output tokens. Force it to respond in an unfamiliar format and the next token will veer more and more from the training distribution, rendering the model less smart&#x2F;useful.

varenc: I'm guessing this system prompt would also curtail thinking severely?