Claude Code-minne: guiden till beständig kontext

Varje Claude Code-session börjar likadant: inget minne av igår. Du spenderar tjugo minuter på att förklara ditt API:s autentiseringsflöde på måndag, och på tisdag förklarar du det igen, för inget om hur modellen fungerar för det vidare på egen hand. Det gapet är den enskilt mest efterfrågade fixen vi hör från team som kör Claude Code dagligen, och det är också det mest missförstådda, för "ge Claude minne" är inte en funktion. Det är fyra mekanismer med olika jobb, kostnader och fellägen.

Den här guiden reder ut dem: vad varje lager faktiskt löser, vad som hör hemma i vilket, hur man sätter upp en minnesskill som claude-mem, och tokenmatematiken som förklarar varför att komma ihåg är billigt medan att återupptäcka samma fakta varje session inte är det.

Groundhog day-problemet

En språkmodell har inget tillstånd mellan API-anrop. Varje meddelande du skickar inkluderar hela konversationen hittills, och när den konversationen slutar, gör allt modellen "visste" om ditt projekt det också. Öppna en ny session imorgon och du är tillbaka till en tom tavla, oavsett vilka filer som råkar ligga på disk.

Det skulle vara okej om sessioner var korta och självständiga. Det är de inte. Riktigt arbete spänner över dagar: du fixar en bugg på måndag, samma mönster dyker upp i en annan fil på torsdag, och agenten har inget sätt att koppla de två om inte något utanför konversationen förde den kopplingen vidare. Varje session utan det betalar en återupptäcktsskatt: läsa samma filer, återlära samma konventioner, ibland upprepa ett misstag den redan fixat.

Fixen är inte ett större kontextfönster. Kontextfönster är redan stora, och problemet är inte kapacitet, det är kontinuitet. Vad du vill ha är en plats utanför konversationen där fakta och beslut överlever, plus ett sätt för Claude att ladda rätt bit av den platsen tillbaka när det spelar roll. Det är minne, och Claude Code ger dig fyra sätt att bygga det.

De fyra lagren av Claude-minne

Lager ett är CLAUDE.md: statiska projektfakta du skriver en gång, som laddas i sin helhet vid varje sessionstart. Lager två är auto-minne, en katalog med filer Claude skriver till sig själv, ackumulerande fakta över tid utan att du författar dem för hand. Lager tre är minnesskills, som fångar och komprimerar sessionskontext automatiskt och injicerar den tillbaka senare. Lager fyra är lågteknologialternativet: en vanlig anteckningsfil agenten läser och uppdaterar för att du sa åt den.

De är inte konkurrerande alternativ. De löser olika problem, och de flesta seriösa uppsättningar kör två eller tre samtidigt.

Lager 1: CLAUDE.md, statiska fakta som alltid laddas

CLAUDE.md är Claude Codes äldsta och enklaste minnesmekanism. Det är en markdown-fil Claude Code hittar genom att gå uppåt från din arbetskatalog, och den laddas i sin helhet, varje session, innan du skrivit något. Det gör den till rätt plats för fakta som nästan alltid är sanna: hur man kör testerna, vilken pakethanterare repot använder, vilken mapp som är föråldrad och förbjuden.

Det är fel plats för allt som ändras ofta eller gäller ibland, för "laddas i sin helhet, varje session" är också dess kostnad. En CLAUDE.md på 3 000 rader är ungefär 30 000 tokens beskattade på varje request, oavsett om den requesten behöver något av det. Vi täcker den fullständiga aritmetiken och ett riktigt kommenterat exempel i vår CLAUDE.md bästa praxis-guide; den korta versionen är att CLAUDE.md vill ha stabila fakta, inte en växande logg.

Det är också där CLAUDE.md tar slut på väg. Den är statisk: du skriver den, Claude läser den, och att uppdatera den är en manuell syssla du måste komma ihåg att göra. De nästa tre lagren finns för att hantera fakta som ackumuleras på egen hand.

Lager 2: auto-minne och minneskataloger

