# Claude Code-grenser i 2026: 8 regler for å unngå å bruke opp tokens
> Claude Code Pro- og Max-grenser i 2026 og 8 regler for å spare tokens: /compact, Plan Mode, en innholdstett CLAUDE.md, Skills, modellvalg og 90 % cachebesparelse.
Source: https://ailoot.ai/blog/nb/claude-code-token-limits-saving/
Canonical: https://ailoot.ai/blog/nb/claude-code-token-limits-saving/
Language: nb
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-129
Revision: sha256-5915ddd1475fab56d9192105a77e716a29bff68a27deede37433ef23ae89d9b1
Hovedpoeng
Claude Code-grensene tar ikke slutt på grunn av abonnementet, men på grunn av arbeidsmetoden. Slik forfatteren beskriver sin erfaring, fylles konteksten opp før lunsj og tokens brukes opp dobbelt så fort hvis alle dagens oppgaver legges i én chat. Hvis du starter en ny samtale for hver oppgave, bruker en innholdstett CLAUDE.md, holder planen i en egen fil og laster inn Skills ved behov, holder Max-abonnementet til 100 dollar til en hel arbeidsdag med vibe-koding. I denne artikkelen går jeg gjennom faktiske planer, 8 regler for å spare tokens og automatiseringskunngjøringen fra 15. juni 2026 som ble satt på pause.
Ailoot-referansedokumentasjon: [ailoot.ai/docs/](https://ailoot.ai/docs/).
## Hvordan fungerer Claude Code-grensene i 2026, og hvorfor når du dem?
Hovedpoeng
Pro til 20 dollar gir deg omtrent 45 meldinger i et 5-timers vindu, Max 5x til 100 dollar gir deg fem ganger så mange, og Max 20x til 200 dollar gir deg tjue ganger så mange. Grensene telles separat for 5-timersvinduet og ukentlig. Anthropic doblet 5-timerskvotene 6. mai 2026. Med de samme grensene kan én person jobbe i 8 timer mens en annen når grensen før lunsj – hele forskjellen ligger i arbeidsmetoden.
Per 20. mai 2026 fungerer betalte Claude Code-abonnementer slik:
| Abonnement | Pris | 5-timersvindu (omtrent) | Særtrekk |
|----|----|----|----|
| Pro | 20 dollar / måned | ~45 meldinger eller 44K tokens | Grunnleggende, for å prøve det ut |
| Max 5x | 100 dollar / måned | ~225 meldinger | Prioritert tilgang |
| Max 20x | 200 dollar / måned | ~900 meldinger | Tidlig tilgang til nye modeller |
| Team Premium | 100 dollar / sete (årlig) | Max 5x per sete | SSO, delte prosjekter |
| Enterprise | kontrakt | tilpasset + etterlevelse | RBAC, datalagringssted |
Tallene er fra Anthropics offisielle side. I tillegg til 5-timersvinduet finnes det også en ukentlig grense, som begynner å merkes for storbrukere rundt fredag.
### Hva var doblingen 6. mai?
På konferansen **Code with Claude SF** 6. mai 2026 kunngjorde Anthropic [en avtale med SpaceX Colossus 1](https://www.anthropic.com/news/higher-limits-spacex): 220 000 NVIDIA-grafikkort, 300 MW kapasitet, på nett innen én måned. Umiddelbart:
- **5-timersgrensene ble doblet** for alle betalte abonnementer.
- **Begrensningen i daglige rushtimer ble fjernet**; den hadde tidligere redusert kvotene i rushtiden.
- **For API-et:** maks. antall inndatatokens per minutt for Opus økte fra 30K til 500K (+1500 %), og maks. antall utdatatokens økte fra 8K til 80K.
En annen midlertidig kampanje gjelder fra 13. mai til 13. juli: **+50 % på ukesgrensene** for Pro / Max / Team. Etter 13. juli går ukeskvotene tilbake til de tidligere nivåene.
### Hvor mye bruker en vibe-koder egentlig?
Anthropic oppgir referansetall i sin [offisielle dokumentasjon](https://code.claude.com/docs/en/costs):
- Utviklere bruker i gjennomsnitt **13 dollar / dag**, **150–250 dollar / måned**.
- 90 % av brukerne holder seg under 30 dollar / dag.
- Agentteam i Plan Mode bruker omtrent **7 ganger flere tokens** enn en vanlig økt.
Størrelsen på kontekstvinduet avhenger av modellen. Ifølge [Anthropics dokumentasjon](https://code.claude.com/docs/en/model-config#extended-context) har Opus 4.7 og nyere, Sonnet 5 og Fable-modellene per september 2026 et vindu på **1M tokens** på alle abonnementer, inkludert Pro, og automatisk komprimering (auto-compact) utløses som standard ved rundt 967K. Opus 4.6 og Sonnet 4.6 uten utvidet kontekst har et vindu på **200K**, og komprimering utløses ved 200K-grensen. Du kan angi din egen terskel med kommandoen `/autocompact`, for eksempel `/autocompact 500k`. Når du stapper en halv dags arbeid inn i én chat, eser konteksten ut, Claude mister tråden, begynner å lese de samme filene på nytt, og tokens brukes opp 1,5 til 2 ganger raskere.
Slik forfatteren beskriver sin erfaring, holder abonnementet til 200 dollar takket være de 8 reglene nedenfor. Uten dem går selv Max 20x tom før lunsj.
## Regel 1. Hvorfor sparer «én oppgave – én samtale» flest tokens?
Hovedpoeng
Den aller første regelen for å spare tokens: Ikke dump tre av dagens oppgaver inn i én chat. Hvert nytt tema får et nytt vindu. Når konteksten er full av en halv dags samtale, leser Claude om igjen det den allerede vet, og bruker tokens på å holde på irrelevant informasjon. Én chat = én oppgave gir både Claude og deg blanke ark.
Regelen handler ikke om å «åpne 5 chatter parallelt», men spesifikt om å «ikke skrape ut den forrige chatten for å bruke den til neste oppgave».
Slik den beskrevne tilnærmingen fungerer, ser det slik ut. Med hver melding ser Claude ikke bare den nye forespørselen, men også hele den foregående samtalen. Hvis du diskuterte en landingsside om morgenen, gikk videre til en e-postkampanje og deretter ba den rette en instruksjon til en workshop, blir hele historikken tatt med i konteksten ved den tredje forespørselen. Tokens brukes på å «huske landingssiden», selv om du allerede har glemt den.
### Hvorfor fungerer det å «rydde hodet»?
Lukk chatten så snart oppgaven er ferdig. Det handler ikke engang om tokens – det er en måte å frigjøre oppmerksomhet på.
Hvis oppgaven faktisk er ferdig, ikke behold chatten «i tilfelle jeg kommer tilbake til den». Åpne en ny. Du kan finne den gamle med `claude --resume` eller `/resume`, ved hjelp av en hvilken som helst indikator (grenens navn, PR-ID, tagg).
### Hva bør du gjøre hvis en oppgave strekker seg over to dager?
Hvis oppgaven virkelig må fortsette, ikke la chatten «henge». Før du lukker den, ber du Claude skrive en ledetekst til en chat ved siden av (se regel 7). Dette komprimerer 50K tokens med historikk til en ledetekst på 500 tokens – og i morgen kan den nye chatten fortsette med konteksten uten at alt må skrives inn på nytt.
## Regel 2: Hold CLAUDE.md på 200 linjer, ikke 500
Hovedpoeng
CLAUDE.md lastes inn ved starten av hver økt og blir værende i konteksten til økten er slutt. Hvis den har 500 linjer, betaler du for disse 500 linjene i tokens i hver økt. Anthropic anbefaler offisielt å holde seg innenfor 200.
[CLAUDE.md er den første filen Claude leser](https://ailoot.ai/blog/nb/claude-md-template/) når en ny økt starter. Denne delen handler spesielt om å spare tokens.
### Hvor mange linjer er passe?
| Tilnærming | Linjer | Hvor det fungerer |
|----|----|----|
| Anthropics offisielle anbefaling | opptil 200 | Gjennomsnittlig kodebase |
| Automatisk generert med `/init` | varierer | Forverrer oftere resultatene enn det forbedrer dem |
### Hvorfor gjør en lang CLAUDE.md agenten dummere?
Forklaringen er enkel: `/init` beskriver repositoriet «tilbake til modellen» og legger til informasjon i konteksten som modellen allerede kjenner eller selv kan finne ved et raskt blikk på strukturen. Denne dupliseringen bruker tokens og gjør fokuset mindre tydelig.
### Tetthetsregelen: hvert ord endrer atferd
Hvis jeg kan fjerne en linje fra CLAUDE.md uten at Claudes atferd endres, er linjen unødvendig. Bruk dette som en test:
1. Åpne CLAUDE.md og gå gjennom hvert avsnitt.
2. Spør deg selv: «Hvis jeg fjerner dette, begynner Claude å gjøre feil?»
3. Hvis ikke, slett det eller flytt det til en [Skill](https://ailoot.ai/blog/nb/claude-code-skills-library/).
Alle regler som bare gjelder i bestemte situasjoner, legges i Skills (`.claude/skills//SKILL.md`). CLAUDE.md er bare for det som trengs hele tiden.
## Regel 3. Hvorfor bør Claude Code-planen ligge i en egen fil?
Hovedpoeng
Planen er en skrivebeskyttet fase: Claude skriver ikke kode, den undersøker og foreslår bare en tilnærming. Etter godkjenning velger jeg implementeringens tillatelsesmodus uttrykkelig. Jeg har planen i en egen fil i mappen `plans/` og gir chatten tilgang til den som kontekst for implementeringen. Dette sparer det dyreste av alt – omarbeiding når den opprinnelige retningen var feil.
Plan Mode er en Claude Code-modus som slås på med `Shift+Tab`. I denne modusen utforsker Claude kodebasen, leser filer og stiller spørsmål før implementering. Hold repoendringer atskilt i arbeidsflyten nedenfor: Gjennomgå planforslaget og lagre det manuelt i prosjektets `plans/`-mappe, eller gå uttrykkelig ut av Plan Mode og godkjenn skriving av planfilen før du starter en ny chat.
### Hvorfor er en plan i en fil bedre enn en plan i Claudes hode?
Jeg har en mappe `plans/` i hvert prosjekt. Når jeg starter en oppgave:
1. Ber jeg Claude i Plan Mode undersøke og foreslå en tilnærming.
2. Gjennomgår jeg planen og lagrer teksten selv i `plans/YYYY-MM-DD-task-name.md`. Alternativt går jeg ut av Plan Mode og godkjenner at Claude skriver filen. Jeg kontrollerer det lagrede innholdet før chatten lukkes.
3. Lukker jeg chatten.
4. Sier jeg i en ny chat: «les `plans/YYYY-MM-DD-...md` og implementer fase 1».
Dette får jeg:
- **Planen er fastlagt** – Claude «glemmer» ikke hva vi bestemte for en time siden.
- **Jeg kan redigere planen for hånd** – jeg ser 5 trinn, skjønner at trinn 3 er unødvendig, sletter det og går videre.
- **Planen overlever en omstart** – jeg kommer tilbake i morgen, åpner filen og fortsetter.
- **Jeg kan overlate den til agenter etter tur** – én chat skriver planen, en annen implementerer den, og en tredje går gjennom den.
### Plan Mode ødelegger ikke cachen
En viktig detalj: Plan Mode ugyldiggjør bare samtalecachen (meldinger), mens systemledeteksten og prosjektkonteksten (CLAUDE.md) forblir varme. Det betyr at det nesten ikke koster tokens å bytte til Plan Mode og tilbake – i motsetning til å bytte modell med `/model`, som bryter cachen for 90 % av inndataene og tvinger fram ny beregning av hele prefikset.
Kontekstarbeid innebærer også å oppbevare planen et sted der den varer, ikke i en chat som dør om 5 timer.
## Regel 4. Skills lastes inn ved en utløser, ikke ved starten av økten
Hovedpoeng
[Claude Code Skills](https://ailoot.ai/blog/nb/claude-code-skills-library/) er mapper med en SKILL.md-fil som Claude bare ser når de er relevante for oppgaven. CLAUDE.md lastes alltid inn; en Skill lastes bare inn når beskrivelsen samsvarer med forespørselen din. Derfor kan et prosjekt inneholde dusinvis av Skills uten å belaste konteksten – oppstartsledeteksten inneholder bare et lite topptekstfelt med navnet og beskrivelsen til hver Skill.
Skills bruker innlasting på tre nivåer:
1. **Metadata alltid** – ved starten av økten ser Claude bare `name` og `description` for hver Skill. Budsjett: ~100 tokens per Skill.
2. **Instruksjoner ved utløser** – når brukeren sier noe relevant, laster Claude inn innholdet i SKILL.md. Budsjett: opptil 5000 tokens.
3. **Ressurser på forespørsel** – medfølgende filer (eksempler, maler) hentes bare når modellen selv trenger dem.
Hele instruksjonene lastes inn bare når Claude avgjør at en Skill er relevant (mindre enn 5k tokens). Hjelpeskript og filer lastes bare inn når det er uttrykkelig nødvendig. Det betyr at du kan ha dusinvis av Skills installert uten at de påvirker ytelsen på oppgaver som ikke er relatert til dem.
— Anthropic Skills-dokumentasjon, https://code.claude.com/docs/en/skills
### Hvordan endrer dette tokenøkonomien?
I eksemplet som beskrives, lå reglene for å skrive opplæringsinstruksjoner, reglene for utsendelser og reglene for kodegjennomgang i CLAUDE.md. Filen vokste til 500 linjer, og ved starten av hver økt betalte jeg for alle 500 linjene, selv om samtalen handlet om en landingsside.
I dette eksemplet inneholder CLAUDE.md 200 linjer med navigasjon og grunnleggende prinsipper. De fire regelsettene ligger i Skills:
```
.claude/skills/
├── write-tutorial/SKILL.md # utløser: «skriv en veiledning»
├── deploy-checklist/SKILL.md # utløser: «sjekk før publisering»
├── send-broadcast/SKILL.md # utløser: «send en utsendelse»
└── debug-payment-webhook/SKILL.md # utløser: «sjekk betalingen»
```
Ved oppstart ser Claude bare overskriftene – 400 tokens. Når jeg sier «skriv en veiledning», laster den inn den tilsvarende SKILL.md og følger den. Når jeg sier «send en utsendelse», laster den inn en annen.
Et sitat fra reglene for å skrive Skills i [Anthropics offisielle dokumentasjon](https://code.claude.com/docs/en/skills):
Når en Skill først er lastet inn, blir innholdet værende i konteksten i de påfølgende turene, så hver linje er en gjentakende kostnad i tokens. Skriv hva man skal gjøre, ikke en oppsummering av hvordan og hvorfor.
— Anthropic Skills-dokumentasjon, https://code.claude.com/docs/en/skills
### Når bør du være skeptisk til en Skill og la være å installere den?
Skills er kjørbare instruksjoner med direkte tilgang til filene og API-nøklene dine. Før jeg installerer andres samling, åpner jeg hver `SKILL.md` og leser den selv. Hvis det finnes `bash:`-blokker med lenker til eksterne URL-er, er det et varselsignal; da installerer jeg den ikke.
## Regel 5. Når bør du gi en oppgave til en underagent i stedet for hovedøkten?
Hovedpoeng
En underagent er en egen Claude-økt med sitt eget kontekstvindu, sin egen systemledetekst og sitt eget sett med verktøy. Bare sluttresultatet sendes tilbake til hovedøkten – hele «støyen» fra å lese 50 filer og analysere 10K linjer med logger blir værende i underagentens kontekst. Dette kan spare opptil 90 % av tokens for oppgavetyper der hovedøkten ellers ville blitt overfylt av utforskende søk.
Fra [den offisielle dokumentasjonen](https://code.claude.com/docs/en/costs):
Overlat omfattende operasjoner til underagenter, slik at de omfattende resultatene blir værende i konteksten deres, og bare resultatet sendes tilbake til hovedsamtalen.
— Claude Code-dokumentasjon, https://code.claude.com/docs/en/costs
### Hvilke oppgaver kan overlates til underagenter?
- **Søk i en stor kodebase.** En underagent leser 30 filer og svarer «den relevante funksjonen ligger i `src/lib/payment/cloudpayments.ts:142`». Jeg ser ikke innholdet i 30 filer i hovedkonteksten.
- **Kjøre tester og analysere logger.** En underagent kjører `npm test`, fanger opp 200 linjer med resultat og svarer «3 tester feilet i X, Y, Z av denne grunnen».
- **Refaktorering på tvers av flere filer.** Én underagent per fil – parallelt.
- **Kontrollere lenker i en veiledning.** En underagent besøker 30 URL-er via WebFetch og svarer «5 lenker gir 404».
I mai 2026 [kunngjorde Anthropic offisielt Multi-Agent Orchestration](https://claude.com/blog/code-w-claude-sf-2026-sf) som en førsteklasses funksjon. Tidligere kunne underagenter bare startes programmatisk via SDK-et; nå kan de startes direkte i Claude Code med skråstrekkommandoer.
### Når underagenter ikke fungerer så godt
Derfor lar jeg aldri underagenter jobbe uten tilsyn i en halv dag. Regelen er: Jo mer du delegerer parallelt, desto oftere bør du kontrollere resultatene underveis. På store oppgaver aktiverer jeg Plan Mode separat for hver underagent.
## Regel 6. Hvordan velger du Claude-modell (Opus / Sonnet / Haiku) til en oppgave?
Hovedpoeng
Opus 4.7, Sonnet 4.6 og Haiku 4.5 har omtrent 5–15 ganger forskjell i pris. Opus koster ti ganger mer enn Haiku, men er ikke ti ganger smartere på 90 % av oppgavene. Regelen er derfor enkel: Bruk Opus bare når du trenger en grundig arkitektonisk beslutning eller en kompleks refaktorering. Sonnet er standardvalget for vanlig arbeid. Haiku er for enkle søk, klassifiseringer og oppslag.
API-priser (per million tokens):
| Modell | Inndata | Utdata | Bufrede inndata |
|------------|-------|--------|--------------|
| Opus 4.7 | 5 dollar | 25 dollar | 0,50 dollar |
| Sonnet 4.6 | 3 dollar | 15 dollar | 0,30 dollar |
| Haiku 4.5 | 1 dollar | 5 dollar | 0,10 dollar |
Kilde: [Anthropics offisielle side](https://platform.claude.com/docs/en/about-claude/pricing). Prisene vises ikke på et abonnement, men forholdet er det samme. Opus 4.7 har et forbehold: sammenlignet med Opus 4.6 kan den nye tokenizeren bruke opptil **+35 % flere tokens** for den samme teksten. Prisen per token har ikke økt, men den reelle kostnaden per forespørsel har gjort det. Hvis du kjører alt gjennom Opus uten å tenke deg om, går grensen tom 5 ganger raskere enn om du brukte Sonnet eller Haiku til halvparten av oppgavene.
### Eksempel på modellvalg
| Oppgave | Modell | Hvorfor |
|----|----|----|
| Arkitektonisk beslutning, ny produktdel | Opus 4.7 | Det trengs dybde |
| Skrive en komponent etter en tydelig spesifikasjon | Sonnet 4.6 | Standardvalg |
| Rette en skrivefeil, gi en variabel nytt navn | Sonnet 4.6 eller Haiku 4.5 | Enkel redigering |
| Finne en fil ut fra en beskrivelse, filruting | Haiku 4.5 | Billig |
| Tekstoversettelse, klassifisering, oppsummering | Haiku 4.5 | En enkel modell klarer det |
| Gå gjennom egen kode | Sonnet 4.6 | Standardvalg |
| Finne en kompleks feil som krever resonnering i flere trinn | Opus 4.7 | Det trengs resonnementskjeder |
Bytt modell med kommandoen `/model`. **Men** modellbytte ugyldiggjør cachen. Hvis du bytter fra Sonnet til Opus midt i en økt, beregner neste forespørsel hele prefikset på nytt til full inndatapris (ikke bufret pris). Det er derfor bedre å velge modell ved starten, i stedet for å bytte fram og tilbake.
### /effort – en mindre aggressiv innstilling
I april 2026 [innførte Anthropic `/effort`](https://code.claude.com/docs/en/changelog) – 5 nivåer for resonneringsdybde: minimal / low / medium / high / xhigh. Claude Code med Opus 4.7 kjører som standard på xhigh.
Dette gjør jeg:
- For klassifisering, datauttrekk og korte oppsummeringer: `/effort low`. Dette sparer 30–70 % på oppgavetyper som ikke trenger dyp resonnering.
- For enkle kodeoppgaver: `/effort medium`.
- For kompleks arkitektur lar jeg den stå på xhigh.
`/effort` endrer ikke modellen, bare dybden i resonnementet. Cachen forblir intakt.
## Regel 7: Send en ledetekst til en ny chat i stedet for å bruke `/compact`
Hovedpoeng
`/compact` komprimerer chatthistorikken til et sammendrag – men bryter samtalecachen og bruker tokens på selve oppsummeringen. Jeg har et bedre triks: Jeg ber Claude skrive en ledetekst til en chat ved siden av med oppgaven og konteksten, kopierer ledeteksten til en ny chat og starter med et varmt prefiks. Da komprimeres 50K tokens med historikk til en ledetekst på 500 tokens.
`/compact` er en offisiell Claude Code-kommando som erstatter historikken med et sammendrag. Hvis du kjører den rett etter den siste meldingen mens cachen er varm (abonnementets TTL er 1 time), blir sammendraget bufret og leses til 10 % av standardprisen. Hvis du kjører den etter en time, er cachen kald og du betaler full pris.
`/compact` kan tilpasses:
```bash
/compact Focus on code samples and API usage
```
Eller du kan angi standardfokus for oppsummeringen i CLAUDE.md:
```markdown
# Compact instructions
When you are using compact, please focus on test output and code changes
```
Men jeg gjør det vanligvis annerledes.
### Sende en ledetekst til en chat ved siden av: et eksempel
Trinn:
1. I den nåværende chatten, når jeg ser at konteksten har passert 50 %, sier jeg: **«Skriv en ledetekst til en chat ved siden av som fortsetter arbeidet uten å miste meningen. Ta med: hva vi jobbet med, hva som allerede er gjort, hva som gjenstår, viktige filer og konstanter.»**
2. Claude gir meg en ledetekst på 300–800 tokens.
3. Jeg lukker den nåværende chatten med `/clear` eller åpner bare en ny.
4. Jeg limer inn ledeteksten og starter med en varm CLAUDE.md og prosjektkontekst, men med et rent samtaleminne.
Dette får jeg sammenlignet med `/compact`:
- **Kontroll over hva som blir med i den nye chatten.** `/compact` oppsummerer etter sin egen forståelse; jeg kan redigere ledeteksten for hånd før jeg starter.
- **Jeg kan lagre ledeteksten i en fil i `plans/`** og vende tilbake til den i morgen.
- **Den nye chatten starter med en ren samtalecache** – etterpå jobber du til bufret inndatapris.
### Når er `/compact` bedre?
- Når du er i Plan Mode og ikke vil miste den gjeldende planen.
- Når oppgaven er ensartet og konteksten henger sammen (for eksempel ved oversettelse av et langt dokument).
- Når `/compact` kjøres **umiddelbart** etter Claudes svar – da havner sammendraget i den varme cachen og koster 10 %.
### `/clear` – siste utvei
`/clear` sletter alt, inkludert prosjektkonteksten. Jeg bruker den bare når jeg bytter til et helt uvedkommende tema og ikke vil beholde noe fra før. Etter `/clear` betaler neste forespørsel full pris for å laste CLAUDE.md inn igjen.
## Regel 8. Hva ugyldiggjør Claude Code-cachen, og hvorfor betaler du for det?
Hovedpoeng
Claude Code gir 90 % rabatt på inndataprisen gjennom bufring – bufrede tokens koster 10 % av vanlig inndatapostpris. Cachen varer 1 time på et abonnement (5 minutter på API-et som standard). Men enhver redigering av systemledeteksten eller prosjektkonteksten bryter cachen og tvinger fram ny beregning av hele prefikset. Denne kunnskapen lønner seg for meg hver dag: Hvis jeg ser at en kort forespørsel plutselig brukte et enormt antall tokens, betyr det at jeg brøt cachen et sted på veien.
På et abonnement er cache-TTL **1 time** (den forlenges hver gang den brukes). På API-et er standarden 5 minutter. Det betyr at hvis du kommer tilbake til arbeidet etter 40 minutter, er cachen fortsatt aktiv, og neste forespørsel koster nesten ingenting for inndata. Etter 1 time utløper cachen, og du betaler full pris.
Det meste av tiden som går med til komprimering, brukes på å generere sammendraget, ikke på et cache-miss.
— Claude Code-dokumentasjon, https://code.claude.com/docs/en/prompt-caching
### Hva bryter cachen (unngå dette midt i en oppgave)
1. **`/model` – modellbytte midt i økten.** Hver modell har sin egen cache. Etter `/model opus` beregnes hele prefikset på nytt for Opus.
2. **Aktivere Plan Mode med innstillingen `opusplan`.** I denne modusen betyr Plan Mode = Opus, normal modus = Sonnet. Hvert Shift+Tab = modellbytte = ugyldig cache.
3. **Koble til / fra MCP-server.** Dette inkluderer automatisk ny tilkobling etter en midlertidig feil. Hvis MCP-serveren din er ustabil, betaler du to ganger.
4. **Avslagsregler med bare navn** (`Bash`, `WebFetch`) – de endrer verktøydefinisjonene i systemledeteksten.
5. **`/compact`** – ugyldiggjør samtalelaget (med vilje).
6. **Oppgradere Claude Code til en ny versjon** – en ny versjon betyr en ny systemledetekst og en ny cache.
### Hva bryter IKKE cachen?
- Redigering av filer i repositoriet (de leses ved behov).
- Redigering av CLAUDE.md midt i en økt (endringene gjelder imidlertid ikke før omstart – se regel 2).
- Endring av utdataformat.
- Endring av tillatelsesmodus (hvis ikke `opusplan` er involvert).
- Bruk av Skills / kommandoer (legges til i samtalelaget).
- `/recap` (en ny kommando, sammendrag uten at cachen ugyldiggjøres).
- `/rewind` (gå tilbake til et prefiks som allerede er varmt).
- Starte en underagent (hovedøkten påvirkes ikke).
### Slik bruker du cachen til din fordel
- Ikke bytt `/model` uten grunn. Velg modell ved starten av oppgaven.
- Ikke aktiver 10 MCP-servere «for sikkerhets skyld». Hver enkelt legges til i systemledeteksten og bryter cachen ved ny tilkobling.
- Ikke rediger CLAUDE.md mellom oppgaver – gjør alle endringer samtidig og start på nytt etterpå.
- Bruk `/recap` i stedet for `/compact` når du bare trenger å se et sammendrag, ikke frigjøre kontekst.
## Hva skjedde med forslaget om automatiseringskreditter fra 15. juni?
Det foreslåtte skillet mellom interaktive og programmatiske abonnementspotter ble satt på pause. [Anthropics støtteoppdatering](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan) sier at Agent SDK, `claude -p` og tredjepartsapper fortsatt kan bruke abonnementsgrensene. Ikke legg kredittbeløpene fra det forkastede forslaget til som en ny obligatorisk regning.
Separate månedlige API-kreditter innført for kvalifiserte Max- og Team-abonnementer i oktober er en inkludert ramme i en tilkoblet Console-organisasjon. De erstatter ikke abonnementets interaktive grenser. [Gjeldende API-kredittveiledning](https://support.claude.com/en/articles/17154008-monthly-api-credits-for-max-and-team-plans) skiller abonnementsinnlogging fra API-nøkkelarbeid og oppgir oppstartsflater som ikke dekkes.
Før du budsjetterer en planlagt oppgave, registrerer du autentiseringsmåte, oppstartsflate, modell og faktisk forbruk. En `claude -p`-kommando alene fastslår ikke hvilken saldo den bruker. Ekstra betalt API-bruk avhenger av organisasjonens faktureringsoppsett. Se [fakturering av Claude Code-automatisering](https://ailoot.ai/blog/nb/claude-code-pricing-automation-billing/) for forklaring og kalkulator.
## En dag i livet til en vibe-koder som bruker Claude Code
Hovedpoeng
Hvis alle 8 reglene virker sammen, er Max 5x-abonnementet til 100 dollar nok til 8–10 timer vibe-koding om dagen. Grensen går ikke tom fordi hver chat håndterer én oppgave, CLAUDE.md er innholdstett, planen er lagret i en fil, Skills lastes inn ved behov, tungt arbeid delegeres til underagenter, modellen velges ut fra oppgaven, overganger mellom oppgaver skjer med overlevering av ledetekst, og du ikke bytter /model eller MCP midt i en økt.
Et eksempel på en dag:
1. **9:00.** Jeg åpner oppgave #1 – en redigering av en e-postmal. Jeg åpner en ny chat, bruker Plan Mode og ber Claude undersøke. Planen er klar på 3 minutter; jeg bytter til automatisk godkjenning, og redigeringen tar 10 minutter. Jeg lukker chatten.
2. **9:30.** Oppgave #2 – skrive en opplæringsveiledning. Jeg åpner en ny chat, der ferdigheten min for å skrive veiledninger utløses. Den laster inn 4000 tokens med metodikk. Jeg går gjennom den, og veiledningen er klar på 40 minutter. Ferdig.
3. **11:00.** Oppgave #3 – et komplekst arkitekturproblem. `/model opus`, Plan Mode, diskusjon. Jeg gjennomgår planen, lagrer den manuelt i `plans/2026-05-20-...md` eller godkjenner filskriving etter at Plan Mode er avsluttet, kontrollerer filen og lukker chatten.
4. **12:00.** Ny chat: «les `plans/2026-05-20-...md` og implementer fase 1». 6 underagenter jobber parallelt – én per fil. Fase 1 er klar på 45 minutter. Jeg lukker den.
5. **14:00.** Oppgave #4 – en redigering av en landingsside. `/model sonnet`. Ny chat. Plan og implementering tar 30 minutter. Jeg lukker den.
6. **15:00.** Oppgave #5 – feilsøking i produksjon. `/model opus`, Plan Mode; det trengs dybde. Etter en times diskusjon ber jeg den skrive en ledetekst til en chat ved siden av med den identifiserte årsaken og det foreslåtte løsningsforslaget. Jeg kopierer den til en ny chat og implementerer det på 20 minutter.
Ved dagens slutt: 6 oppgaver, 8 lukkede chatter, ikke én eneste `/compact`. Grensen er brukt 40–60 %. Det holder i massevis.
Grensen går tom for folk som:
- Stapper en hel oppgave inn i én chat der 50 % av konteksten allerede er brukt.
- Beholder CLAUDE.md på 600 linjer fordi «det kan komme til nytte».
- Bytter til `/model opus` for hver enkle redigering.
- Aktiverer 8 MCP-servere for sikkerhets skyld.
- Aldri bruker underagenter og drar alt inn i hovedsamtalen.
Grensen går ikke tom for folk som bygger en ekstra hjerne i prosjektfiler og jobber med Claude som med en ingeniør på teamet – de gir den tydelige oppgaver, dumper ikke alt inn i én samtale og bruker ulike verktøy til ulike oppgaver.
### Kilder
- [Anthropic – høyere grenser og SpaceX-avtalen (6. mai 2026)](https://www.anthropic.com/news/higher-limits-spacex)
- [Claude Code-dokumentasjon – kostnadsoptimalisering](https://code.claude.com/docs/en/costs)
- [Claude Code-dokumentasjon – kontekstvindu og automatisk komprimering etter modell](https://code.claude.com/docs/en/model-config#extended-context)
- [Claude Code-dokumentasjon – hurtigbufring av ledetekster](https://code.claude.com/docs/en/prompt-caching)
- [Claude Code-dokumentasjon – Skills](https://code.claude.com/docs/en/skills)
- [Claude Code-dokumentasjon – endringslogg](https://code.claude.com/docs/en/changelog)
- [Anthropic API-priser](https://platform.claude.com/docs/en/about-claude/pricing)
- [Anthropic Code with Claude SF 2026 – oppsummering av hovedinnlegget](https://claude.com/blog/code-w-claude-sf-2026-sf)
Du kan fortsette å utforske Ailoot på [ailoot.ai](https://ailoot.ai/).
## Spørsmål om denne veiledningen: Claude Code-grenser i 2026: 8 regler for å unngå å bruke opp tokens
### Hvordan lagrer jeg en plan når jeg fortsatt er i Plan Mode?
Gjennomgå planforslaget og kopier det manuelt til prosjektets plans/-fil, eller gå uttrykkelig ut av Plan Mode og godkjenn filskrivingen. Kontroller innholdet som er lagret før økten lukkes, slik at neste chat kan laste den faktiske filen.
### Hva bør en overlevering før ny chat inneholde?
Ta med oppgaven, fullført arbeid, gjenstående arbeid, viktige filer og beslutninger. Lagre først den godkjente planen eller overleveringen, og gi banen til den nye chatten. En kort overlevering er nyttig bare hvis den bevarer opplysningene som trengs for å fortsette.
## Ailoot · Selskapet og dets prosjektportefølje
Ailoot bygger på etablert driftserfaring, en stor kundebase, stabil tjeneste og løpende KPI-kontroll.
Selskapet og dets prosjektportefølje: millioner av kunder; månedlig salg for milliarder.
Ailoot bruker denne driftserfaringen til API-tilgang til AI-funksjoner i kundenes produkter, agenter, applikasjoner og automatiseringer.