Sonnet, Opus och effort i Claude Code: Välja modell

Praktiskt material om modeller och arbete med agenter: Ailoot-dokumentation.

Uppdaterad 23 september 2026. Sedan den här artikeln publicerades har Anthropic ändrat modellgenerationer två gånger: först släpptes Opus 5 och Sonnet 5, sedan Claude Opus 5.5 den 22 september. Urvalslogiken i den här guiden fungerar fortfarande: använd den dyra modellen för arkitektur och felsökning och mellanmodellen för det dagliga arbetet. Namnen och priserna har ändrats. I nästa avsnitt förklarar jag exakt vad som ändrats och hur du läser tabellerna nedan.

Vad som ändrades i september 2026: Opus 5.5, Sonnet 5 och nya priser#

Här är en snabb sammanfattning av vad som ändrats i siffror och kommandon:

Tre slutsatser som påverkar det dagliga arbetet.

Den främsta modellen är billigare. Anthropic uppger att Opus 5.5 kräver mindre beräkningskraft, så priset per token sjönk med 20 %, cacheläsningar sjönk från $0.50 till $0.20 per miljon och typiska arbetsflöden med standardinställningar kostar 40 % mindre än med Opus 5. Den gamla reflexen ”Jag slog på Opus — jag brände igenom min gräns på en halv dag” känns mindre övertygande, även om problemet inte har försvunnit.

Nu ställer du in resonemangsdjupet manuellt. Opus 5.5 börjar på medium, medan andra modeller med stöd för effort börjar på high. Om du förväntar dig djup analys från den främsta modellen anger du uttryckligen /effort high eller xhigh. En detalj till: den översta nyckeln effortLevel i användarinställningarna fungerar inte för Opus 5.5, eftersom nivån nu sparas separat för varje modell.

Alla tre aktuella modeller har ett kontextfönster på en miljon token. Uppgifterna om 200K för mellanmodellen och uppgraderingen till 1M med opus[1m] gäller inte för aktuella Opus 5.5 och Sonnet 5: de har en miljon token inbyggt.

Tabellerna och beräkningarna nedan behåller de ursprungliga modellnamnen och priserna som en guide till urvalslogiken. Använd de aktuella priserna: $4 / $20 för den främsta modellen och $2 / $10 för mellanmodellen.

Vad som ändrades i maj 2026: Sonnet 4.6, Opus 4.7, Haiku 4.5 och varför det spelar roll#

Den 6 maj 2026, på konferensen Code with Claude, lanserade Anthropic fem stora uppdateringar: hanterat minne (Dreaming), resultat, orkestrering av flera agenter, Remote Control och Agent View. Samma dag fördubblades gränserna för Pro, Max, Team och Enterprise. Begränsningarna under rusningstid, som hade gällt sedan slutet av mars, togs bort helt.

Samtidigt uppstod ett annat avtal om beräkningskapacitet. I sitt S-1-dokument offentliggjorde SpaceX ett Anthropic-avtal värt $1.25 miljarder per månad till och med maj 2029 för Colossus (220,000+ NVIDIA-GPU:er, 300+ MW). Det betyder att Claude kommer att ha mer kapacitet under de kommande åren, inte mindre.

Vad innebär det här i praktiken för en vibe-kodare? Det typiska arbetsflödet brukade låta så här: ”Jag använder Opus eftersom det är smartare.” Nu skiljer sig de tre modellerna verkligen åt:

• Opus 4.7 ($5 / $25 per miljon in- och utgående token, 1M kontext) — släpptes den 16 april 2026. Ny tokeniserare. SWE-bench Verified: 87.6 %, en ökning med 13 % jämfört med Opus 4.6.
• Sonnet 4.6 ($3 / $15, 1M kontext) — 79.6 % på SWE-bench Verified. 91 % av Opus 4.7:s benchmarkresultat till 60 % av dess grundpris för indata/utdata och nästan i nivå med Opus 4.6 (80.8 %) — bara 1.2 poängs skillnad.
• Haiku 4.5 ($1 / $5, 200K kontext) — snabb och billig. För allt som inte kräver arkitektoniskt tänkande.

