Besparelser

PRECC sporer estimerede tokenbesparelser fra hver opfangning. Brug precc savings for at se, hvor meget spild PRECC har forhindret.

Hurtig oversigt

$ precc savings
Session Token Savings
=====================
Total estimated savings: <span data-stat="session_tokens_saved">8,741</span> tokens

Breakdown:
  Pillar 1 (cd prepends):         <span data-stat="session_p1_tokens">3,204</span> tokens  (<span data-stat="session_p1_count">6</span> corrections)
  Pillar 4 (skill activations):   <span data-stat="session_p4_tokens">1,560</span> tokens  (<span data-stat="session_p4_count">4</span> activations)
  RTK rewrites:                   <span data-stat="session_rtk_tokens">2,749</span> tokens  (<span data-stat="session_rtk_count">11</span> rewrites)
  Lean-ctx wraps:                 <span data-stat="session_lean_tokens">1,228</span> tokens  (<span data-stat="session_lean_count">2</span> wraps)

Detaljeret oversigt (Pro)

$ precc savings --all
Session Token Savings (Detailed)
================================
Total estimated savings: <span data-stat="session_tokens_saved">8,741</span> tokens

Command-by-command:
  #  Time   Command                          Saving   Source
  1  09:12  cargo build                      534 tk   cd prepend (cargo-wrong-dir)
  2  09:14  cargo test                       534 tk   cd prepend (cargo-wrong-dir)
  3  09:15  git status                       412 tk   cd prepend (git-wrong-dir)
  4  09:18  npm install                      824 tk   cd prepend (npm-wrong-dir)
  5  09:22  find . -name "*.rs"              387 tk   RTK rewrite (output truncation)
  6  09:25  cat src/main.rs                  249 tk   RTK rewrite (lean-ctx wrap)
  7  09:31  cargo clippy                     534 tk   cd prepend (cargo-wrong-dir)
  ...

Pillar Breakdown:
  Pillar 1 (context resolution):   <span data-stat="session_p1_tokens">3,204</span> tokens  <span data-stat="session_p1_pct">36.6</span>%
  Pillar 2 (GDB debugging):            0 tokens   0.0%
  Pillar 3 (mined preventions):        0 tokens   0.0%
  Pillar 4 (automation skills):    <span data-stat="session_p4_tokens">1,560</span> tokens  <span data-stat="session_p4_pct">17.8</span>%
  RTK rewrites:                    <span data-stat="session_rtk_tokens">2,749</span> tokens  <span data-stat="session_rtk_pct">31.5</span>%
  Lean-ctx wraps:                  <span data-stat="session_lean_tokens">1,228</span> tokens  <span data-stat="session_lean_pct">14.1</span>%

Hvordan besparelser estimeres

Hver korrektionstype har en estimeret tokenpris baseret på, hvad der ville være sket uden PRECC:

Korrektionstype	Estimeret besparelse	Begrundelse
cd prepend	~500 tokens	Fejloutput + Claude-ræsonnement + genforsøg
Færdighedsaktivering	~400 tokens	Fejloutput + Claude-ræsonnement + genforsøg
RTK rewrite	~250 tokens	Omstændeligt output som Claude ville have skullet læse
Lean-ctx wrap	~600 tokens	Store filindhold komprimeret
Lært forebyggelse	~500 tokens	Kendt fejlmønster undgået

Disse er konservative estimater. Faktiske besparelser er ofte højere, fordi Claudes ræsonnement om fejl kan være omstændeligt.

Kumulative besparelser

Besparelser bevares på tværs af sessioner i PRECC-databasen. Over tid kan du spore den samlede effekt:

$ precc savings
Session Token Savings
=====================
Total estimated savings: <span data-stat="session_tokens_saved">8,741</span> tokens

Lifetime savings: <span data-stat="total_tokens_saved">142,389</span> tokens across <span data-stat="total_sessions">47</span> sessions

Statuslinje

Efter installation tilføjer PRECC en statusLine-post i ~/.claude/settings.json, så Claude Codes statuslinje viser live sessionsmetrikker:

$0.42 spent | 1.2M in/out | 📊 last cmd: −1.2K | PRECC: 7 fixes | 5.8ms avg | this session: 320 saved over 7 cmds (~$0.05) | lifetime: 8.9K saved over 217 cmds (~$2.85)

Sæt PRECC_LANG for at vise etiketterne på dit sprog — se kapitlet om lokalisering.

Hvert segment:

Segment	Kilde	Betydning	Nulstilles ved sessions-genstart?
`$0.42 spent`	`cost.total_cost_usd`	Akkumulerede sessionsomkostninger rapporteret af Claude Code	Ja
`1.2M in/out`	`total_input_tokens + total_output_tokens`	Ikke-cachede input- + output-tokens i sessionen	Ja
`📊 last cmd: −1.2K`	PRECC-måling af den seneste Bash-kommando	Reel målt besparelse ved at køre originalen igen	Nej (bevares på tværs af sessioner)
`PRECC: 7 fixes`	`metrics.log`	Antal rettelser i denne session — kun antal, ingen falsk token-estimat	Ja
`5.8ms avg`	PRECC-hook-latens p50	Tid PRECC bruger på at behandle hvert værktøjskald	Ja
`bash 18% of total`	`post_observations.log`	Andel sessions-tokens fra Bash-output — forklarer hvorfor PRECC’s besparelser naturligt er en brøkdel af de samlede omkostninger (PRECC optimerer kun Bash-output)	Ja
`this session: 320 saved over 7 cmds (~$0.05)`	`.lifetime_summary.json` − baseline	Reel delta pr. session. Skjult når delta er nul (sessionsstart)	Ja (basislinjen genoptages)
`lifetime: 8.9K saved over 217 cmds (~$2.85)`	`.lifetime_summary.json`	Akkumulerede sparede tokens og genmålte kommandoer siden PRECC blev installeret første gang, plus en estimeret USD-værdi til den aktuelle pris pr. token	Nej