Mellanlagret är en minneskatalog, ofta ~/.claude/memory/ eller en projektlokal motsvarighet, där Claude skriver strukturerade anteckningar om vad den lär sig och läser dem tillbaka vid starten av framtida sessioner. Till skillnad från CLAUDE.md författar ingen de flesta av dessa poster för hand. Agenten bestämmer att något är värt att komma ihåg, ett beslut du fattade, en preferens du uttryckte, ett faktum den fick gräva efter, och arkiverar det med tillräcklig struktur för att hämtas senare.

Det är här Memory Management-skillen bor, och det är den högst rankade skillen i den här kategorin på SkillProof: 9,2 av 10. Vi körde den över en full vecka av riktiga sessioner, inte en enda demokörning, och den höll under faktisk användning. Claude återkallade tillförlitligt projektbeslut och preferenser den lagrat, och återkallningsprecisionen förblev hög även när lagringen växte, delen som vanligtvis går sönder först i naiva implementationer.

Vad som skiljer det här lagret från CLAUDE.md är att det är selektivt på vägen tillbaka in också. En väl byggd minnesskill indexerar vad den lagrat och drar den relevanta biten för aktuell uppgift, så lagringen kan växa till tusentals poster utan att varje session betalar för alla av dem.

Lager 3: minnesskills, claude-mem och automatisk fångst

Det tredje lagret tar idén längre. I stället för att Claude bestämmer mitt i konversationen vad som är värt att spara, fångar en dedikerad skill hela sessionen automatiskt, komprimerar den, och injicerar den relevanta kontexten tillbaka i nästa. Claude-mem är det tydligaste exemplet på det här mönstret. Dess pitch är "beständig kontext över sessioner för varje agent": den bevakar vad din agent gör under en session, komprimerar den aktiviteten med en AI-sammanfattningspass, och lyfter fram den komprimerade versionen nästa gång den är relevant, över Claude Code och, enligt sin egen dokumentation, flera andra agent-runtimes.

Vi bör vara raka om var den står i vår testning. Claude-mem dök upp genom vår GitHub-crawler med 85 685 stjärnor, vilket är varför den är köad för ett fullständigt test snarare än att redan bära en dom; vi publicerar inte en poäng förrän vi installerat en skill rent och kört den mot riktigt arbete, samma ribba Memory Management redan klarade. Vad vi kan säga nu är arkitektoniskt: automatisk fångst tar bort ögonblicket där du annars skulle stanna upp och bestämma, mitt i sessionen, om något är värt att komma ihåg. Skillen bestämmer åt dig. Om det håller över en full vecka på en ren maskin är vad testkön finns för att svara på.

Lager 4: vanliga filer som minne

Det sista lagret behöver ingen skill alls: en vanlig markdown-fil, oftast kallad något i stil med notes.md eller progress.md, som du ber Claude läsa vid sessionsstart och uppdatera i slutet. Ingen indexering, ingen automatisk fångst, ingen poängsättning. Du är minnessystemet; filen är bara där du skriver ner det.

Det här lagret underskattas för det låter för enkelt för att spela roll. Det gör det inte. För ett soloprojekt med en bidragsgivare och en handfull pågående trådar slår en anteckningsfil du faktiskt underhåller ett automatiserat minnessystem du aldrig tittar på. Fellöget ligger helt hos dig dock: ingen beskär den, ingen flaggar motsägelser, och den växer till en vägg av text med samma blinda fläckar vilket ounderhållet dokument som helst utvecklar. Den fungerar exakt så bra som din disciplin om att uppdatera den, inte bättre.

Vad hör hemma var: beslutstabellen

Minnestyp	Bäst för	Laddas	Underhåll
CLAUDE.md	Stabila, alltid-sanna fakta (byggkommandon, konventioner, fallgropar)	I sin helhet, varje session	Manuellt, redigera för hand
Auto-minne / minneskatalog	Beslut och preferenser som ackumuleras över tid	Selektivt, vid hämtning	Mestadels automatiskt (skill-hanterat)
Minnesskills (claude-mem)	Full sessionskontext, fångad utan att du bestämmer vad som spelar roll	Komprimerad, injicerad vid relevans	Automatisk fångst, tillfällig granskning
Vanlig anteckningsfil	Soloprojekt, enkla pågående trådar	Manuellt, du säger åt Claude att läsa den	Fullt manuellt

