Claude Code-terminal: 7 arbetsflödeslyft för avancerade användare

Vanilla Claude Code är redan användbart direkt. Du installerar det, du promptar det och det bygger vad du vill. Det är de flestas vibe-coding-setup, och det funkar.

Versionen av Claude Code som någon med en anpassad terminal använder är ett annat verktyg. De har förhandsgodkänt bash-kommandon de litar på, så Claude ber nästan aldrig om tillstånd. En CLAUDE.md ligger i projektroten, så Claude känner redan till deras konventioner i samma stund som en session öppnas. Och när en session börjar kännas förvirrad är kommandot de tar till inte en omstart.

Den här artikeln är gapet mellan de två Claude Code-uppläggen, i sju uppgraderingar. Ingen tar mer än tio minuter att ställa in, och varje ger avkastning inom en vecka.

Om du aldrig har öppnat Claude Code tidigare är vår huvudguide till Claude Code en bättre startpunkt. Allt nedan förutsätter att du redan kan prompta och godkänna verktygsanrop.

1. Sluta godkänna samma kommandon om och om igen

Direkt ur lådan ber varje nytt verktygskall om godkännande. Okej första gången du kör pytest. Irriterande tredje gången. Den tionde trycker du Enter utan att läsa prompten. Det är det sämsta av två världar: du har lärt dig att ignorera säkerhetskontrollen, och ändå saktar den ner dig.

Det finns förstås läget "farligt kringgå behörigheter" eller "auto-läge." Vi gick igenom kompromisserna i detalj i min handledning om Claude Code Auto Mode och kanaler.

Definiera behörigheter i filen settings.json

Lösningen är en .claude/settings.json i projektroten, med ett permissions-block som förhandsgodkänner mönstren du litar på och blockerar dem du inte gör:

{
  "permissions": {
	"allow": [
  	"Bash(pytest *)",
  	"Bash(uv run *)",
  	"Bash(ruff check *)",
  	"Read(~/.zshrc)"
	],
	"deny": [
  	"Bash(curl *)",
  	"Read(./.env)",
  	"Read(./.env.*)",
  	"Read(./secrets/**)"
	]
  }
}

Regler utvärderas i en fast ordning: deny först, sedan ask, sedan allow. Första träffen vinner, så en deny-regel slår alltid ett senare allow.

Bemästra scope och jokertecken

Tre saker snubblar folk på första gången de skriver en sån här.

1. Det första är scope. Ett projekts .claude/settings.json skriver över din globala ~/.claude/settings.json, så om du tillåtit Bash(rm *) globalt och ett projekt nekar det, vinner projektet. Det är rätt default, men överraskar dem som väntar sig att globala tillåtelser ska vara klistriga.

