# En instruktionsfil för Claude Code, Codex och Cursor 2026
> En källa till sanning för Claude Code, Codex och Cursor 2026: när Claude Code läser AGENTS.md direkt, import av @AGENTS.md i CLAUDE.md, en symbolisk länk och /init.
Source: https://ailoot.ai/blog/sv/agents-md-claude-md-one-instruction-file/
Canonical: https://ailoot.ai/blog/sv/agents-md-claude-md-one-instruction-file/
Language: sv
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-004
Revision: sha256-8c11fc23cdc72f7e6b687963c426f114d7a1ceeea3bca53ced23eff7114bce7b
Information om tjänsten finns i [Ailoot-dokumentationen](https://ailoot.ai/docs/).
## Vad förändras när du använder Claude Code, Codex och Cursor tillsammans?
Det viktigaste
År 2026 består en typisk vibe-kodares verktygsuppsättning inte av ett enda verktyg, utan av 3–5. Claude Code som huvudverktyg, Codex för långa autonoma uppgifter och Cursor för snabba redigeringar i IDE:n. Var och en har sin egen instruktionsfil: `CLAUDE.md`, `AGENTS.md`, `.cursorrules`. Om du håller dem synkroniserade manuellt redigerar du en rad på fem ställen, glömmer att uppdatera Cursor, och en vecka senare ger Claude och Codex olika resultat på samma prompt.
I exemplet som beskrivs är Claude Code huvudverktyget, medan Codex och Cursor används för specifika uppgifter. Min `CLAUDE.md` har ungefär 250 rader instruktioner: vad som ska läsas och i vilken ordning, vad som inte får röras, vilka kommandon som ska användas för driftsättning och reglerna för commit-format. När jag först provade Codex CLI i projektet kände det inte till några av reglerna: det körde `git push --force`, rotade runt i `.env` och döpte om filer vårdslöst.
Jag kopierade först `CLAUDE.md` till `AGENTS.md` för hand. Två veckor senare upptäckte jag att projektet redan hade fyra versioner av samma instruktion: i `CLAUDE.md`, `AGENTS.md`, `.cursorrules` och `.windsurf/rules/`. De skilde sig alla åt lite grann. Det här är inte ett Claude- eller Cursor-problem; det är den grundläggande fallgropen i alla system med flera källor till sanning. Jag diskuterar problemet mer ingående i [guiden om arbete med flera agenter](https://ailoot.ai/blog/sv/claude-code-codex-together/).
I juni 2026 gav Anthropics dokumentation om minne i Claude Code ett svar: en delad fil plus en import. Sedan september 2026 läser Claude Code `AGENTS.md` direkt om projektet saknar `CLAUDE.md`, och en import behövs när du har regler som är specifika för Claude. Nedan förklarar jag när en enda `AGENTS.md` räcker, hur du konfigurerar en import och hur du skiljer delade regler från Claude-specifika.
## Läser Claude Code AGENTS.md direkt?
Det viktigaste
Ja, från och med version 2.1.277, som släpptes den 18 september 2026, men bara om det inte finns någon `CLAUDE.md`, `.claude/CLAUDE.md` eller `CLAUDE.local.md` i arbetskatalogen eller ovanför den. Om `CLAUDE.md` finns läser Claude Code som standard bara den filen, och `AGENTS.md` inkluderas med raden `@AGENTS.md` i `CLAUDE.md` eller med en symbolisk länk. Beteendet ändras i `/config`, under Project instructions. Före september läste Claude Code inte `AGENTS.md` alls, och import var det enda sättet.
Före september 2026 var svaret ”nej”. Issue \#6235, där stöd för AGENTS.md efterfrågades, hade varit öppen sedan augusti 2025 och stängdes den 17 augusti 2026. Dokumentationen om minne pekade på en lösning hela tiden: skapa en CLAUDE.md och inkludera `AGENTS.md` i den som en import. Från och med version 2.1.277 säger dokumentationen något annat:
Claude Code kan läsa AGENTS.md som projektinstruktioner, så ett kodförråd som redan är konfigurerat för andra agenter fungerar utan CLAUDE.md, import eller konfiguration.
— Anthropic, https://code.claude.com/docs/en/memory#agents-md
Exakt vad Claude Code läser beror på vilka filer som finns i projektet:
| Filer i projektet | Vad Claude Code läser |
|----|----|
| `AGENTS.md`, utan `CLAUDE.md` eller `CLAUDE.local.md` i arbetskatalogen eller ovanför den | `AGENTS.md` |
| `AGENTS.md` och `CLAUDE.md` (eller `CLAUDE.local.md`) i arbetskatalogen eller ovanför den | Endast `CLAUDE.md` |
| `CLAUDE.md` med raden `@AGENTS.md` | `CLAUDE.md` och `AGENTS.md` inuti den via importen |
För den här kontrollen räknas `CLAUDE.md`, `.claude/CLAUDE.md` och `CLAUDE.local.md` i arbetskatalogen och i alla kataloger ovanför den. En personlig `~/.claude/CLAUDE.md`, en centralt hanterad företagsfil och regler från `.claude/rules/` räknas inte: de läses in tillsammans med `AGENTS.md`.
När det inte finns någon `CLAUDE.md` läser Claude Code alla `AGENTS.md`- och `.claude/AGENTS.md`-filer i arbetskatalogen och ovanför den vid start, och hämtar in en `AGENTS.md` i en underkatalog när programmet öppnar en fil i den underkatalogen. `@path`-importer inne i `AGENTS.md` fungerar också. Claude Code läser inte `AGENTS.local.md`, `AGENTS.override.md` eller innehållet i katalogen `.agents/`.
Fallgropen: även en personlig `CLAUDE.local.md` räknas. Skapa en sådan för att behålla dina ocommittade regler, så slutar Claude Code tyst att läsa `AGENTS.md`. Inställningen nedan är lösningen.
Beteendet ändras i `/config`, under Project instructions:
| Inställning | Vad Claude Code läser |
|----|----|
| `claude-md-or-agents-md` (standard) | `CLAUDE.md`, eller, om varken den eller `CLAUDE.local.md` finns, `AGENTS.md` |
| `claude-md-and-agents-md` | Båda filerna: i varje katalog först `CLAUDE.md`, sedan `AGENTS.md` |
| `claude-md` | Endast `CLAUDE.md` |
| `managed-only` | Endast företagets centralt hanterade `CLAUDE.md` och automatiskt minne |
Om du vill behålla `CLAUDE.local.md` utan att förlora `AGENTS.md` ställer du in `claude-md-and-agents-md`. Ingen dubbelläsning sker: om `AGENTS.md` redan inkluderas via raden `@AGENTS.md` eller en symbolisk länk läser Claude Code inte in den en andra gång, oavsett inställning.
Du kan kontrollera om filen har lästs in med kommandot `/memory`: från och med version 2.1.280 visas sökvägen till `AGENTS.md` i listan. I versioner före 2.1.277 och i sessioner där det inbyggda plugin-programmet `agents-md` är inaktiverat läser Claude Code bara `CLAUDE.md`, och det finns ingen post för Project instructions i `/config`. Före version 2.1.281 fungerade sessioner via Amazon Bedrock och sessioner med telemetri inaktiverad på samma sätt. I den första sessionen efter uppdatering från en äldre version kan `AGENTS.md` också utebli; det fungerar från och med nästa session.
Vad betyder det här för en konfiguration med en fil? Om du inte har regler som bara gäller Claude kan du hoppa över `CLAUDE.md`: `AGENTS.md` räcker, och Claude Code, Codex och Cursor läser den. Om du har sådana regler (planläge för riskfyllda kataloger, skills, hooks) behöver du `CLAUDE.md`, och då slutar Claude Code att läsa `AGENTS.md` på egen hand. Inkludera då `AGENTS.md` i `CLAUDE.md` med raden `@AGENTS.md`; den här konfigurationen fungerar precis som före september. Den fungerar också med äldre versioner av Claude Code. Jag förklarar det i detalj nedan.
## Hur importerar du @AGENTS.md i CLAUDE.md?
Det viktigaste
En import behövs när projektet har en `CLAUDE.md`: om den finns läser Claude Code som standard inte `AGENTS.md` på egen hand. För att konfigurera det skriver du raden `@AGENTS.md` högst upp i filen `CLAUDE.md`. När Claude Code startar en session infogar det innehållet i `AGENTS.md` där raden står och läser resultatet som en enda text. Under importen kan du lägga till ett avsnitt med rubriken ”Claude Code” med regler som bara gäller Claude. Importer fungerar med relativa och absoluta sökvägar och kan nästlas upp till fyra nivåer.
Ett minimalt fungerande exempel från den officiella dokumentationen:
```markdown
@AGENTS.md
## Claude Code
Use plan mode for changes under `src/billing/`.
```
Så här fungerar det. Den första raden, `@AGENTS.md`, är en importinstruktion. När Claude Code tolkar `CLAUDE.md` i början av en session hittar det importen och infogar hela innehållet i `AGENTS.md` där den står. Därefter kommer rubriken `## Claude Code`: den är bara markdown, men fungerar som ett avsnitt med ”Claude-specifika tillägg”. Under den finns en regel som bara gäller Claude Code: använd planläge för ändringar i faktureringskatalogen. Codex CLI eller Cursor öppnar inte den här filen alls; de använder den vanliga `AGENTS.md`.
Ett citat ur dokumentationen om hur importer fungerar:
CLAUDE.md-filer kan importera ytterligare filer med syntaxen @path/to/import. Importerade filer expanderas och läses in i kontexten vid sessionsstart tillsammans med den CLAUDE.md-fil som hänvisar till dem.
— Anthropic, https://code.claude.com/docs/en/memory
Några praktiska detaljer:
- **Relativa och absoluta sökvägar.** `@AGENTS.md` är relativ till filen som innehåller importen. `@/Users/me/shared/rules.md` eller `@~/.claude/personal.md` är absoluta. Jag använder `@~/.claude/personal.md` för personliga preferenser som jag inte vill lägga i kodförrådet.
- **Fyra nivåers djup.** `AGENTS.md` kan importera `@docs/coding-style.md`, och `coding-style.md` kan importera ytterligare en fil, upp till fyra nivåer. Det räcker för alla verkliga strukturer.
- **Backticks blockerar importer.** Om texten säger `` `@README` `` är det bara ett omnämnande av namnet, inte en import. Det är användbart när du förklarar för läsare hur importer fungerar utan att utlösa en.
- **Godkännande för filer utanför projektet.** Om en import pekar utanför arbetskatalogen, som `@~/.claude/personal.md`, visar Claude Code en dialog med en lista över de filerna första gången. Om du tackar nej förblir externa importer inaktiverade och dialogen visas inte igen. `@AGENTS.md` i projektets rot utlöser ingen dialog. Det skyddar dig från att av misstag läsa in en orelaterad fil i kontexten.
Efter att jag bytte till den här konfigurationen i det beskrivna projektet minskade min `CLAUDE.md` från 250 rader till 60: `@AGENTS.md` plus fem till sju regler som bara gäller Claude Code (planläge för riskfyllda kataloger, vad man inte ska röra i adminområdet och hur commits ska formuleras). Allt som delas ligger i `AGENTS.md`, som Codex och Cursor läser.
## När bör du välja en symbolisk länk och när en import?
Det viktigaste
Anthropic erbjuder två mekanismer: en import via `@AGENTS.md` eller en symbolisk länk, `ln -s AGENTS.md CLAUDE.md`. En symbolisk länk är enklare – det är bara ett alias och kräver inga filändringar. Men den har tre nackdelar: Windows kräver administratörsbehörighet, du kan inte lägga till Claude-specifika regler i `CLAUDE.md`, och Git visar ibland en symbolisk länk som skräp i diffen. Import är den universella metoden. Om du inte har regler som bara gäller Claude behöver du sedan version 2.1.277 ingetdera: Claude Code läser `AGENTS.md` direkt.
Dokumentationen visar alternativet med symbolisk länk så här:
```bash
ln -s AGENTS.md CLAUDE.md
```
Och direkt därefter ger den en uppriktig varning om Windows:
Om du eller någon annan som klonar kodförrådet arbetar på Windows bör du använda importen @AGENTS.md. Att skapa en symbolisk länk där kräver administratörsbehörighet eller Developer Mode, och Git utan aktiverat core.symlinks checkar ut en incheckad länk som en vanlig textfil, vilket lämnar en `CLAUDE.md` på en rad i stället för instruktionerna i den kopian.
— Anthropic, https://code.claude.com/docs/en/memory
Jämförelsetabell:
| Kriterium | Importen `@AGENTS.md` | Symbolisk länk `ln -s` |
|----|----|----|
| **Fungerar på Windows utan administratörsbehörighet** | ja | nej (Developer Mode krävs) |
| **Kan lägga till regler som bara gäller Claude** | ja, efter importen | nej, filen är identisk |
| **Visas i Git som vanlig markdown** | ja | som en länk (beror på `core.symlinks`) |
| **Kan importera flera filer** | ja, upp till fyra nivåer | nej, en-till-en |
| **Cache/ogiltigförklaring i Claude Code** | standard för CLAUDE.md | fungerar, men symboliska länkar har metaproblem |
| **Standardval** | passar alla | endast om plattformsoberoende användning inte spelar någon roll |
Jag använder importer i det beskrivna projektet. Skälen:
1. **Teamet använder olika plattformar.** Jag använder Mac; i exemplet är teamet ungefär jämnt fördelat mellan Windows och Mac. Om en symbolisk länk finns i kodförrådet checkas den ut som en vanlig textfil med en enda rad, `AGENTS.md`, för Windows-användare utan Developer Mode. Det skapar märkliga buggar: ibland fungerar reglerna, ibland inte, och det är oklart varför.
2. **Jag vill ha Claude-specifika regler.** Under `@AGENTS.md` har min `CLAUDE.md` ett avsnitt med rubriken ”Claude Code” och regler: använd `--effort high` för arkitekturuppgifter, kör `npm run build` före `git push` och anropa inte `/api/v1/deploy` för hand. Codex förstår inte de här kommandona.
3. **Det är enklare att felsöka.** När något går fel öppnar jag `CLAUDE.md` och ser importen och mina åsidosättningar. En symbolisk länk har inget ”det här lades till här”. Mer om felsökning av Claude Code-inställningar finns i [guiden om säkert läge](https://ailoot.ai/blog/sv/claude-code-safe-mode-recovery/).
Om du inte har Claude-specifika regler behövs ingen symbolisk länk från och med version 2.1.277: ta bort `CLAUDE.md`, så läser Claude Code `AGENTS.md` direkt. Behåll den symboliska länken bara om någon i teamet använder en version äldre än 2.1.277 och inte kan uppdatera. Om du har Claude-specifika regler är en import smidigare i nio fall av tio.
## Vad läser Codex, Cursor, Copilot, Windsurf och Gemini CLI?
Det viktigaste
Varje verktyg läser sin egen fil, ibland fler än en. Claude Code läser `CLAUDE.md` och har sedan september 2026 också läst `AGENTS.md` om projektet saknar `CLAUDE.md`. Codex CLI läser `AGENTS.md` plus `AGENTS.override.md`. Cursor läser det äldre formatet `.cursorrules` eller det nyare `.cursor/rules/*.mdc`, och sedan sommaren 2026 läser det även `AGENTS.md`. Copilot läser `.github/copilot-instructions.md` eller `.github/instructions/*.instructions.md`. Windsurf läser det äldre `.windsurfrules` eller den nyare `.windsurf/rules/`. Gemini CLI läser `GEMINI.md`. Aider och Cline har redan infört stöd för `AGENTS.md`.
En översikt över de sju huvudverktygen (baserad på varje verktygs officiella dokumentation):
| Verktyg | Huvudsaklig instruktionsfil | Alternativ | Läser AGENTS.md? |
|----|----|----|----|
| **Claude Code** | `CLAUDE.md` | `~/.claude/CLAUDE.md`, `./.claude/CLAUDE.md`, hanterad policy | ja, om projektet saknar `CLAUDE.md` (sedan 2.1.277), annars via en import |
| **Codex CLI** (OpenAI) | `AGENTS.md` | `AGENTS.override.md` | ja (inbyggt) |
| **Cursor** | `.cursor/rules/*.mdc` | `.cursorrules` (föråldrat) | ja |
| **GitHub Copilot** | `.github/copilot-instructions.md` | `.github/instructions/*.instructions.md` | via tillägg |
| **Windsurf** | `.windsurf/rules/` | `.windsurfrules` (föråldrat) | ja |
| **Gemini CLI** | `GEMINI.md` | \- | nej |
| **Aider, Cline, opencode** | `AGENTS.md` | \- | ja (inbyggt) |
Vad innebär det här? Om ett kodförråd har `AGENTS.md` (plus en `CLAUDE.md` med import när Claude-specifika regler behövs) får fem av de sju verktygen automatiskt uppdaterade instruktioner. Cursor och Windsurf, som har egna inbyggda filer, kan antingen lämnas som de är (`AGENTS.md` läses också av dem) eller få en `@AGENTS.md`-import tillagd – men deras syntax skiljer sig åt och stöds inte alltid.
Den enklaste strategin för ett nytt projekt:
1. **Lägg alla delade regler i `AGENTS.md`** – 95 % av reglerna hör hemma där.
2. **Skapa `CLAUDE.md` om du behöver regler som bara gäller Claude:** skriv `@AGENTS.md` på första raden och lägg sedan till ett avsnitt med Claude-specifika regler nedanför. Om det inte finns några sådana regler behövs inte `CLAUDE.md`; sedan version 2.1.277 har Claude Code läst `AGENTS.md` direkt.
3. **Behåll `.cursor/rules/` för Cursor** i de sällsynta fall då något specifikt för Cursor behövs (kommandona `@Codebase` och `@Docs`).
4. **Gör likadant för Windsurf:** glöm det gamla `.windsurfrules`; använd bara det nya `.windsurf/rules/` när du behöver mönster för dess syntax.
Den här metoden ger dig 80 % av nyttan med 20 % av arbetet. Min erfarenhet är att det blir besvärligt att underhålla fler än två källor till sanning (delade regler plus Claude-specifika) när jag hanterade team med olika verktyg i ”Antigravity”. Om någon i teamet lägger till en regel i `.cursorrules` och glömmer `AGENTS.md` kommer Cursor och Codex att vara oense en vecka senare.
## Hur hämtar /init i Claude Code in en befintlig AGENTS.md?
Det viktigaste
`/init` bygger en `CLAUDE.md` utifrån det som redan finns i kodförrådet och sparar 20–30 minuters manuellt arbete. Som standard hämtar det in Cursor-regler (`.cursor/rules/`, `.cursorrules`) och Copilot-regler (`.github/copilot-instructions.md`), medan det läser `AGENTS.md`, `.windsurfrules` och `.clinerules` i läget `CLAUDE_CODE_NEW_INIT=1`. Samma läge startar ett interaktivt flerstegsflöde: det ställer frågor, utforskar koden genom en underagent och föreslår en plan innan det skriver. Sedan september 2026 finns det en nackdel med `/init` i ett projekt med `AGENTS.md`: en ny `CLAUDE.md` inaktiverar direkt läsning av `AGENTS.md`, och reglerna hamnar i två filer.
Anthropic beskriver `/init` så här i sin dokumentation:
När du kör /init läser kommandot andra verktygs instruktionsfiler och flyttar relevanta delar till den genererade CLAUDE.md: Cursor-regler från .cursor/rules/ eller .cursorrules, Copilot-regler från .github/copilot-instructions.mdCLAUDE_CODE_NEW_INIT=1 även AGENTS.md, .devin/rules/, .windsurf/rules/ eller .windsurfrules, samt .clinerules.
— Anthropic, https://code.claude.com/docs/en/memory
Vad innebär det i praktiken? Kodförrådet jag beskrev hade en `.cursorrules` från när jag provade Cursor (ungefär 80 rader) och en `AGENTS.md` (120 rader, sammanställd för hand). När jag körde `claude /init` tog kommandot båda filerna, tog bort liknande regler och sammanställde en ren `CLAUDE.md` på en minut. Jag kontrollerade den efteråt och gjorde mindre ändringar – tog bort inaktuella delar och lade till en struktur med rubriker. Det gick snabbare än att skriva om från grunden.
Det interaktiva läget, där `/init` också läser `AGENTS.md`, aktiveras via en miljövariabel:
```bash
CLAUDE_CODE_NEW_INIT=1 claude
```
När `/init` startar ställer Claude en rad klargörande frågor: vilka artefakter som ska konfigureras (`CLAUDE.md`, skills, hooks), vilken teknikstack projektet använder och vilka kommandon som ska användas för tester. Sedan utforskar en underagent kodbasen – läser `package.json`, `README.md` och konfigurationsfiler – och fyller i det som saknas. Till slut visar den ett förslag som du kan redigera innan det sparas. Mer om hur du konfigurerar Claude Code när du startar ett projekt finns i [den separata guiden](https://ailoot.ai/blog/sv/spec-kit-claude-code-spec-driven-development/).
Nu till nackdelen. Om projektet redan har en aktiv `AGENTS.md` skapar `/init` en `CLAUDE.md` bredvid den med en kopia av dess regler. Från den punkten läser Claude Code som standard bara `CLAUDE.md`, så det finns två källor till sanning igen: du uppdaterar `AGENTS.md`, medan Claude fortsätter att arbeta utifrån den gamla kopian. Kommandot `/import` gör något liknande: det lägger till en engångskopia av `AGENTS.md` i `CLAUDE.md`. För att behålla en enda källa lägger du importen `@AGENTS.md` på första raden i `CLAUDE.md` efter `/init` och tar bort allt i `CLAUDE.md` som upprepar `AGENTS.md`.
`/init` är en bra utgångspunkt för ett nytt projekt eller ett projekt som du flyttar över från Cursor eller Copilot. Du behöver inte söka på nätet efter den ”bästa CLAUDE.md-mallen” – Anthropic utgår redan från innehållet i kodförrådet. Om projektet redan har en aktiv `AGENTS.md` och inga Claude-specifika regler behövs inte `/init`: Claude Code läser `AGENTS.md` direkt.
## Hur skiljer du delade instruktioner från Claude-specifika?
Det viktigaste
Lägg regler som alla AI-agenter kan förstå i `AGENTS.md`: vad som inte får röras, hur grenar ska namnges, att `.env` innehåller en hemlighet och vilka kommandon som ska användas för tester. Lägg regler som är specifika för Claude Code i `CLAUDE.md` (under importen): planläge, skills, hooks, hänvisningar till skills och modellnamn per version. Skillnaden är enkel: om en regel börjar med ”Claude bör” hör den hemma i `CLAUDE.md`. Om den börjar med ”verktyget bör” hör den hemma i `AGENTS.md`.
Jag skiljer dem åt enligt den här principen. Delade regler som hör hemma i `AGENTS.md`:
- **Vad som inte får röras i koden.** Mapparna `.env`, `node_modules`, `prisma/migrations` (endast via `prisma migrate`), `.next/`, `.git/`.
- **Hur saker ska namnges.** Grenar: `feat/`, `fix/`, `chore/`. Commits: prefixen `feat:`, `fix:`, `docs:` plus en kort beskrivning. Komponentfiler i `kebab-case`.
- **Kommandon för test/lint.** `npm run build`, `npm run lint`, `npm test`. Vilket kommando som ska köras före `git push`.
- **Arkitekturprinciper.** Vad som hör hemma i `src/lib/`, vad som hör hemma i `src/components/`, var affärslogiken finns och var användargränssnittet finns.
- **Säkerhet.** Checka aldrig in hemligheter. Kom åt produktionsdatabasen endast via `prod-psql`. Anslut till produktion över SSH endast via aliaset `prod`, inte `root@IP`.
Claude-specifika regler som hör hemma i `CLAUDE.md` (under `@AGENTS.md`):
- **Planläge.** Använd `plan mode` för ändringar i riskfyllda kataloger (till exempel `src/billing/`).
- **Ansträngningsnivå.** Använd `--effort high` för arkitekturuppgifter och `medium` för rutinuppgifter.
- **Skills.** Vilka AI-agenter och skills som ska köras i olika situationer. Exempel: ”kör skillen `build-masterskaya-guide` när du arbetar med en guide”.
- **Claude-minne.** Vad som ska läggas i automatiskt minne och vad som ska läggas i `CLAUDE.local.md`. Mer om Claude-minne finns i [guiden om Memory och CLAUDE.md](https://ailoot.ai/blog/sv/claude-memory-claude-md-auto-memory/).
- **Hooks.** Om `.claude/settings.json` har konfigurerade hooks beskriver du i `CLAUDE.md` vad de gör (Codex och Cursor känner inte till dem och behöver inte göra det).
- **Skills och kommandon.** En lista över slash-kommandon som jag ofta använder (`/init`, `/cd`, `/memory`, `/plan`).
Gränsen är inte alltid tydlig. Till exempel är ”kör aldrig `git push --force` till `main`” uppenbart en delad regel och hör hemma i `AGENTS.md`. Men ”använd planläge när du kör `git push` till en het gren” är specifikt för Claude Code och hör därför hemma i `CLAUDE.md`. Testet är: ”Om jag tog bort Claude Code i morgon och bara behöll Codex, skulle den här regeln fortfarande gälla?” Om ja, lägg den i `AGENTS.md`. Om nej, lägg den i `CLAUDE.md`.
## Vad hör hemma i AGENTS.md, och vad hör hemma i CLAUDE.md eller .claude/rules?
Det viktigaste
I ett stort projekt räcker inte en enda `AGENTS.md` – den blir för stor, och varje agent får onödigt mycket material i sin kontext. Lösningen är en katalog med `.claude/rules/` och separata filer per ämne samt YAML-frontmatter `paths:` för sökvägsbaserade utlösare. Till exempel gäller en API-regel bara när Claude arbetar i `src/api/`. Det sparar mycket utrymme i kontextfönstret. Motsvarigheten för Cursor är `.cursor/rules/`, och för Windsurf är det `.windsurf/rules/`.
Om reglerna överstiger 200 rader är det dags att dela upp dem. Anthropics dokumentation rekommenderar att sikta på 200 rader per fil, eftersom långa `CLAUDE.md`-filer börjar leda till att regler följs sämre utan att det märks: Claude verkar läsa dem men följer dem mer sällan.
En struktur för ett stort projekt som fungerar för mig:
```
my-project/
├── AGENTS.md # 100-150 lines, shared
├── CLAUDE.md # 30-50 lines: @AGENTS.md + Claude-only
└── .claude/
├── CLAUDE.md # alternative to root file, same file
└── rules/
├── api.md # with paths: ['src/api/**']
├── components.md # with paths: ['src/components/**']
├── testing.md # without paths, always active
└── security.md # without paths, always active
```
Varje fil i `.claude/rules/` kan ha frontmatter:
```markdown
---
paths:
- "src/api/**/*.ts"
---
# API rules
- Every endpoint validates input with zod
- Errors use the standard `{error, code}` format
- OpenAPI comments are required
```
Claude läser in dessa regler bara när det arbetar med filer som matchar mönstret. Om det ändrar `src/components/Button.tsx` läggs API-reglerna inte till i kontexten. På så sätt används kontextfönstret bara för det som är relevant. Katalogen `.claude/rules/` fungerar också utan `CLAUDE.md`: om projektet bara innehåller `AGENTS.md` läses dess regler in tillsammans med den, och de inaktiverar inte direkt läsning av `AGENTS.md`.
Cursor och Windsurf stöder samma metod genom katalogerna `.cursor/rules/` och `.windsurf/rules/`. AGENTS.md-standarden kan hänvisa till dessa kataloger, men syntaxen mellan verktygen är ännu inte helt stabil. Det är säkrare att hålla delade regler i `AGENTS.md` och duplicera sökvägsbegränsade regler i `.claude/rules/` och `.cursor/rules/` – det här är sällsynta specialfall, inte huvuddelen av reglerna.
Användbara platser för CLAUDE.md (ordnade från bredast till snävaste omfattning):
| Nivå | Plats | Syfte |
|----|----|----|
| **Hanterad policy** | `/Library/Application Support/ClaudeCode/CLAUDE.md` (Mac), `/etc/claude-code/CLAUDE.md` (Linux) | Företagsregler, IT/DevOps |
| **Användare** | `~/.claude/CLAUDE.md` | Personliga preferenser för alla projekt |
| **Projekt** | `./CLAUDE.md` eller `./.claude/CLAUDE.md` | Projektteamets regler |
| **Lokal** | `./CLAUDE.local.md` (i `.gitignore`) | Personliga preferenser för ett specifikt projekt |
Ett exempel på en `~/.claude/CLAUDE.md` kan innehålla två regler: ”svara på det språk användaren föredrar” och ”stava Ailoot exakt så här”. De här reglerna gäller för alla projekt, så det finns ingen anledning att duplicera dem i varje kodförråd.
Av dessa fyra nivåer är det bara en projektbaserad `CLAUDE.md` och `CLAUDE.local.md` som inaktiverar direkt läsning av `AGENTS.md`. En personlig `~/.claude/CLAUDE.md` och en centralt hanterad policy står inte i vägen; Claude Code läser in dem tillsammans med `AGENTS.md`.
## Vad ska du göra om AGENTS.md redan är inaktuell i projektet?
Det viktigaste
Om `AGENTS.md` sammanställdes 2025 för Codex eller Aider och inte har redigerats sedan dess öppnar du projektet i Claude Code och ber Claude redigera filen. AGENTS.md är ett levande dokument; Linux Foundations specifikation uppdateras. Huvudregeln för att hålla den aktuell: varje regel måste besvara frågan ”Vad är jag trött på att upprepa för Claude/Codex?” Om den inte gör det ska du arkivera den.
I projektet jag beskrev hade jag en `AGENTS.md` från maj 2025 – 180 rader, många av dem inaktuella (den nämnde Anthropic API-slutpunkter som hade ändrats sedan dess, exempel med den syntax för `claude --tools` som inte längre finns och regler om `~/.claude/projects/` med en inaktuell struktur).
Planen jag använde för att uppdatera den:
1. **Granska den med `claude` i planläge.** Jag öppnar kodförrådet, kör `claude --safe-mode` och ber: “Läs `AGENTS.md` igen och föreslå en lista över inaktuella eller upprepade punkter. Redigera den inte; lista bara punkterna.” På två minuter fick jag en lista med 23 punkter att granska.
2. **Ta bort uppenbart inaktuella punkter.** Av de 23 punkterna var 9 tydligt inaktuella – kommandosyntax, slutpunkter och flaggnamn. Jag tog bort de raderna.
3. **Slå ihop dubbletter.** Ytterligare 6 punkter upprepade varandra med olika formuleringar (”gör ingen force-push”, ”använd aldrig `--force`”, ”undvik `git push -f`”). Jag slog ihop dem till en rad.
4. **Lägg till nya punkter.** Jag lade till sådant som jag hade märkt att Claude/Codex regelbundet fick fel under den senaste månaden, enligt regeln ”en rad per felmönster”. Det gav 8 nya punkter.
5. **Kör en underagent för slutgranskning.** Jag bad Claude granska den med instruktionen ”hitta motsägelser, tvetydigheter och dubbletter”. Den hittade tre formuleringar som kunde göras tydligare. Jag rättade dem.
Efter en timme var `AGENTS.md` 110 rader lång och aktuell, och jag kände till varje rad. Det var lätt att bygga en `CLAUDE.md` på 30 rader utifrån den. Codex blev också märkbart noggrannare med tester efteråt – jag misstänker att en del av dess ”konstiga” beslut berodde på inaktuella instruktioner som det hade följt i god tro.
Huvudprinciperna för en levande `AGENTS.md`:
- **Varje regel svarar mot ett återkommande misstag.** Om jag inte kom att tänka på en regel en enda gång under månaden finns det ingen poäng med att behålla den.
- **Skriv regler som uppmaningar, inte som teori.** ”Använd två blanksteg” är en regel. ”Kodstilen bör vara snygg” är det inte.
- **Var konkret.** ”Kör `npm run build` före `git push`” är en regel. ”Testa ändringarna” är det inte.
## Vad fungerar DEFINITIVT INTE med den här konfigurationen?
Det viktigaste
Import av `@AGENTS.md` får inte olika verktyg att bete sig likadant. Varje verktyg har sina egna egenheter: Codex CLI känner inte till `.claude/rules/` eller hooks. Cursor har en egen funktion för automatisk komplettering som inte läser CLAUDE.md när den kompletterar text. Copilot följer `.github/copilot-instructions.md`, och regler enbart i AGENTS.md räcker inte för det. Det handlar inte om ”en fil = ett beteende”, utan om ”en källa för grundreglerna, och sedan egna tillägg för varje verktyg”.
Några saker jag lärde mig den hårda vägen under sex månaders arbete med den här konfigurationen:
**1. Cursor-autokomplettering använder inte AGENTS.md.** När Cursor föreslår att komplettera en rad i redigeraren läser det inte `AGENTS.md` i realtid – det är en separat snabb motor som arbetar. Regler i AGENTS.md spelar bara roll när du skickar en chattförfrågan i Cursor. Det betyder att om du skriver ”använd inte `var`, använd `const`” i AGENTS.md påverkar det inte automatisk komplettering; du behöver konfigurera detta via ESLint eller TypeScript-konfigurationen.
**2. Claude Code-hooks i AGENTS.md fungerar inte för Codex.** Om `.claude/settings.json` har en konfigurerad PreToolUse-hook som blockerar en viss åtgärd är den informationen bara användbar för Claude. Codex känner inte till hooks; för det är det ”verktyget bestämmer själv”. Det är rimligt att skriva ”gör inte X” i `AGENTS.md` och ”det finns en hook som fysiskt blockerar X” i `CLAUDE.md` under importen.
**3. Copilot och `.github/copilot-instructions.md`.** GitHub Copilot läser sin egen fil och läser fortfarande inte AGENTS.md särskilt bra. Om ditt team använder Copilot aktivt kan du antingen lägga till en separat `.github/copilot-instructions.md` med en förkortad version av reglerna eller använda [Copilot Extensions](https://github.com/marketplace?type=apps&category=copilot-extensions) som känner till AGENTS.md. Det här förändras snabbt, så bilden kan se annorlunda ut om tre till sex månader.
**4. Git registrerar inte en symbolisk länk som en ändring i CLAUDE.md.** Om du kör `ln -s AGENTS.md CLAUDE.md` och uppdaterar `AGENTS.md` en vecka senare visar Git en diff bara för `AGENTS.md`. Det är normalt, men en kollega som granskar PR:en kanske inte inser att `CLAUDE.md` också har uppdaterats (via den symboliska länken). Lösning: skriv uttryckligen i PR-beskrivningen: ”uppdaterade `AGENTS.md`; Claude Code ser samma fil via den symboliska länken”.
**5. Djupa importer är svåra att felsöka.** Om `AGENTS.md` importerar `@docs/coding-style.md`, som importerar `@docs/typescript.md`, och någon regel står i konflikt med en annan blir felsökningen svår. Jag håller importer på en nivå (`CLAUDE.md` → `AGENTS.md`) och nästlar inte vidare. Anthropic tillhandahåller en `InstructionsLoaded`-hook som loggar vilka filer som lästes in – användbart för att felsöka lagerindelade konfigurationer. Obs: hooken körs för `AGENTS.md` som inkluderas via en import eller symbolisk länk, men inte för `AGENTS.md` som Claude Code läste självt.
### Källor
- [Dokumentation om Claude Code-minne – avsnittet AGENTS.md](https://code.claude.com/docs/en/memory#agents-md) – när Claude Code läser AGENTS.md direkt, inställningar för Project instructions, importer och symboliska länkar samt beteendet hos `/init`.
- [Dokumentation om Claude Code-minne – import av ytterligare filer](https://code.claude.com/docs/en/memory#import-additional-files) – syntaxen `@path/to/file`, upp till fyra nivåer, relativa och absoluta sökvägar.
- [agents.md – Linux Foundations standard](https://agents.md/) – den officiella AGENTS.md-standarden och en lista över verktyg med stöd.
- [Cursor Rules-dokumentation](https://docs.cursor.com/context/rules-for-ai) – vad Cursor läser (`.cursor/rules/*.mdc`, AGENTS.md).
- [Anpassade instruktioner för GitHub Copilot](https://docs.github.com/en/copilot/customizing-copilot/adding-custom-instructions-for-github-copilot) – formatet `.github/copilot-instructions.md`.
- [AGENTS.md-specifikationen hos Linux Foundation](https://aaif.io/projects/agents-md/) – en specifikation under utveckling.
Den kompletta uppsättningen för vibe-kodning på en kväll: **AI-klon + Second Brain + kontextteknik**.
Lär känna [Ailoot](https://ailoot.ai/).
## Frågor om den här guiden: En instruktionsfil för Claude Code, Codex och Cursor 2026
### När bör jag använda import i stället för symbolisk länk?
Använd `@AGENTS.md` i `CLAUDE.md` när Claude-specifika tillägg behövs eller kollegor använder Windows. En symbolisk länk gör att båda namnen hänvisar till samma innehåll och kan därför inte ha separat Claude-avsnitt.
### Hur kontrollerar jag att gemensamma instruktioner lästs in?
Kör `/memory` och kontrollera listade instruktionsfiler. Om `CLAUDE.md` eller `CLAUDE.local.md` hindrar direkt AGENTS.md-inläsning i din konfiguration lägger du till import eller väljer inställningen för båda och startar ny session.
## Ailoot · Företaget och dess projektportfölj
Ailoot bygger på etablerad driftserfarenhet, en stor kundbas, stabil service och löpande KPI-kontroll.
Företaget och dess projektportfölj: miljontals kunder; månatlig försäljning för miljarder.
Ailoot använder denna driftserfarenhet för API-åtkomst till AI-funktioner i kundernas produkter, agenter, applikationer och automatiseringar.