Och huvudpoängen: tre nya kommandon i Claude Code uppdaterades i början av maj: /model, /effort, /fast. Vart och ett kan minska tokenanvändningen med 2–5 gånger om du vet när du ska använda det.

I arbetssättet som beskrivs här används båda huvudmodellerna varje dag. Här nedan följer den resulterande beslutsöversikten.

Så väljer du modell: en beslutsöversikt efter uppgiftstyp#

Den här tabellen är praktisk att ha nära till hands och konsultera när du byter uppgift.

Huvudprincipen: välj Sonnet som standard. Sonnet 4.6 är standard på de flesta användarplaner av en anledning. Anthropics officiella hjälp säger uttryckligen att Sonnet är rätt val för de flesta kodningsuppgifter.

Ett farligt mönster som 80 % av nybörjarna fastnar i: de ställer in Opus som standard och undrar varför gränsen tar slut på en halv dag. Gränsen tar slut eftersom Opus kostar 1.67 gånger mer per token.

Hur Sonnet 4.6 skiljer sig från Opus 4.7 i verkliga uppgifter#

Ett benchmark säger inte mycket i sig. Det viktiga är skillnaden på verkliga uppgifter. Här ställs båda modellerna bredvid varandra på samma uppgift.

Scenario 1. Enkel refaktorering (3–5 filer).

Sonnet och Opus presterar likvärdigt. I jämförelsen som beskrivs observerades ingen skillnad i kodkvalitet. Tid: Sonnet är 15–20 % snabbare. Kostnad: Sonnet är 1.67 gånger billigare, så valet är självklart.

Scenario 2. Felsökning av en icke-trivial bugg. Anta att e-postkvitton slutar komma fram på en e-handelsplattform efter en migrering av betalningsgatewayen. Symptom: cron körs, en post hamnar i databasen, men e-postmeddelandet skickas inte.

• Sonnet: på 15 minuter kontrollerar den loggarna och de uppenbara ställena, hittar e-posttjänsten i miljövariablerna och föreslår att nyckeln kontrolleras. Om nyckeln är OK börjar den gå i cirklar.
• Opus med insatsnivån xhigh bygger omedelbart upp en mental karta: ”webhook → cron → statuskontroll → e-posttjänst”. På 20 minuter hittar den att migreringen ändrade order-ID-formatet medan e-posttjänsten filtrerar efter det gamla formatet.

Det här är ingen magi. Det är adaptivt resonemang: Opus 4.7 bestämmer i varje steg hur mycket den ska tänka, och vid en svår bugg använder den token för djupare resonemang, inte för ett snabbare svar.

Scenario 3. Arkitekturbeslut. ”Bör vi flytta analysen till en separat tjänst?” Sonnet ger en bra plan för en sådan fråga, men kan missa nyanser — till exempel att övervakning med två tjänster kräver att aviseringarna också flyttas. Opus 4.7 arbetar systematiskt igenom sådana nyanser.

Den sista raden spelar roll. När du läser att ”Opus 4.7 kostar si och så”, kom ihåg: samma fil kräver 20–35 % fler token än med Sonnet. Den verkliga kostnaden för samma uppgift ökar ännu mer än tabellens nominella priser antyder.

Vill du inte bara välja mellan modeller, utan även bygga en kombination som gör Claude tillförlitlig oavsett modell? Att välja Sonnet eller Opus är en axel inom kontextteknik. En fungerande uppsättning kombinerar alla tre grundpelare: AI-klon + Second Brain + Context Engineering — den kombinationen förvandlar Claude från en ”assistent med hallucinationer” till ett tillförlitligt verktyg. Utan den börjar även den dyraste modellen hallucinera redan vid det tredje steget.