Läs den tabellen efter vad som ändras, inte efter vad som är bekvämt att sätta upp. Om ett faktum fortfarande skulle vara sant om sex månader hör det hemma i CLAUDE.md. Om det är ett beslut fattat den här veckan som kan spela roll igen senare hör det hemma i minne. Om du inte kan förutsäga vad du behöver komma ihåg och inte vill bestämma i stunden, det är fallet för automatisk fångst. Om inget av det gäller slår en anteckningsfil ändå ingenting.

Att sätta upp claude-mem, steg för steg

Det generella mönstret för en automatisk-fångst-minnesskill ser ut så här, med claude-mem som det konkreta exemplet:

1. Klona skillen. git clone https://github.com/thedotmack/claude-mem in i en arbetskatalog, följ sedan repots installationsskript i stället för att kopiera filer för hand. Minnesskills behöver oftast registrera en hook, inte bara släppa en SKILL.md på plats.

2. Starta om Claude Code. Installationen kopplar oftast en session-start- eller session-end-hook så fångst sker utan att du anropar något. En omstart är vad som fångar upp det.

3. Kör en normal session. Testa den inte med en leksaksuppgift. Gör riktigt arbete; poängen är att se vad den bestämmer är värt att komma ihåg när ingen bevakar för testet.

4. Starta din nästa session och kolla vad som kom tillbaka. Fråga Claude vad den kommer ihåg om gårdagens arbete innan du säger något annat. Något specifikt och korrekt betyder att fångst fungerar. Något vagt eller fel betyder kolla konfigurationen innan du litar på den med något som spelar roll.

5. Sätt en granskningsrytm. Automatisk fångst utan granskning förvandlas till automatisk ackumulering av brus. Ge dig själv en återkommande tioinutersslot för att skumma vad som lagrats (mer om det under minneshygien nedan).

Om du hellre börjar med något redan poängsatt är Memory Management den manuella-men-testade vägen: installera skill-mappen i ~/.claude/skills/, och den skapar sin egen minneskatalog vid första användning, ingen separat hook-installation krävs.

Tokenekonomin för minne

Här är matematiken som gör minne värt uppsättningskostnaden. Säg att ett projektfakta tar 500 ord att förklara från grunden: formen på ditt autentiseringsflöde, varför en viss tabell har två främmande nycklar, vad deploy-skriptet faktiskt gör. Förklarat färskt i chatt är det ungefär 650 tokens av input varje gång du förklarar om det, ovanpå tiden du spenderar på att skriva det och tiden Claude spenderar på att resonera över det i det meddelandet.

Lagrat i minne i stället kostar samma faktum de 650 tokens en gång, att skriva. Hämtning efteråt kostar en bråkdel av det: ett väl indexerat minneslager drar en komprimerad sammanfattning, ofta under 100 tokens, bara när aktuell uppgift rör det faktumet. Förklara det i chatt fem gånger över en månad och du har spenderat ungefär 3 250 tokens på att återlära vad minne skulle kostat 650 tokens att lära sig och 500 totalt att återkalla fem gånger: ett grovt fem-till-ett-gap som breddas ju oftare faktumet behövs.

Jämför det med att stoppa allt i CLAUDE.md i stället: ett faktum relevant en session av tjugo laddas fortfarande de andra nitton, utan selektivitet att återta den kostnaden. Den fasta preambeln din uppsättning bär på varje vändning (CLAUDE.md, verktygsscheman, minnesinjektioner) konkurrerar direkt med ditt faktiska arbete om utrymme och uppmärksamhet. Vi mätte det här mer djupgående, med riktiga före/efter-tokenantal, i vår tokenkostnadsguide; minne är en post i den större bilden, ofta den billigaste fixen relativt vad den sparar.

Minneshygien: granskningsritualen

Ett minnessystem som bara ackumulerar är inte en funktion, det är en långsam läcka. Inaktuella poster misslyckas inte högljutt; inget kraschar när Claude återkallar ett beslut du reverserade för tre veckor sedan. Den agerar bara tyst på inaktuell information, och du bränner felsökningstid på att räkna ut varför agenten är säkert fel om något du vet att du fixade.

