Token-discipline til Claude Code — benchmarket ærligt

Vi bruger vores dage på at måle andres Claude-skills, og ét mønster dukkede op igen og igen i telemetrien: de sessioner, der blev dyre, blev ikke dyre, fordi Claude skrev lange svar. De blev dyre på grund af det, Claude læste. Hele filer åbnet for at finde én funktion. Filer genlæst lige efter en vellykket redigering, "bare for at tjekke". En JSON med 16.000 poster hevet ind i konteksten, som var det et blogindlæg.

Så byggede vi en skill, der angriber den side af regningen, udgav den under en MIT-licens og gjorde det, vi kræver af enhver skill, vi lister: benchmarkede den mod en baseline med kontrollerede kørsler og offentliggjorde tallene — også dem, der ikke smigrer den.

Skillen hedder token-discipline. Den er gratis: github.com/Skillproofdev/token-discipline.

Hullet i alle de token-skills, vi undersøgte

Før vi skrev en eneste linje, gennemgik vi otte offentliggjorte token-besparende skills og protokoller — fra regelsættet for kortfattet output med 5.800 stjerner, der dominerer nichen, til "nød"-skills, der udløses ved 40 % kontekst, til protokoller, der hævder besparelser på 76-93 % uden nogen mekanisme bag og uden telemetri, vi kunne finde.

Næsten alle deler den samme blinde vinkel: de optimerer output. Fjern optakten, forkort svarene, stop med at gentage planen. Det er reelt nok, men det er den mindre halvdel af regningen. I agent-sessioner — Claude Code, der udfører rigtigt arbejde i et repository — dominerer input: hver filoplæsning, hvert søgeresultat, hver værktøjsoutput lander i konteksten og bliver sendt igen ved hver eneste efterfølgende forespørgsel.

Tre input-side-teknikker optrådte i ingen af de otte som håndhævelige regler:

1. Søg, før du læser. Find frem med grep/glob først, og læs så kun det matchende område. Åbn aldrig en hel fil for at finde noget.
2. Batch uafhængige værktøjskald. Hvis tre oplæsninger ikke afhænger af hinanden, hører de hjemme i én besked. Hver ekstra tur betaler igen for tænke- og fortælletokens mellem kaldene.
3. Stol på tilstand, du allerede har. Efter din egen vellykkede redigering skal du ikke genlæse filen for at bekræfte det — redigeringsværktøjet fejler højlydt, hvis det går galt. Genlæsninger er til eksterne ændringer, ikke dine egne.

Disse tre blev kernen i skillen. Omkring dem ligger seks regler mere: læs udsnit i stedet for filer, forespørg store JSON-filer/logs med python eller jq i stedet for at åbne dem, opsummér og drop lange outputs, deleger bred udforskning til subagenter, hold konteksten cache-venlig (stabilt præfiks urørt — Anthropics eget engineering-blog kalder prompt caching den enkeltfaktor, der har størst betydning for omkostningerne), og, ja, også kortfattet output. Ni regler, hver formuleret som en hård regel med et angivet alternativ, så det aldrig koster korrekthed at følge den.

Sådan benchmarkede vi den

Samme protokol som i vores Skill Bench-serie: samme model, samme prompt, én variabel. Hver opgave blev kørt to gange — én Claude Sonnet-agent uden skill, og én, der læste SKILL.md først og fik besked på at følge den strengt. Skill-agentens totaler inkluderer omkostningen ved at læse selve skillen. Testbedet var vores eget kodebase: en Astro-side med omkring 9.000 linjer templates plus et JSON-datasæt med 16.682 poster — stort nok til, at udisciplineret læsning rent faktisk gør ondt.

Fem opgavepar, valgt til at dække spektret fra trivielt til reelt multi-step:

Opgave	Baseline	Med skill	Δ
Kodebase Q&A — 8 spørgsmål på tværs af subsystemer	88.419	71.636	−19,0 %
Multi-fil-redigering — 4 koordinerede ændringer	68.219	54.637	−19,9 %
Kodesporing — one-shot	53.986	52.850	−2,1 %
Audit-gennemgang — one-shot	44.691	44.705	+0,0 %
Stor-JSON-digest — one-shot	42.726	45.164	+5,7 %

Hvad tallene faktisk siger

På reelt multi-step-arbejde sparer skillen omkring 20 %. Kodebase-Q&A'en med otte spørgsmål er det tætteste, vi kommer på en normal arbejdssession — spor auth-flowet, forklar webhooken, find sorteringslogikken. Baseline-agenten svarede korrekt, men undervejs læste den rundhåndet og verificerede overflødigt. Den disciplinerede agent svarede på de samme spørgsmål, med samme præcision (vi tjekkede hver eneste file:line-reference fra begge), for 16.783 færre tokens.

Multi-fil-redigeringen er det mere interessante resultat. Fire koordinerede ændringer på tværs af fire filer. Baseline-agenten blev færdig og — citeret fra dens egen rapport — "verificerede ved at genlæse de redigerede områder". Den vane alene udgør en femtedel af regningen. Skill-agenten foretog de samme fire ændringer, sprang ceremoni-genlæsningerne over og meldte færdig. Vi diffede begge working trees: redigeringerne var ligeværdige og korrekte i begge. Intet gik tabt ved at stole på, at værktøjet fejler ved fiasko, for det er dét, værktøjer gør.