När du ska använda Haiku 4.5 (och varför 80 % av Claude Code-uppgifterna använder Sonnet)#

Här gör Haiku verklig nytta:

• Enradsskript: ”skriv ett bash-skript som startar om nginx om processen inte svarar på 30 sekunder.”
• Enkel kodförklaring: ”vad gör den här funktionen?”
• Generering av konventionella commit-meddelanden.
• Grundläggande syntaxkontroller / lint-korrigeringar.
• Översättning av kommentarer mellan språk.

Tekniskt sett fungerar Haiku i Claude Code på samma sätt som via /model haiku. Men det finns en hake: underagenter och bakgrundsuppgifter använder Haiku som standard om du inte skriver över detta med miljövariabeln ANTHROPIC_DEFAULT_HAIKU_MODEL.

Haikus kontext är 200K token. Det räcker gott för de flesta filer, men du stöter på gränsen om du arbetar med ett monorepo eller långa transkriptioner. Sonnet och Opus har 1M i det läget.

Kostnad: 1,000 liknande förfrågningar (till exempel att generera commit-meddelanden från 200 indatoken + 50 utdatatoken) kostar $0.45 med Haiku. Samma arbetsmängd kostar $1.35 med Sonnet och $2.25 med Opus. Det är en trefaldig skillnad.

Kommandot /model: så byter du modell under en session#

Sex sätt att ange modell i Claude Code, i prioritetsordning:

1. Under en session: /model <alias> — byter direkt. Konversationshistorik, filer och kontext följer med; bara modellen som behandlar nästa meddelande ändras. Om det redan har kommit utdata under sessionen ber menyn om bekräftelse — nästa svar läser hela historiken igen utan cache.
2. Vid start: claude --model <alias>.
3. Miljövariabel: ANTHROPIC_MODEL=<alias>.
4. Inställningsfil: fältet model i ~/.claude/settings.json.

Grundläggande kommandon:

# Starta med den främsta modellen (för närvarande Opus 5.5)
claude --model opus

# Byt till Sonnet under en session
/model sonnet

# Öppna valmenyn (för interaktivt val)
/model

# Byt till Opus med 1M kontext
/model opus[1m]

# Byt till en specifik version (lås fast den)
/model claude-opus-5-5

Alias och vad de pekar på i Anthropic API (per den 23 september 2026):

• opus → Opus 5.5 (kräver Claude Code v2.1.280 eller senare)
• sonnet → Sonnet 5
• haiku → Haiku 4.5
• best → den smartaste tillgängliga modellen
• default → Opus 5.5 på Pro, Max, Team, Enterprise och Anthropic API
• opusplan → en hybrid av Opus + Sonnet (beskrivs separat nedan)

⚠️ Standardinställningarna skiljer sig åt hos molnleverantörer: på Amazon Bedrock och Google Cloud pekar aliaset sonnet på Sonnet 4.5; på Microsoft Foundry löses opus fortfarande till Opus 4.6. Om du arbetar via en molnleverantör låser du fast en specifik version (claude-opus-5-5) eller ställer in variabeln ANTHROPIC_DEFAULT_OPUS_MODEL.

Från och med version 2.1.144 är den största ändringen att /model inte längre skriver modellvalet till inställningarna. Valet gäller den aktuella sessionen och försvinner när sessionen stängs. Om du vill spara en standard permanent trycker du på d på den markerade raden i valmenyn. Då skrivs fältet model till ~/.claude/settings.json.

Sammanfattade sessioner (claude --resume, --continue, /resume) behåller modellen som användes i den sessionen, oavsett aktuell inställning. Det förhindrar att en annan session ändrar modellen när du återupptar en session.

Om du vill kontrollera vilken modell som är aktiv använder du /status — det visar både kontot och den aktuella modellen.

/model opusplan: jämför planerings- och utförandekostnader separat#