2. Det andra är jokertecken på nätverkskommandon. Bash(curl http://github.com/ *) ser restriktivt ut men fångar inte https://, flaggor före URL:en, omdirigeringar eller shell-variabelexpansion. Mönstret som dokumentationen rekommenderar är att neka Bash(curl *) rakt av. Använd sedan WebFetch-verktyget med WebFetch(domain:github.com) för de domäner du faktiskt vill tillåta.

3. Det tredje är blanksteg. Bash(ls *) matchar ls -la men inte lsof. Bash(ls*) matchar båda. Mellanslaget före asterisken gör faktiskt jobbet, och det är värt att vara medveten om vilket du skrev.

Några tangentbindningar hör hemma bredvid behörigheter i samma "sluta bråka med terminalen"-kategori och är värda att lära sig dag ett:

• Skift+Tabb växlar behörighetslägen (default, auto-accept, plan)

• Esc+Esc öppnar återspolningsväljaren (mer om detta i #3)

• Ctrl+R baklängessöker i din prompthistorik, på samma sätt som i bash och zsh

• Ctrl+U tar bort från markören till radens början

• Skift+Enter lägger till en ny rad i prompten

De flesta av dessa tangentbindningar fungerar direkt i terminaler. Om de inte gör det, kör /terminal-setup-kommandot en gång för att installera allt.

2. Få Claude Code att minnas ditt projekt

Varje session startar med ett färskt kontextfönster.

Som standard minns inte Claude att du använder uv istället för pip. Det minns inte att dina tester ligger i tests/ och inte test/. Och API-konventionerna du la tio vändor på att förklara igår är också borta. Lösningen är en CLAUDE.md i projektroten. Starta Claude Code från den katalogen (eller en underkatalog), så laddas filen in i kontext automatiskt före din första prompt.

Snabbaste sättet att börja är /init. Kör det i projektet. Claude läser kodbasen och skriver en start-CLAUDE.md med byggkommandon, testinstruktioner och konventioner den kan härleda. Du kommer att redigera den efteråt, eftersom /init ger dig en fungerande bas snarare än en färdig fil.

Claude letar efter kontext på tre ställen, staplade ovanpå varandra:

Projekt-CLAUDE.md på ./CLAUDE.md följer med repot. Den är samma för alla som bidrar, så lägg projektspecifika fakta här:

• Paket­hanteraren och språkversionen
• Testkommandot och var testerna ligger
• Katalogstrukturen och eventuella icke‑självklara konventioner
• Allt en ny kollega behöver veta dag ett

Användar-CLAUDE.md på ~/.claude/CLAUDE.md följer med dig över alla projekt på din maskin. Här hör personliga preferenser hemma: din kodstil, hur du vill ha docstrings skrivna, språken du oftast väljer. Lägg inte projektfakta här, för de spiller över i varje annat repo du öppnar.

Auto-minne är det tredje lagret, och det skriver Claude själv. När du rättar det under en session ("vi använder snake_case här, inte camelCase"), loggar det rättelsen till ~/.claude/projects/<project>/memory/MEMORY.md. De första 200 raderna eller 25 KB av den filen laddas i början av varje konversation i samma projekt. Du kan se vad som laddas med /memory, som också låter dig slå på eller av auto-minne.

En tumregel för storlek: håll varje CLAUDE.md under 200 rader. Efter det börjar filen äta märkbar kontext i varje vända, och Claude följer långa filer mindre tillförlitligt än korta. Om din kryper över, dela upp den i .claude/rules/ med pathscope. För en djupare genomgång av vad som faktiskt hör hemma i en CLAUDE.md-fil, se min guide om att skriva den bästa CLAUDE.md-handledningen.

3. Sluta starta om sessioner när de spårar ur

Instinkten, när en session börjar kännas fel, är att köra /clear och börja om. Det är fel instinkt för det mesta. En omstart kastar bort sökvägarna Claude har redigerat, det fallande testet den följde eller begränsningarna du skrev i början. En ny session måste lära om allt det där, och du betalar för omlärningen i tokens och tid.

Det första att lära sig är symptomet. Kontext-röta som detta har några tydliga signaler:

• Claude frågar igen efter en filsökväg den redigerade för fem vändor sedan
• Den upprepar ett förslag du redan avvisade
• Den tappar bort vilken branch du är på
• Du har rättat den mer än två gånger i samma fråga under en session

När du ser dessa har du fyra alternativ, och de är inte utbytbara:

Kompaktera din session

 /compact är inte så dåligt som vissa användare hävdar.

Din projekt-CLAUDE.md överlever det. Claude läser in filen från disk efter komprimering och injicerar den på nytt, så dina konventioner tappas inte bort. Du kan också skicka fokusinstruktioner för att styra summeringen, som /compact keep the auth refactor decisions, drop the failed test runs. Det är skillnaden mellan en användbar sammanfattning och en generisk.

Använda Claude Codes "ångra"-alternativ

Esc+Esc återspolningsväljaren är den de flesta inte vet finns. Den öppnar en lista över varje prompt‑checkpoint i sessionen. När du väljer en erbjuder den tre alternativ: återställ bara konversationen, bara koden eller båda.

"Återställ kod och konversation" är vad de flesta vill ha. En halvtimme av dåliga vändor kan försvinna utan att du öppnar git. Det är det närmaste Claude Code har till ångra för en hel session.

När du slutar starta om, är nästa problem att hitta sessioner igen.

Namnge och öppna sessioner på nytt

claude -n <name> (eller --name) startar en namngiven session, och namnet visas i /resume och i terminaltiteln. När du har tre saker på gång i samma repo (en experiment‑branch, en refaktorering, en felsökningsvända) är namn sättet att skilja dem åt. /rename ändrar namnet mitt i sessionen om ditt scope skiftar.

Proffstips: Använd /color för att ytterligare särskilja sessioner när flera körs i samma terminalfönster.

Att öppna en session igen sker via en av två flaggor. claude --continue (eller -c) laddar den senaste konversationen i aktuell katalog. Använd det när du just var här och vill fortsätta.

claude --resume öppnar en interaktiv väljare, och claude --resume <name-or-id> hoppar direkt till en specifik session. Behandla sessioner som git‑brancher: olika arbetsströmmar förtjänar sina egna.

4. Planera det svåra, snåla på det enkla

Den enskilt största kostnaden i en anpassad setup är inte editorn eller tangentbindningarna. Det är att matcha mängden beräkning du lägger med svårigheten på uppgiften framför dig. Tre verktyg samarbetar här: planläge, /effort och /model.

Använda Claude Codes planläge

Planläge säger åt Claude att tänka igenom ett angreppssätt innan den rör filer. Den skriver planen, du läser den, du godkänner eller invänder, och först därefter exekverar den.

Ett knep jag använder för att göra mina planer bergsäkra är en enkel prompt jag ofta använder:

Red-team this plan from multiple angles using as many Opus 4.7 agents as you need.

Det här startar flera underagenter för att granska planen ur flera aspekter och föreslå åtgärder. Det är en bra praxis när du hanterar en planfil över 500 rader.

Kostnaden är att planering plus red‑teaming lägger till två vändor innan någon kod landar, så för allt mindre än en betydande funktion eller buggfix är det överkurs.

Det finns fem sätt att gå in i planläge:

Det inlina formatet (/plan refactor the auth module to use JWT) är det de flesta missar. Det sätter både läget och uppgiften i ett knapptryck istället för två. För en djupare genomgång av gransknings‑först‑arbetsflöden i planläge går min handledning om Claude Codes planläge steg för steg.

Ställa in en lämplig ansträngningsnivå

Effort är nästa att lära sig. Det styr hur mycket utökande tänkande Claude gör i varje vända. Högre effort betyder djupare resonemang, fler tokens och ett långsammare svar.

/effort <level> och CLI-flaggan --effort <level> accepterar alla fem värden. Low, medium, high och xhigh ligger kvar över sessioner. Max gäller bara i aktuell session eftersom det tar bort begränsningen på token‑förbrukning, så du sätter det medvetet varje gång. Rätt default för vardagsjobb är low eller medium. Spara high eller xhigh för genuint svåra problem, och max för stunder när du hellre bränner tokens än har fel.

En motpoäng att ha i åtanke: en modell på low med grym kontext slår ofta samma modell på max med dålig kontext. Att snygga till din prompt är oftast en större vinst än att skruva upp effort.

Välja rätt modell

Modellvalet är där de verkliga kostnadsbesparingarna sker. /model växlar mitt i sessionen, och Alternativ+P (macOS) / Alt+P (Win/Linux) byter utan att rensa det du redan skrivit. Alias värda att känna till:

• sonnet är dagligt standardval

• opus är för de svåraste problemen (aliaset best pekar också på opus)

• haiku är när du vill ha fart

• sonnet[1m] och opus[1m] är varianterna med 1M‑kontext

• opusplan kör Opus i planläge och Sonnet i exekvering

• default rensar alla åsidosättningar och går tillbaka till rekommenderad modell

Om du defaultar till Opus för allt är att byta till Sonnet för största delen av dagen den enskilt största möjliga besparingen för dig. 

Opus är rätt val när du fastnat i något svårt och vill ha den smartaste modellen på det. Sonnet hanterar nästan allt annat. Kostnadsgapet mellan dem är tillräckligt stort för att "jag kör Opus för säkerhets skull" är den dyraste vanan du kan lämna på autopilot.

5. Automatisera sånt du gör för hand

När friktionskällorna är borta är nästa lager arbetet du fortfarande gör manuellt.

Schemalagda uppgifter

Det är enklare än att lista ut hur man låter bli. Två funktioner täcker det mesta: /loop för återkommande kontroller du annars skulle vakta, och hooks för garantier du inte får via en CLAUDE.md‑instruktion.

/loop kör om en prompt eller ett slash‑kommando enligt ett återkommande schema. Syntaxen har två former:

• /loop 5m <prompt> kör prompten var 5:e minut

• /loop <prompt> ensamt lämnar takten till modellen, som bestämmer när det ska köras igen

Intervallenheter är s, m, h och d, med en minuts minimum. Du behöver Claude Code v2.1.72 eller senare.

Till exempel kan du ställa in en test‑watcher: /loop 2m run the test suite and report failures. Istället för att minnas att köra tester efter varje ändring (och glömma hälften av gångerna) fångar Claude ett trasigt test vid nästa 2‑minuters‑tick.

Samma mönster funkar för en staging‑deploy‑poll (/loop 10m check if the staging deploy is green) eller en loggtail under ett fladdrigt incidentförlopp (/loop 1m tail the last 50 lines of app.log and flag errors).

Loopar lever i 7 dagar.

Uppgiften körs en sista gång dag sju och raderar sig själv. De är sessionskopplade, så --continue eller --resume tar tillbaka dem om du stänger och öppnar igen. För att stoppa en loop i förtid, tryck Esc. Om du behöver schemaläggning som överlever stängd session (en nattlig kontroll, en veckosammanställning), använd Routines via /schedule istället.

Hooks

Hooks är den andra halvan. De kör shell‑kommandon vid specifika punkter i Claudes arbetsflöde, konfigurerade i .claude/settings.json. 

Skälet att välja en hook istället för en CLAUDE.md‑instruktion är en sak: CLAUDE.md är rådgivande, och hooks garanteras köras. Klassikerfallet är "kör alltid lintern efter redigering"‑regeln som Claude hoppar över halva gångerna. En hook stänger det gapet.

Sex händelser täcker de flesta fall:

En minimal PostToolUse‑hook som lintar efter varje filredigering:

{
  "hooks": {
	"PostToolUse": [
  	{
    	"matcher": "Edit|Write",
    	"hooks": [
      	{ "type": "command", "command": "/path/to/lint-check.sh" }
    	]
  	}
	]
  }
}

En fallgrop värd att memorera: endast exit‑kod 2 blockerar faktiskt Claude. Exit 1 behandlas som ett icke‑blockerande fel, och Claude fortsätter ändå, även om 1 brukar vara Unix standard för fel. Om din hook ska upprätthålla en regel, returnera 2.

Du behöver inte heller skriva hooks för hand.

Prompta Claude med "write a hook that runs ruff after every file edit" så skissar den JSON:en åt dig. /hooks listar varje aktiv hook‑konfiguration, så du slipper greppa inställningsfiler när något triggas oväntat. För hela händelsekatalogen och JSON‑scheman för stdin/stdout, se min handledning om Claude Code‑hooks.

6. Håll koll på vad allt detta kostar

Loopar, långa sessioner och Opus‑som‑default bränner tokens. Tre kommandon gör förbrukningen tillräckligt synlig för att hantera, och vanan du vill ha är att kasta ett öga på dem, inte att konfigurera dem.

/usage visar din plannivå, sessionstotaler, kostnadsuppdelning per modell och förloppsindikatorer för 5‑timmars‑ och veckovisa rate‑limit‑fönster.

/context visualiserar det aktuella kontextfönstret som ett färgat rutnät, med kapacitetsvarningar och förslag på vilka verktyg eller filer som tar plats. Använd det när en session känns tung och du ska välja mellan /compact och /clear.

/statusline konfigurerar en beständig rad längst ner i din terminal. Den kan visa modell, kontextprocent, rate‑limit‑fönster och allt annat du kan läsa från sessionens JSON. Det är den som mest förändrar beteenden, eftersom den placerar kostnadsrelevanta siffror i ditt perifera seende medan du jobbar.

Du kan köra /statusline och beskriva på vanlig svenska vad du vill visa, så genererar Claude skriptet och uppdaterar inställningarna. Det andra alternativet är att skriva ett shell‑skript själv och peka på det från ~/.claude/settings.json:

{
  "statusLine": {
	"type": "command",
	"command": "~/.claude/statusline.sh"
  }
}

För uppföljning på längre sikt över sessioner är npx ccusage ett community‑verktyg som aggregerar token‑förbrukning över tid. Det är tredjepart, inte byggt av Anthropic, men fyller gapet mellan sessionskopplad /usage och din månadsfaktura.

7. Tre saker till som är värda att känna till

De sex uppgraderingarna ovan är dem jag använder varje dag. De tre nedan är riktiga funktioner jag använder mer sällan, men som du bör veta finns, så att du kan plocka fram dem den dag du behöver dem.

Använda push‑to‑talk med /voice

/voice slår på push‑to‑talk‑diktering. Håll Space, prata, släpp och den transkriberade texten landar i promptinmatningen. Du behöver v2.1.69 eller senare, och tjugo språk stöds.

Röst slår ofta tangentbord när du går och tänker högt eller dikterar intention i början av en uppgift innan formuleringen satt sig. Det är sämre för redigering på radnivå, där "ändra rad 47 till..." är enklare att skriva.

Hämta molnsessioner med /teleport

/teleport (alias /tp) hämtar en molnsession till din lokala terminal. Säg att du startade en lång uppgift i webbappen eller iOS‑appen, och nu är du tillbaka vid din laptop. Kör claude --teleport för att öppna en väljare och landa den sessionen i din terminal med rätt branch redan utcheckad.

Några krav måste linjera:

• Ren git‑status
• Rätt repo
• Samma claude.ai‑konto som körde molnsessionen
• Branchen var pushad till remote

Blanda inte ihop --teleport med --resume. Det senare öppnar bara lokala sessioner från den här maskinens historik. För en djupare genomgång täcker vår handledning om fjärrstyrning av Claude Code resten.

Ställa följdfrågor med /btw

/btw är för den snabba frågan du vill ställa utan att bryta flödet.

Tänk att Claude är mitt i en uppgift. Du har redan startat en lång redigering eller ett verktygskall, och du behöver plötsligt veta regexen för att matcha IP:er eller vilken flagga som gör X. 

Du kan bara skriva /btw <question>, så dyker svaret upp i ett avfärdbart överlägg. Uppgiften som pågår fortsätter, svaret hamnar aldrig i konversationshistoriken, så du behöver inte starta en ny session för en engångsfråga och du smutsar inte ner din nuvarande.

Slutsats

Det snabbaste sättet att tappa allt i den här artikeln är att testa allt på en dag. Välj två eller tre, bygg muskelminne för dem och lägg till resten senare när den första uppsättningen sitter.

Tre att börja med, var och en för en annan del av dagen, så att de inte tränger ut varandra:

• En stram projekt‑CLAUDE.md plus två eller tre wildcard‑behörighetsregler i .claude/settings.json för bash‑kommandon du godkänner på nytt varje session. Det här är morgonens setup‑vana, och du märker den först när avbrotten upphör.

• Valet mellan /compact och /clear och Esc+Esc‑återspolningsväljaren. Det här är vanan mitt i sessionen, och signalen är stunden då Claude frågar igen efter en filsökväg den kände till för en timme sedan.

• En /loop för en återkommande kontroll som redan tar din tid. Det här är bakgrundsvanan, och när den väl är igång ger den avkastning av sig själv.

Om skillnaden mellan Sonnet, Opus och Haiku fortfarande känns dim, vår kurs Introduction to Claude Models går igenom när varje modell passar. Det gör /effort- och /model-anropen mycket enklare.