Kör en månatlig genomgång, tio minuter, samma disciplin som CLAUDE.md-granskningsritualen vi rekommenderar på annat håll. Öppna minneslagringen. För varje post som ser bärande ut, fråga om den fortfarande är sann, om ett beslut den beskriver reverserats sedan dess, och om den är specifik nog att agera på. Radera allt som misslyckas. En minneslagring du är stolt över är mindre ett år in än den var tre månader in; tillväxten ska vara i precision, inte volym.

Den mest tillförlitliga utlösaren för en granskning är inte kalendern dock. Det är stunden Claude gör något fel på grund av ett inaktuellt minne. Behandla det som en bugg: fixa posten i samma andetag som misstaget, inte vid din nästa schemalagda genomgång.

Integritet: vad fångas, var det bor

Minnesskills läser vad som händer i dina sessioner, så den ärliga frågan är vad som fångas och var det hamnar. För filbaserat minne, Memory Management, claude-mem, och den vanliga anteckningsansatsen likadant, är svaret oftast detsamma: allt skrivs till vanliga filer på din egen disk, oftast under ~/.claude/ eller en projektlokal minnesmapp, inte till en tredjepartsserver. Inget lämnar din maskin om du inte committar de filerna till ett delat repo eller en skill explicit dokumenterar en fjärrsynkroniseringsfunktion.

Det är goda nyheter för kontroll och dåliga nyheter för att anta att det automatiskt är säkert. En minnesfil är en klartextredogörelse för vad du jobbade på, och den kan inkludera autentiseringsuppgifter nämnda i förbifarten, klientnamn, eller arkitekturdetaljer du inte skulle vilja ha i ett publikt repo. Läs vad som faktiskt finns i en minneskatalog innan du committar den tillsammans med din kod, och innan du installerar någon minnesskill, kolla dess källkod för vad "fångar allt din agent gör" faktiskt betyder, inklusive om kommandoutput som innehåller hemligheter sopas in också. Automatisk fångst förtjänar samma granskning som vilket verktyg som helst som läser din terminal.

Vanliga frågor

Har Claude Code inbyggt beständigt minne?

Delvis. CLAUDE.md ger dig statiskt, alltid laddat minne direkt ur lådan, och det är genuint inbyggt, ingen installation krävs. Allt bortom statiska fakta, minne som ackumuleras, indexeras, och hämtas selektivt, kommer för närvarande från en skill snarare än en nativ funktion.

Vad är skillnaden mellan CLAUDE.md och en minnesskill?

CLAUDE.md laddas i sin helhet, varje session, och du underhåller den för hand. En minnesskill skriver och läser en växande lagring selektivt, drar bara vad som är relevant för aktuell uppgift, och mycket av skrivandet sker utan att du gör det manuellt. Använd CLAUDE.md för fakta som aldrig ändras; använd en minnesskill för fakta som ackumuleras.

Är claude-mem säkert att installera just nu?

Vi kan inte ge det en dom än. Den är i vår testkö, inte poängsatt, trots sin stora följarskara på GitHub. Installera den som du skulle installera vad som helst opoängsatt: på ett projekt du har råd att experimentera i först, och läs källkoden innan du litar på den med känsliga sessioner.

Hur mycket kostar det i tokens att köra en minnesskill?

Mindre än alternativet i nästan alla fall. Lagringen själv är nästan gratis eftersom den bor på disk, inte i kontext. Hämtning vid sessionsstart kostar oftast betydligt mindre än att förklara om samma faktum i chatt, och gapet breddas ju fler gånger det faktumet annars skulle behöva förklaras om.

Ska jag använda mer än ett minneslager samtidigt?

Ja, och de flesta fungerande uppsättningar gör det: CLAUDE.md för fakta som aldrig ändras, plus antingen en minnesskill eller en disciplinerad anteckningsfil för fakta som ackumuleras. Behandla dem som kompletterande snarare än att välja en favorit. Poängen är att matcha varje typ av faktum till lagret byggt för det, inte att bestämma sig för en mekanism för allt.