På trivielle one-shots går det lige op — og det offentliggør vi alligevel. JSON-digest-opgaven kostede faktisk 5,7 % mere med skillen. To grunde, begge lærerige. For det første koster det omkring 1.400 tokens bare at læse skillen, og en opgave, der er færdig efter to værktøjskald, giver den overhead ingen steder at blive afskrevet. For det andet opfører en nutidig model sig allerede godt på nemme opgaver: baseline-agenten kastede ét blik på en JSON med 16.682 poster og greb straks fat i python i stedet for at åbne den. Ingen skill nødvendig. Disciplin betaler sig, hvor udisciplin er mulig — lange sessioner, mange filer, kontekst der hober sig op — ikke hvor der ikke er noget at spilde.

Er dine sessioner mest one-linere, leverer skillen sit eget svar: en 60-token destilleret blok, du sætter ind i CLAUDE.md i stedet for at installere hele skillen. Altid aktiv, koster omtrent lige så meget som denne sætning, og en enkelt undgået helfil-læsning betaler den tilbage mange gange. (Vi byggede en kalkulator til lige præcis denne always-on-skat — matematikken bag trigger-beskrivelser gælder også for regelblokke.)

De ni regler, kort fortalt

Den fulde SKILL.md er ~1.400 tokens og læsbar på én skærm; sådan ser den ud:

1. Søg, før du læser. Grep først; læs så træffet ±30 linjer. At læse mere end ~200 linjer kræver en begrundelse, du kan formulere i én sætning.
2. Læs udsnittet, ikke filen. Offset+limit til alt langt; python/jq til alt struktureret. En stor JSON er en database, ikke et dokument.
3. Batch uafhængige værktøjskald. Én besked, flere kald, når outputs ikke fodrer inputs.
4. Stol på tilstand, du allerede har. Ingen bekræftende genlæsninger efter dine egne redigeringer; kør ikke søgninger igen, hvis resultater allerede står i konteksten.
5. Citér ikke koden tilbage. Referér til file:line. Indsæt kun det, mennesket skal se for at beslutte.
6. Opsummér, og drop så. Efter et langt værktøjsoutput: behold de 2-5 fakta, og anmod aldrig loggen igen.
7. Deleger tung udforskning. Brede gennemgange sendes til en subagent; de tunge oplæsninger dør i dens kontekst, ikke din.
8. Hold konteksten cache-venlig. Stabilt præfiks urørt; tilføj, omskriv ikke; hold øje med cache-TTL'en.
9. Output-disciplin. Svar først, ingen optakt, ingen diff-essays.

Plus et selvaudit-tjekpunkt (tre spørgsmål før enhver stor genlæsning) og en eksplicit gør-ikke-liste, for en token-skill, der får en agent til at springe nødvendig verifikation over, sparer dig ikke noget — den udskyder bare merarbejdet. Kræver en reel fejljagt hele filen, siger reglen: læs den, med begrundelsen angivet.

Hvor det her passer ind i det større omkostningsbillede

Regler som disse er den variable halvdel af din regning. Den faste halvdel — de 30.000-token-optakter fra MCP-servere, oppustede CLAUDE.md-filer og altid-aktive skill-beskrivelser, der bliver sendt igen ved bogstaveligt talt hver eneste forespørgsel — er et andet problem med andre løsninger, og som regel den største gevinst for tunge brugere. Vi skrev det audit op i Sådan skærer du Claude Code-tokenomkostninger ned; de to artikler supplerer hinanden: fix de faste omkostninger én gang, og lad så token-discipline holde de variable omkostninger flade hele sessionen.

Og hvis du undrer dig over, om skills generelt sparer tokens: vores Skill Bench-serie målte fire populære skills og fandt, at de for det meste ikke gør — de koster ekstra tokens og køber i stedet kvalitet og disciplin. token-discipline blev bygget specifikt til at være undtagelsen, og selv da tjener den kun sin plads på multi-step-arbejde. Det er den ærlige grænse, og vi vil hellere trække den selv end lade dig finde den på regningen.

Installation

git clone https://github.com/Skillproofdev/token-discipline ~/.claude/skills/token-discipline

Genstart Claude Code. Den udløses af "reduce token usage", "work token-efficiently", klager over kontekstgrænser og spørgsmål om omkostninger — eller anvend den session-bredt via CLAUDE.md-blokken indeni.

FAQ

Erstatter det her output-verbosity-skills? Nej — den inkluderer deres kerne (regel 9) og tilføjer input-siden, de springer over. Kører du allerede et regelsæt for kortfattet output, overlapper token-discipline det på én regel ud af ni.

Bliver Claude mere sjusket af det? Benchmarken siger nej: multi-fil-redigeringen kom ud ligeværdig og korrekt på begge sider, og skillens gør-ikke-liste beskytter eksplicit den verifikation, der faktisk er nødvendig. Reglerne erstatter ceremonielle oplæsninger, ikke nødvendige.

Hvorfor er selve skillen så kort? Fordi en token-besparende skill, der koster tusindvis af tokens pr. session at indlæse, ville være selvparodi. SKILL.md er ~1.400 tokens, der indlæses efter behov; den altid aktive CLAUDE.md-blok er ~60.

Jeg har et Pro/Max-abonnement, ikke API'en. Betyder det her noget? Ja, i grænsevaluta: de samme tokens, der fakturerer API-brugere, æder af dine forbrugslofter. Tyve procent færre tokens på arbejdssessioner betyder proportionalt mere arbejde, før du rammer loftet.

Var benchmarken plukket, så den passede? De fem opgaver blev designet, før nogen af varianterne kørte, og vi offentliggjorde de to resultater, hvor skillen tabte. Rå telemetri — tokenantal og antal værktøjskald pr. kørsel — findes i repoets README.