I arbetssättet som beskrivs här används det här läget för uppgifter som tar mer än 10 steg.

Logiken:

• I Plan Mode (/plan) diskuterar ni arkitekturen och alternativen och kommer överens om ett tillvägagångssätt. Opus är dyrt här, men motiverar priset eftersom resonemanget är fundamentalt annorlunda.
• Så snart Plan Mode avslutas och Claude börjar redigera filer, skriva tester och köra kommandon är det utförande. För utförandet matchar Sonnet 4.6 Opus i kvalitet.

Så aktiverar du det:

# Vid start
claude --model opusplan

# Eller under en session
/model opusplan

En specifik beräkning. Anta att en refaktorering i 50 steg har en typisk fördelning:

• Planering (5 steg, ~30,000 indatatoken + 8,000 utdatatoken): Opus 4.7
• Utförande (45 steg, ~200,000 indatatoken + 50,000 utdatatoken): Sonnet 4.6

Baslinjen använder 230 000 indatatoken och 58 000 utdatatoken: 2,60 dollar till tabellens historiska Opus-priser. Opusplan behåller 30 000 indata och 8 000 utdata på Opus (0,35 dollar) och använder 200 000 indata och 50 000 utdata på Sonnet (1,35 dollar), totalt 1,70 dollar. Besparingen är (2,60 − 1,70) / 2,60 = 34,6 %. Med identiska tokenantal och dessa priser sparar ersatt utförande 40 % av den delen; även om utförandet var 90 % av baskostnaden blir total besparing 36 %. En tokeniserarskillnad kräver uttryckliga indata-/utdataantal per modell och motiverar inte ensam ett påstående om 75–80 %.

⚠️ En detalj: Opus i Plan Mode med opusplan använder standardkontexten på 200K. Den automatiska uppgraderingen till 1M, som är tillgänglig med aliaset opus, gäller INTE för opusplan. Om du planerar en stor uppgift med miljontals token i kontext (till exempel analys av ett stort monorepo) använder du antingen uttryckligen /model opus[1m] eller byter till opusplan EFTER planeringen.

Kommandot /effort: 5 nivåer av adaptivt resonemang#

Det här är det näst viktigaste kommandot efter /model. Effort är adaptivt resonemang: i varje steg avgör modellen hur djupt den ska tänka utifrån uppgiftens komplexitet. Ju högre nivå, desto djupare resonemang och desto fler token används.

Nivåer (beroende på uppgiften):

Tre modeller stöds: Opus 4.7, Opus 4.6 och Sonnet 4.6. Effort är inte tillgängligt på de övriga.

Vad som ändrades i september 2026. Nivåerna low, medium, high, xhigh och max finns för Opus 5.5, Opus 5, Sonnet 5, Opus 4.8 och Opus 4.7; Opus 4.6 och Sonnet 4.6 har inte xhigh, och en begärd xhigh körs som high på de modellerna. Standardnivån är high på alla modeller som stöder effort, utom Opus 5.5 (medium) och Opus 4.7 (xhigh). Det innebär att djup analys måste begäras uttryckligen på den nuvarande främsta modellen. Ett separat ultracode-läge har också tillkommit: det är en Claude Code-inställning, inte en modellnivå — det skickar xhigh och ber också Claude bygga dynamiska arbetsflöden för stora uppgifter.

Så ställer du in nivån:

# Öppna det interaktiva reglaget
/effort

# Ange nivån direkt
/effort high
/effort xhigh

# Återställ till modellens standard
auto

# Via en startflagga
claude --effort high

# Via en miljövariabel (gäller vid start)
export CLAUDE_CODE_EFFORT_LEVEL=high

# I inställningarna (max fungerar inte — max gäller bara sessionen)
{
  "effortLevel": "high"
}

# I skill-/underagentens frontmatter
---
name: my-skill
effort: low
---

Nivån visas bredvid logotypen och snurrikonen i Claude Code, till exempel ”with low effort”, så du behöver inte öppna /model för att kontrollera den.

