Tips from the community

One practitioner ran five real coding tasks at effort high then medium: ~26,000 vs ~14,300 output tokens, a ~45% cut, all five completed with no quality drop visible by eye. The docs confirm the mechanism (thinking bills as output) but publish no measurement.

Hitting the Sonnet family limit leaves Opus as the only model with quota, and the documented fix — switching families with /model — spends your remaining shared weekly allowance at the pricier rate. Check the weekly bar in /usage before you switch, not after.

Versioning ~/.claude in git backs up months of config tuning, but needs an exclusion list in danger order — credentials first, ~/.claude.json and prompt history second, runtime state third — and the popular projects/**/*.jsonl carve-out leaks superseded transcripts.

A PreToolUse hook on the file-editing tools that exits 2 when you are on the repository's default branch turns "Claude quietly edited main" into a message Claude reads and acts on — but it is a nudge, not a boundary, since Bash writes bypass it and a timed-out hook fails open.

`.claudeignore` is not a Claude Code feature — it is inert. The documented ways to keep Claude out of a path are `.gitignore` (already respected by content searches) and `Read` deny rules in `.claude/settings.json`.

Community skill repos say to write the description in third person and name explicit non-triggers. The non-trigger half matches skill-creator's should-trigger/should-not-trigger tuning; the voice rule is undocumented, and Anthropic's own examples break it.

When a task needs real intelligence but also needs to be fast, turn the effort dial down on the bigger model instead of switching to a smaller model at max effort.

On a 1M-context model, deliberately set the auto-compact window to a fraction of the real window — one practitioner runs 400K on 1M and reports the full window degraded quality. The knob is documented; the value is a judgement call nobody has published a measurement for.

Spend concentrates in a few long, uncleared sessions, as the docs say. But the corollary that output tokens are a rounding error is arithmetic error: cache reads bill at ~10% of the input rate, so in the docs' /usage example output is 0.53% of tokens and 14% of the cost.

Before concluding the model changed, check two documented self-inflicted causes: a prompt-cache miss after an idle gap on a large context window, and skills, subagents and MCP servers loading into every session. Both are measurable from inside the product.

Past a dozen skills, description matching picks the wrong one. A UserPromptSubmit hook can score each prompt against a checked-in rules file (keywords, path patterns, intent regexes) and inject a suggestion: the routing is deterministic, the invocation still is not.

Setting subagentPromptCacheTtl to 1h pays the higher cache-write rate on every short helper request to rescue the few that idle past five minutes; the real leak is the parent's cache going cold while it blocks on a child, which promptCacheTtl fixes.

Claude Code writes every session to plaintext JSONL under ~/.claude/projects/, and the community tool ccusage parses those files locally into daily/monthly/session reports and a live 5-hour-block dashboard — no API key, nothing leaving the machine.

"Tests pass" and "training complete" are written by the same turn that wanted to be finished — confirm with a quantity that cannot exist unless the work happened, such as wall-clock elapsed time, GPU utilisation, a row count, or the `duration_ms` a PostToolUse hook receives.

The highest-leverage change is often the project's own tooling rather than the prompt: make commands fail fast and loudly instead of hanging, guard dev-server targets with a pidfile, and tee output to log files the agent can read.

A rule you have had to repeat in CLAUDE.md is a missing test: encode it as a script that exits non-zero and wire it into a hook, because the docs state plainly that CLAUDE.md is advisory while hooks are deterministic.

Don't let an agent finish on "tests pass" — require a test that fails on the pre-fix revision and passes on the fix, so the test provably covers the bug.

Treat build, test and CI output as an interface the agent reads: put the informative error before the noisy generic one, and give the agent a way to fetch CI logs itself.

The documented 200-line CLAUDE.md figure is a ceiling, not a target — practitioners measuring compliance land nearer 40–80 lines, and blog-level corpus analysis puts well-performing agent-instruction files around 300–350 words.

A subagent hands back its summary, not the intermediate reasoning that produced it — so fanning one feature across several subagents throws away the understanding you were paying them to build.

Subagents can spawn their own subagents three layers deep by default, so one prompt can fan out into a tree you never see; cap it with CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH or by withholding the Agent tool per subagent rather than trusting the default.

Author the task dependency graph yourself and hand agents only leaf tasks: the shared task list enforces the dependencies, but from v2.1.233 the Task tools are off by default on Opus 4.8 and Sonnet 5, so a team falls back to the agent-to-agent chatter the report calls a mess.

Subagents are sold as the way to protect context, but heavy users report better results from simply starting a fresh session when the delegated work will write files rather than just read them — delegate the reading, do the writing yourself in a clean context.

Instead of arguing about which model or phrasing to use, run the identical prompt in several isolated checkouts on different models at once and keep the best result — the docs give you the isolation and the per-session model switch, but never suggest using them as a bake-off.

Re-running one prompt file through `claude -p` in a shell loop — one task per iteration, each starting from empty context — is a build strategy, not just a batch trick: the loop's job is to keep the context window small rather than to remember.

Run review subagents in parallel, each on a different axis, then spawn a second round whose only job is to falsify round one's findings — the adversarial second pass is what removes the false positives.