lifetime:-segmentet placeres sidst, så det bliver det første, der afkortes, hvis Claude Codes UI klipper linjen ved højre kant.

Hvorfor omkostninger og tokenantal ikke kan divideres

Det viste 1.2M in/out er ikke den nævner, der producerede $0.42 spent. Claude Codes cost.total_cost_usd beregnes ud fra API’ens fulde token-opdeling — basis-input, output, plus cache-læsninger og cache-oprettelser. De session-omfattende akkumulerede cache-token-tællinger eksponeres ikke i statusline-skemaet, så PRECC kan kun vise den synlige (ikke-cache) del.

I lange sessioner med mange genlæsninger af filer kan cache-læsninger være 10× det synlige tokenantal. Derfor ville sammenkobling som forhold være vildledende — PRECC viser dem i stedet som uafhængige segmenter.

Hvorfor PRECC ikke beregner omkostningerne

Omkostningstallet er autoritativt. PRECC læser cost.total_cost_usd ordret fra den JSON, som Claude Code piper til status-kommandoen via stdin. Det er det samme tal, som Claude Code trækker fra dit abonnements-/forbrugsbudget. Du kan til enhver tid verificere det med den indbyggede /cost-skråstregkommando — begge bør stemme overens.

Hvad driver omkostningerne

For Claude Opus 4.6:

Token type	Standard (≤200k context)	1M context tier
Input	$15 / MTok	$30 / MTok
Output	$75 / MTok	$150 / MTok
Cache write	$18.75 / MTok	$37.50 / MTok
Cache read	$1.50 / MTok	$3 / MTok

De største drivere i lange sessioner er normalt output-tokens (den dyreste pr.-token-type, især på 1M-konteksttrinnet), gentagne cache-læsninger (billige enkeltvis, men ophobes hurtigt over mange runder) og cache-oprettelser (skrives én gang pr. fillæsning til ~1.25× basis-input-satsen). PRECC reducerer omkostningerne for synlige tokens ved at komprimere Bash-output (segmentet 📊 last cmd: viser besparelsen pr. kommando), men kan ikke reducere cache-læsninger af filer, som Claude allerede har indlæst.

Stabile sessions-tællinger

Segmentet “PRECC: N fixes” tæller hændelser siden den persisterede sessions-start, som skrives til ~/.local/share/precc/sessions/<session_id>.start ved den første statusline-opdatering i hver session. Dette gør tællingen monoton — den kan ikke falde midt i sessionen, selv hvis cost.total_duration_ms mangler ved en bestemt opdatering.

Automatisk opdateret livstidssnapshot

lifetime:-segmentet læser ~/.local/share/precc/.lifetime_summary.json, som omskrives ved hver PostToolUse-måling og ved hver precc savings-påkaldelse. this session:-segmentet læser den samme lifetime-fil, men trækker en pr.-session-basislinje fra, som persisteres ved den første opdatering i hver session. Ingen manuel opdatering nødvendig — filerne opdaterer sig selv.

Undertrykke statuslinjen

Hvis du hellere vil beholde din eksisterende statuslinje, så indstil din egen statusLine-kommando i ~/.claude/settings.json. PRECC’s installer vil registrere den brugerdefinerede værdi og lade den være ved efterfølgende opdateringer.

For kun at undertrykke 📊 PRECC-linjen pr. interaktion (i additionalContext), sæt PRECC_QUIET=1 i dit shell-miljø.

PRECC’s three savings mechanisms each have a counterpart in the recent literature. These are related work — the ideas PRECC’s design draws on. Their reported figures are their measurements, not PRECC’s: PRECC only ever quotes numbers measured on your own machine (see “measured, not estimated”, above).

Output/trajectory trimming (PRECC’s diet + bash-output compression) — Reducing Cost of LLM Agents with Trajectory Reduction (AgentDiet), FSE 2026, arXiv:2509.23586. Removes redundant/expired trajectory content post-hoc; reports −39.9–59.7% input tokens. PRECC applies the same idea pre-execution and deterministically (no extra LLM call).
Skills as programs (PRECC’s mined + builtin rewrite skills) — Harnessing LLM Agents with Skill Programs, arXiv:2605.17734. Frames reusable agent skills as executable program functions — the same analogy behind PRECC’s command-rewrite skills (a pattern → a deterministic rewrite).
Context compression (PRECC’s compress + lean-ctx wrapping) — Compress the Context, Keep the Commitments: A Formal Framework for Verifiable LLM Context Compression, arXiv:2605.17304. Recent work on compressing context without losing required information — the property PRECC’s deterministic, cache-stable rewrites aim to preserve.

Keyboard shortcuts

PRECC User Guide