Effort-reglaget visas också i menyn för val av /model — använd vänster-/högerpilarna för att ställa in nivån.

En viktig detalj. När du byter till Opus 4.7 från en annan modell ställs effort med tvång in på xhigh — även om du hade high för Opus 4.6 eller Sonnet 4.6. Kör /effort igen för att återställa önskad nivå.

En teknik till: ultrathink i prompten. Om du tar med ordet ultrathink i prompttexten använder Claude djupare resonemang i den turen utan att ändra sessionens effort. Liknande fraser (”think”, ”think hard”, ”think more”) aktiverar inte detta beteende — de skickas bara som vanlig text.

Kommandot /fast: Opus är 2.5 gånger snabbare för 6 gånger priset — när lönar det sig?#

Fast mode är en förhandsversion för forskning. Det kräver Claude Code v2.1.36+ och kan kontrolleras med claude --version.

Så aktiverar du det:

# Växla fast mode (tillgängligt i Claude Code CLI och VS Code Extension)
/fast

# Eller i inställningarna
{
  "fastMode": true
}

När det har aktiverats:

• Om du använder en annan modell byter Claude Code automatiskt till Opus.
• En bekräftelse med texten ”Fast mode ON” visas.
• En ↯-ikon visas bredvid prompten.

Alternativ och detaljer:

• Standardmodellen i fast mode är den mest kapabla tillgängliga Opus-modellen. Per den 23 september 2026 är det Opus 5.5; fast mode fungerar inte alls på Opus 4.7, och om du byter till den stängs fast mode av.
• Fast mode sparas mellan sessioner som standard. Team-/Enterprise-administratörer kan kräva uttryckligt val för varje session med fastModePerSessionOptIn: true.
• När du stänger av fast mode genom att köra /fast igen stannar du kvar på Opus — modellen återgår inte till den föregående. Om du vill byta använder du /model.
• Om du aktiverar det mitt i en konversation debiteras fast mode-priset för hela konversationens kontext. Därför är det mer ekonomiskt att aktivera fast mode i början av sessionen, inte halvvägs.

När du ska använda fast mode:

• Livefelsökning: Du följer en trace och svarstiden är kritisk.
• Snäv deadline för interaktivt arbete: Du skriver en demo till 18:00 och behöver göra snabba iterationer.
• Snabb koditeration: Du testar hypoteser efter varandra.

När du inte ska använda det:

• Långa autonoma uppgifter där hastigheten inte är kritisk. Du betalar 6 gånger priset för 2.5 gånger hastigheten — det lönar sig inte om du går på lunch medan Claude arbetar.
• Batchbearbetning, CI/CD-pipelines — inte alls för interaktivt läge.
• Kostnadskänsliga arbetsflöden — valet är självklart.

Tillgänglighet:

• Fungerar INTE på Bedrock, Vertex eller Foundry.
• Kräver användningskrediter på kontot (debitering utöver planens inkluderade gräns). För individuella konton aktiveras det i Console-betalningsinställningarna. För Team/Enterprise måste en administratör aktivera det.
• Fast mode-token dras INTE från planens inkluderade gräns. De debiteras direkt från användningskrediterna till fast mode-priser från den allra första tokenen.

Om du når gränsen för fast mode-förfrågningar eller får slut på användningskrediter växlar fast mode automatiskt till standardhastighet och standardpris, ↯-ikonen blir grå och arbetet fortsätter. När gränsen återställs aktiveras fast mode igen.

Fast mode och effort konkurrerar inte med varandra. Du kan kombinera dem: fast mode + low effort = högsta hastighet på enkla uppgifter.

Vad varje modell faktiskt kostar: en uppdelning av månadsräkningen#

Priser per miljon token (Anthropic API, USD):

Vad som faktiskt minskar kostnaden:

1. Promptcachning. Anthropic cachar upprepade avsnitt i promptar: systemprompten, CLAUDE.md och verktygsbeskrivningar. En cacheträff kostar 10 % av indatapriset. På Sonnet minskar det $3 per miljon token till $0.30 — tio gånger billigare. Det aktiveras automatiskt via cache_control: { type: "ephemeral" } i API-förfrågan. I Claude Code fungerar det som standard.

2. Batch API: 50 % rabatt på in- och utdata för uppgifter där du kan vänta (rapporter, generering av text i stora batchar). Sonnet via Batch API = $1.50 / $7.50. Det fungerar inte direkt i Claude Code, men använd det om du bygger automatiseringar med Anthropic SDK.

3. opusplan i stället för enbart Opus: cirka 34,6 % besparing i det genomräknade historiska exemplet; faktisk total beror på utförandeandel, tokenantal, priser, cache och omförsök.

4. Sonnet som standard + Opus vid behov: den främsta besparingen. Om Opus är aktiverat ”för säkerhets skull” byter arbetssättet som beskrivs här till Sonnet. Om uppgiften kräver Opus blir det tydligt vid det tredje eller fjärde steget, och då byter jag uttryckligen med /model opus.

5. Kom ihåg Opus 4.7:s nya tokeniserare. För samma fil använder Opus 4.7 upp till 35 % fler token än Sonnet 4.6. Den verkliga kostnaden för samma uppgift blir högre än vad tabellen antyder.

Ett konkret exempel: en typisk uppgift för en fastighetsbyrå som bygger en webbplatsprototyp åt en ny kund: ”skapa en sida med tre sektioner, ett formulär och integration med en betalningsgateway”. Resultaten blev:

• Bara Opus 4.7 (high effort): ~$4.80 per session (1.5 timmars arbete).
• opusplan: ~$1.90 (Opus planerar, Sonnet utför).
• Bara Sonnet 4.6 (high effort): ~$1.30, men arkitekturbeslutet var sämre (Sonnet valde en mallbaserad metod, medan Opus i opusplan kom på en egen lösning för de icke-standardiserade kraven).

Vinnaren för den här uppgiften är opusplan. Besparingen är 60 %, med Opus-kvalitet på den kritiska delen.

Claude Code visar inte tokenantal direkt för gränserna — de är dynamiska och beror på planen. Men i /status kan du se din plan och aktuella användning. För närmare kontroll finns en detaljerad guide: Så undviker du att förbruka Claude Code-gränserna på en dag.

Vilket dagligt arbetsflöde bör du sätta upp? 4 färdiga förinställningar#

De här fyra förinställningarna kan växlas beroende på arbetsdagen och uppgiften.

Förinställning 1. Daglig kodning — 80 % av arbetstiden i arbetssättet som beskrivs här.

claude --model sonnet --effort high
# Växla upp till Opus under sessionen vid behov
/model opus

Vad det är: nya funktioner, små refaktoreringar, felsökning av enkla buggar, dokumentation. Sonnet med high effort är den bästa balansen.

Förinställning 2. Tung refaktorering — en stor arkitekturändring.

claude --model opusplan
# Använd först /plan för att diskutera strukturen
# När du lämnar Plan Mode sköter Sonnet utförandet

Vad det är: skriva om en modul i 15+ filer, byta en integration från en gateway till en annan. Opus hanterar arkitekturen (tänker igenom beroenden), och Sonnet hanterar utförandet (redigerar filer snabbt). Sådana uppgifter kan spara 70 %+.

Förinställning 3. Snabbfix — enradiga ändringar och skript.

claude --model haiku --effort low

Vad det är: ”ändra namnet på en variabel i alla filer”, ”skriv ett bash-skript som startar om nginx”, ”vad gör den här funktionen?” Haiku klarar de här uppgifterna och kostar tre gånger mindre än Sonnet.

Förinställning 4. Arkitektursession — ett strategiskt beslut.