Parallel subagent fan-out can cost more total tokens than doing the same work in one sequential session: each subagent pays for its own uncached system prompt and tool prefix, reloads the CLAUDE.md hierarchy and git status, and re-reads files its siblings already read.

Practitioners report 2-3 concurrent worktree sessions as the working maximum, because the bottleneck is your review capacity, not Claude's throughput.

Git worktrees isolate files only: parallel Claude Code sessions still share one local dev database, one set of localhost ports, and one credential store, so migrations from two branches leave a schema matching neither and no git conflict appears.

Pruning MCP servers to save context is mostly obsolete advice now that tool search defers tool schemas; the live risk is the opposite — Claude writes a script for a job an installed MCP tool already does, because it never saw the tool.

On an unfamiliar or agent-written codebase, have Claude write a linear walkthrough of the whole system to a file before you ask for any change — a durable artefact you can re-read, re-feed, and audit, unlike an explanation that scrolls away with the session.

When a team disagrees about an approach, have Claude build the competing implementations as real PRs in separate worktrees and compare the diffs, instead of arguing it out in a design doc.

Judge a Claude Code rollout by how much of the generated code is still in the tree weeks later, not by the accept rate on the dashboard — which by its own documentation stops counting the moment a suggestion is accepted.

One reported `/context` audit found 51,400 tokens loaded before the first prompt; disabling four third-party plugins and turning off auto memory recovered roughly 10,000 of them, while deleting an individual skill saved about 100.

Keep .claude/settings.json a curated, reviewed allowlist; let settings.local.json collect exploratory grants, then promote the durable ones and delete the rest. Also gitignore the local file in the repo: Claude Code's auto-ignore goes to your global excludes, which no clone gets.

A vendor postmortem reportedly traced the spring 2026 quality drop to three dated product changes rather than to quantization; the durable and documented lesson is that a saved effort level and a stale CLI version are the first two things to check when output quality falls.

A developer measured a server that `/context` reported at 45,018 tokens as costing 15,282 tokens in a single batched `count_tokens` call, and attributed the gap to per-tool summation re-counting the ~313-346-token tool-use preamble once per tool.

A 1,650-session study found CLAUDE.md length, position, nesting and self-contradiction had no measurable effect on adherence; only presence did (0% to 68%). The docs say the opposite, so treat both as unproven and restate the rule in your prompt when editing or late in a session.

Public trackers charting Claude Code "degrading" day to day are underpowered: 50 tasks once a day carries a day-over-day uncertainty of about +/-20 points, wide enough to explain most visible movement and unable to separate a model change from a harness, prompt or load change.

Community hook configs return a top-level block: true and message to stop a tool call, but neither field exists in Claude Code's hook schema — what blocks is exit code 2, decision: "block" with reason, or PreToolUse hookSpecificOutput.permissionDecision: "deny".

Tool search defers MCP tool definitions by default, so unused servers no longer cost you full schemas on every turn — but the docs still tell you to disable servers you are not using, because tool names and server instructions load every session regardless.

"/clear kills your cache" is a bad reason to avoid it: the docs say /clear costs nothing when you want a fresh start, and /compact is the request that reads the whole conversation - though a warm-cache /compact reads its prefix from cache and costs a fraction of that.

Idle MCP servers and an inherited CLAUDE.md do not fill your context before you type: the docs' startup itemization totals about 7,850 tokens, MCP tool names just 120, because tool definitions are deferred by default. Keep running /context; the 33k figure is not yours.

Most of a hand-built slash-command library goes unused - but the two reasons the best-known writeup gives, no argument passing and no way to inject git context, are both fixed now, so check the reasons before inheriting the conclusion.

Subagent tokens are not invisible to Claude Code. Only the prompt cache line is main-conversation-only; /usage attributes usage to subagents by name and the agent panel shows a live per-subagent token count. /context excludes them by design, not as a gap.

Popular community hook configs guard on $CLAUDE_TOOL_INPUT_FILE_PATH, a variable the docs never mention; it expands to empty, the guard never matches, and the hook exits 0 having formatted nothing.

Claude Code's docs do name git reset --hard, git clean -fd and git checkout -- . as blocked by default, but only by the auto mode classifier: in Manual, dontAsk, or under a broad Bash(git *) allow rule nothing stops them, and /rewind cannot recover the work.

Claude Code's worktree sweep skips any worktree holding changed files, untracked files, or unpushed commits, so the timer is not the risk: the exit prompt and git worktree remove --force delete the directory, its branch, and everything uncommitted. Commit before you leave.

Viberank's 1,102 self-submitters put median API-equivalent spend at $1,479/month; Anthropic's docs put the enterprise average at $150-250/developer/month. Neither median decides API vs a $200 seat - only measuring your own spend does.

Community configs treat CLAUDE.md as a fixed instruction budget, not a line budget: every rule added makes every other rule less likely to be obeyed. The reframe is sound, but two rules repeated with it - never put code style in CLAUDE.md, never use /init - contradict the docs.

No /limit-reset command appears anywhere in the Claude Code docs, which document hidden and plan-gated commands openly; the real menu-hidden command at a usage limit is /rate-limit-options: wait and continue, add credits, or upgrade.