claude --model opus --effort xhigh
# Använd högsta insats när du går in i Plan Mode:
/plan
# Lägg till ordet ultrathink i prompten för kritiska frågor

Vad det är: ”bör X vara en separat tjänst?”, ”vilka verktyg ska vi använda för prototypen?”, ”hur ska vi organisera ett databasschema för användning med flera klienter?” Här är Opus 4.7 dyrt — och värt det, eftersom ett misstag här kostar veckor av arbete.

De här förinställningarna kan sparas som Skills (en modell per skill) eller som alias i ~/.zshrc:

alias claude-daily='claude --model sonnet --effort high'
alias claude-refactor='claude --model opusplan'
alias claude-quick='claude --model haiku --effort low'
alias claude-architect='claude --model opus --effort xhigh'

Om du arbetar i ett team kan du standardisera via hanterade inställningar. En administratör ställer in availableModels: ["sonnet", "haiku", "opusplan"] i organisationens policy, så att användarna rent praktiskt inte kan välja Opus direkt utan bara genom ett uttryckligt val. Det är ett bra skydd mot att av misstag förbruka gränsen.

För dig som bygger underagenter kan du också ange olika modeller för olika underagenter via CLAUDE_CODE_SUBAGENT_MODEL eller fältet model i agentdefinitionens frontmatter. Det ger ytterligare en nivå av optimering.

Vad du kan göra när du får slut på kapacitet: 5 praktiska metoder#

Om /status visar att du har nått Opus-gränsen:

1. Byt till Sonnet 4.6: /model sonnet. Den har en separat pott, och du märker ingen skillnad på 80 % av uppgifterna. På Anthropic API kan Claude Code automatiskt växla till Sonnet när du närmar dig gränsen, även om du har nått Opus-gränsen.

2. Använd opusplan för det återstående arbetet: /model opusplan. Om du har Plan Mode-uppgifter kvar för dagen använder de Opus sparsamt (bara för planering); utförandet sker helt med Sonnet.

3. Kontrollera promptcachningen: se till att du inte har inaktiverat den med DISABLE_PROMPT_CACHING=1. Om din CLAUDE.md eller systemprompt innehåller en megabyte med inställningar bör den cachas. Vid 90 % läsningar minskar det användningen tiofalt.

4. Flytta batchuppgifter: om du har massgenerering (rapporter, texter, översättningar) flyttar du den till ett skript med Batch API — 50 % rabatt på in- och utdata. Det fungerar inte direkt i Claude Code, men tar 30 minuter att sätta upp med ett tsx-skript + Anthropic SDK.

5. Använd Haiku för sekundära uppgifter: byt Claude Code till Haiku för rutinuppgifter som ”skriv ett commit-meddelande” eller ”förklara vad den här filen gör”. Den använder tre gånger mindre än Sonnet och fem gånger mindre än Opus.

Och den viktigaste påminnelsen: sedan den 6 maj 2026 har gränserna för Pro, Max, Team och Enterprise fördubblats, och begränsningarna under rusningstid har tagits bort. Om Opus förbrukar kapaciteten på en halv dag är det inte gränserna som är problemet — Opus används där Sonnet skulle klara uppgiften. Beslutsöversikten i guidens andra avsnitt ger dig kontrollen tillbaka.

Läs pelarartikeln Så undviker du att förbruka Claude Code-gränserna på en dag: 8 regler för att spara token 2026 för en djupgående genomgång av gränserna och åtta praktiska regler för att spara token. En annan användbar följeslagare är Plan Mode i Claude Code: en steg-för-steg-guide, eftersom opusplan inte fungerar utan Plan Mode. Grunden för alla modeller är Så konfigurerar du CLAUDE.md 2026.

Ett fungerande upplägg för vibe-kodning: AI-klon + Second Brain + Context Engineering. Praktiskt material: Ailoot-dokumentation.

Mer material och verktyg: Ailoot.