# Claude Code i 2026: 11 tips, genveje og kommandoer
> 11 praktiske Claude Code-teknikker: genveje, CLI-flag og /commands samt 6 strategier fra 6 måneders dagligt arbejde. Færre tokens, færre hallucinationer.
Source: https://ailoot.ai/blog/da/claude-code-tips/
Canonical: https://ailoot.ai/blog/da/claude-code-tips/
Language: da
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-001
Revision: sha256-56b67921d002f4c24a34d2d98d30d8fde1992455dd49ff63506d1dea8b30525b
Se [dokumentationen](https://ailoot.ai/docs/) for yderligere vejledning i arbejdet med Ailoot.
## Hvad gør disse 11 tips, og hvorfor har du brug for taktikker frem for teori?
Vigtige punkter
Dette er ikke en liste over de ”bedste Claude Code-funktioner” eller en genfortælling af Anthropics dokumentation. Det er 11 teknikker fra seks måneders dagligt arbejde: 5 taktiske (genveje, flag, /commands) og 6 strategiske (hvordan man opdeler en plan, håndterer 5 vinduer og opdager blinde vinkler). En enkelt aften er nok til at indarbejde 11 vaner.
Med vibe coding er spørgsmålet ikke længere ”virker Claude Code?” – spørgsmålet er ”hvordan arbejder man med det, så det ikke bruger alle ens grænser eller hallucinerer?” Mine 9 tidligere vejledninger gennemgår begreberne: [CLAUDE.md](https://ailoot.ai/blog/da/claude-md-template/), [Plan Mode](https://ailoot.ai/blog/da/claude-code-plan-mode/), [kontekstarbejde](https://ailoot.ai/blog/da/context-engineering/), [Skills](https://ailoot.ai/blog/da/claude-code-skills-library/), [Subagents](https://ailoot.ai/blog/da/claude-code-subagenter/), [MCP](https://ailoot.ai/blog/da/mcp-servers-claude-code/), [/rewind](https://ailoot.ai/blog/da/claude-code-undo-changes/), [grænser](https://ailoot.ai/blog/da/claude-code-token-limits-saving/), [den anden hjerne](https://ailoot.ai/blog/da/claude-code-second-brain/). Denne artikel samler taktikker, der supplerer dem.
Hvert tip løser ét problem. Du kan læse dem i rækkefølge eller springe til dem, der er mest relevante: Gå direkte til tip 1 for genveje, tip 4 og 5 for at spare tokens, tip 6 for parallelle opgaver og tip 8-11 for forfatterens teknikker.
Jeg skriver til folk, der **allerede** har installeret Claude Code og har brugt det i mindst en uge. Hvis du lige har installeret det, så begynd med [CLAUDE.md-vejledningen](https://ailoot.ai/blog/da/claude-md-template/), og vend derefter tilbage.
## Sådan skifter du Claude Code-tilstand: Shift+Tab-genvejen
Vigtige punkter
Shift+Tab skifter mellem tilladelsestilstande: `default`, `acceptEdits`, `plan` og eventuelle aktiverede tilstande (`auto`, `bypassPermissions`). Skift til [Plan Mode](https://ailoot.ai/blog/da/claude-code-plan-mode/) før en kompleks opgave, og kontrollér tilstandsindikatoren, før du sender opgaven. Vælg `acceptEdits` før rutinearbejde, og verificér den etiket; antallet af tryk afhænger af starttilstanden og de aktiverede tilstande.
Den mest almindelige begynderfejl er at blive i `default` hele dagen og godkende hver ændring manuelt. Efter en time er det udmattende, og man bliver fristet til at køre `--dangerously-skip-permissions` (mere om det til sidst i tipset). Shift+Tab er mellemvejen: Du vælger selv, hvornår du har brug for `acceptEdits`, og hvornår du har brug for `plan`.
Her er den konkrete regel, jeg følger, når jeg skifter:
1. **Når jeg starter en kompleks opgave** – brug Shift+Tab, indtil tilstandsindikatoren viser `plan`. Claude tænker det grundigt igennem og udarbejder en plan; den skriver ikke kode, før jeg godkender den.
2. **Planen er godkendt, og arbejdet går videre til implementering** – skift, indtil tilstandsindikatoren viser `acceptEdits`. Claude redigerer filer uden at bede om godkendelse, men spørger stadig om lov til Bash-kommandoer.
3. **Rutineændringer (omdøbning, enkel refaktorering)** – gå direkte til `acceptEdits` uden en plan.
4. **Risikozone (databasemigreringer, sletning af filer)** – jeg går tilbage til `default` med Shift+Tab.
```bash
# Almindelige tilladelsestilstande (kontrollér aktiv etiket, ikke et fast antal tryk):
# default - almindelige tilladelsesprompts
# acceptEdits - filændringer accepteres; andre værktøjstilladelser gælder stadig
# plan - undersøg og planlæg før implementering
# Yderligere tilstande afhænger af version, indstillinger og organisationspolitik.
```
Hvis Shift+Tab ikke virker i din version af Claude Code (`claude --version`), skal du kontrollere, at du har den nyeste version. Kommandoen `/doctor` viser dig alt om installationen.
Shift+Tab skifter mellem tilladelsestilstande. De tilgængelige tilstande afhænger af, hvad du har aktiveret i indstillingerne.
— Anthropic Docs, https://code.claude.com/docs/en/interactive-mode
## Sådan fortryder du den seneste handling uden at miste konteksten: Esc Esc
Vigtige punkter
Dobbelt-Esc er en hurtig måde at fortryde Claudes seneste handling på uden en fuld `/rewind`. Hvis inputfeltet er tomt, åbnes menuen med kontrolpunkter. Hvis der står noget i feltet, ryddes det, men teksten gemmes i historikken (pil op henter den frem igen). Det løser frygten for ”jeg har ødelagt det og kan ikke fortryde” i 80% af tilfældene; du behøver ikke gå til git.
Esc og Esc Esc gør forskellige ting, og derfor forveksler folk dem:
- **Ét Esc** – afbryder Claude, mens den er i gang med noget. Alt, hvad den har nået at gøre, bliver stående. Nyttigt, når den er på afveje, og du vil styre den i en anden retning.
- **Dobbelt-Esc** – hvis inputfeltet er tomt, åbner menuen med kontrolpunkter (gendan kode, samtale eller begge dele, eller lav et resumé). Hvis feltet indeholder tekst, ryddes det, og teksten gemmes i historikken (pil op henter den frem igen).
```bash
# From the Esc Esc menu with an empty field:
# 1. Restore code only - restore the files, leave the conversation
# 2. Restore conversation only - restore the conversation, leave the files
# 3. Restore code and conversation - restore both (the most common choice)
# 4. Summarize from here - summarize the conversation from this point
# 5. Summarize up to here - summarize up to this point
```
Der oprettes automatisk kontrolpunkter for hver prompt, du sender – der er intet, du skal huske, og du kan altid gå tilbage. Se [vejledningen til /rewind](https://ailoot.ai/blog/da/claude-code-undo-changes/) for en fuld gennemgang; den beskriver også, hvordan git kan kombineres med det til større tilbagerulninger.
Hver brugerprompt opretter et nyt kontrolpunkt. Kontrolpunkter gemmes mellem sessioner, så du kan vende tilbage til dem i genoptagne samtaler.
— Anthropic Docs, https://code.claude.com/docs/en/checkpointing
Esc Esc er en af de første teknikker, begyndere bør lære. Når de ikke længere er bange for at ”ødelægge det og ikke kunne fortryde”, begynder de at eksperimentere mere modigt, og resultaterne bliver langt bedre.
## Hvornår skal du bruge /compact i stedet for /clear?
Vigtige punkter
`/clear` nulstiller sessionen helt og efterlader et rent kontekstvindue. `/compact [hint]` får LLM til at komprimere samtalehistorikken til et resumé, der bevarer betydningen af det tidligere arbejde. Reglen er enkel: Opgaven er færdig – `/clear`. Du fortsætter med den samme opgave, men vinduet er fuldt – `/compact`. Forveksler du dem, mister du enten kontekst eller rammer grænsen.
Sådan fungerer `/compact` internt: Claude tager hele beskedhistorikken, behandler den og returnerer et kort resumé med de vigtigste detaljer. Et nyttigt trick er at give den et vink: `/compact keep the coding principles and current plan, discard the CSS discussion`. Så bliver komprimeringen målrettet.
```bash
# When to use what:
/clear # finished a feature, moving to a new one
/compact # long session, context is >50% full
/compact keep the architecture and plan # targeted compression with a focus
```
Tegnet på, at det er tid til `/compact`: Kommandoen `/cost` eller statuslinjen viser, at 70%+ af kontekstvinduet er brugt, mens sessionen kun er halvvejs. Hvis du ignorerer det, begynder Claude at ”glemme” starten af samtalen, og du spilder tid på at forklare tingene igen.
I Claude Code gør vi for eksempel dette ved at sende beskedhistorikken til modellen, så den kan opsummere og komprimere de vigtigste oplysninger.
— Anthropic Engineering, https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
Se vejledningen om [kontekstarbejde](https://ailoot.ai/blog/da/context-engineering/) for hele teorien om kontekstvinduet. Den forklarer også, hvorfor kontekst er en begrænset ressource med aftagende udbytte.
## Sådan følger du tokens i realtid: kommandoen /cost
Vigtige punkter
`/cost` viser det aktuelle forbrug i dollars og tokens. `/statusline` føjer de samme oplysninger til statuslinjen – du kan altid se modellen, mappen, kontekstprocenten og prisen uden at køre en kommando. Den vigtigste måde at håndtere frygten for at ”bruge det hele på én dag” på er at gøre forbruget synligt hele tiden.
Frygten for at ”bruge det hele på én dag” er en af de største bekymringer blandt vibe coders. Den vigtigste måde at håndtere den frygt på er at gøre forbruget **synligt**.
```bash
/cost # shows current session spending (tokens + $)
/statusline # configures the status bar: model + directory + context % + cost
```
En enkel regel: Tjek `/cost` hvert 30-60 minut. Hvis du har brugt mindre end et par dollars på en time, er det fint. Hvis det er mere, er der noget galt: Du har måske glemt `/compact`, så konteksten vokser; måske valgte du den forkerte model (mere om det i næste tip); eller måske genlæser Claude store filer 10 gange.
Den fulde vejledning til at spare på grænserne er [”Sådan undgår du at opbruge Claude Code-grænserne på én dag”](https://ailoot.ai/blog/da/claude-code-token-limits-saving/), med 8 regler. Taktikken her er at gøre forbruget synligt med `/cost` og `/statusline`.
Vil du ikke kun følge tokens, men også opbygge et system, hvor en **AI-agent** ikke selv overskrider sine grænser? `/cost` er blot en indikator. Den fulde kombination – **AI-klon + den anden hjerne + [kontekstarbejde](https://ailoot.ai/blog/da/context-engineering/)** – forvandler Claude fra en ”assistent med grænser” til et værktøj, der kan arbejde længe og forudsigeligt.
## Hvilken Claude-model skal du vælge til en opgave: Haiku, Sonnet eller Opus?
Vigtige punkter
Flaget `--model` ændrer kun modellen for den aktuelle session. Grundreglen: Haiku til scripts og hurtige ændringer, Sonnet til rutinemæssig dyb tænkning, Opus til arkitektur og kompleks fejlfinding. Ifølge offentlige interviews bruger Claude Code-teamet selv Opus med thinking ”til alt”, men det er en mulighed for dem, der betaler for et abonnement uden at bekymre sig om tokens. For en iværksætter gælder en anden regel: Begynd billigere, og betal mere, når du har brug for det.
```bash
claude --model haiku # ~3× cheaper than sonnet, for routine work
claude --model sonnet # default, balance of price and quality
claude --model opus # ~1.7× more expensive than sonnet, for complex tasks
```
Ifølge Anthropics offentlige priser fra maj 2026: Haiku \$1/\$5 pr. 1M input-/outputtokens, Sonnet \$3/\$15, Opus \$5/\$25. Det betyder, at Haiku er 3 gange billigere end Sonnet, og Opus er 1,7 gange dyrere end Sonnet.
Sådan vælger jeg hver dag:
| Opgave | Model | Hvorfor |
|----|----|----|
| Omdøb en variabel/funktion | Haiku | Entydig handling; ingen grund til at ”tænke” |
| Enkel refaktorering (udtræk en funktion) | Sonnet | Standard, billig og præcis |
| Tilføj en ny funktion med arkitektur | Opus | Kræver dyb ræsonnering |
| Fejlfind en mærkelig fejl, som Sonnet ikke har fundet efter 3 forsøg | Opus | Mindre styring, større træfsikkerhed |
| Læs og opsummér lange logfiler | Haiku | Enkel kategorisering, billigere |
Det kan diskuteres, om man overhovedet skal bruge Sonnet og Haiku, hvis Opus i gennemsnit klarer opgaven ”i første forsøg”. Mit svar: For en iværksætter, der ikke er programmør, kan Haiku og Sonnet betale sig til 70% af opgaverne. Gem Opus til de 30%, der virkelig er vanskelige.
## Sådan kører du 3-5 opgaver parallelt: /resume + git worktrees
Vigtige punkter
Parallelle opgaver i Claude Code bygger på 2 ting: `--resume` (fortsæt en navngiven session) og `git worktree` (en separat mappe til hver gren). I praksis har jeg 5-10 Claude-vinduer åbne samtidig, og hvert arbejder på sin egen mikroopgave. Konteksterne overlapper ikke, og tokens spildes ikke på ”alt i ét vindue”.
Logikken er enkel: Et langt Claude-vindue **sluger** kontekst. Hver forespørgsel indlæser alt fra vinduet i modellen – også selvom du nu taler om noget helt andet. 5 korte vinduer til mikroopgaver husker hver kun deres eget arbejde. Samlet bruger du mindre.
```bash
# Start a named session for a specific task:
claude --resume "auth-refactor"
claude --resume "homepage-redesign"
claude --resume "db-migration"
# Use a worktree to keep git from overlapping:
git worktree add ../my-project-auth feature/auth
cd ../my-project-auth
claude --resume "auth-refactor"
```
Hvis du mister overblikket over, hvad der er i hvert vindue, kan du køre `claude --resume` uden argumenter for at se en liste over de seneste sessioner med deres navne og tidspunkter. I en aktiv session viser `/agents` de kørende underagenter.
Når jeg arbejder på en funktion med en lang udviklingscyklus, gør jeg som regel sådan:
1. **Vindue 1** – plan i `plans/YYYY-MM-DD-feature.md`. Kun diskussion, ingen kode.
2. **Vindue 2** (følger planen) – implementér fase 1. Opdatér planen efter fasen (`[x]`).
3. **Vindue 3** – implementér fase 2 parallelt med vindue 2, hvis faserne ikke overlapper.
4. **Vindue 4** – en synteseagent kontrollerer resultaterne fra begge vinduer.
5. **Vindue 5** – en sikkerhedsgennemgang efter sammenlægningen (se tip 8).
Hvornår du **ikke** skal bruge worktrees: Hvis du håndterer 1-2 projekter om dagen, vil arbejdet med at skifte mellem worktree-mapper æde gevinsten. Worktrees begynder at kunne betale sig ved 3+ parallelle opgaver om dagen.
## Sådan undgår du hallucinationer: filreferencer med @file
Vigtige punkter
Skriv `@src/lib/auth.ts` i stedet for ”gennemgå projektet og find auth.ts”, så indlæser Claude filen direkte uden at søge. Det sparer tokens (du behøver ikke gennemgå mappetræet) og fjerner en kilde til hallucinationer (Claude behøver ikke gætte stien – du har angivet den). Det samme gælder kommandoer: `!git status` køres uden et værktøjskald, og outputtet kommer ind i konteksten.
Filernes autoudfyldning begynder med symbolet `@`. Begynd at skrive en sti, så viser Claude forslag. Du kan referere til flere filer på én gang: `@src/lib/auth.ts @src/lib/session.ts @prisma/schema.prisma`.
```bash
# Prompt without exact paths (bad):
> Look at the auth logic and fix the session bug
# Prompt with @ references (right):
> @src/lib/auth.ts @src/lib/session.ts - fix the bug: after logout the cookie isn't cleared
```
Det andet trick i samme gruppe er shell-tilstand med `!`:
```bash
> !git status # runs without calling Claude, output goes into context
> !npm test # same
> !cat /var/log/app.log | tail -50 # same
```
Hvorfor? Du bruger ikke tokens på at sige ”Claude, se på git-statussen” – Claude ville alligevel få samme svar gennem værktøjet. `!` er kortere og billigere.
Det hænger sammen med `CLAUDE.md`: Hovedfilen bør indeholde højst 200 linjer med projektregler. Mere specifikke regler (for eksempel API-konventioner) placeres i `.claude/rules/api-design.md` med YAML-frontmatter `paths: ["src/api/**/*.ts"]`. Så indlæses de kun, når Claude redigerer filer i `src/api/`. Se [CLAUDE.md-vejledningen](https://ailoot.ai/blog/da/claude-md-template/) for hele gennemgangen.
## Sådan undgår du at miste fremskridt i lange opgaver: planer med faser og \[ \] / \[x\]
Vigtige punkter
Enhver opgave, der tager mere end 30 minutters arbejde, kræver en plan i en separat fil, `plans/YYYY-MM-DD-name.md`, med faser og afkrydsningsfelter `[ ]` / `[x]`. Planen hører hjemme i en fil, ikke i chatten. Så kan parallelle vinduer tage sig af forskellige faser uden at spænde ben for hinanden, og det er let at se fremskridtene i stedet for at skulle ”huske” dem fra chatten.
Her er skabelonen til planfilen, som jeg bruger i alle projekter:
```markdown
# Plan: [feature name]
Creation date: 2026-05-22
Goal: [one sentence on what we want to achieve]
## Phase 1: [short name]
- [ ] Step 1.1: [specific action]
- [ ] Step 1.2: [specific action]
- [ ] Step 1.3: [specific action]
## Phase 2: [short name]
- [ ] Step 2.1
- [ ] Step 2.2
## Outcome
Fill in at the end: fully or partially implemented, and what remains.
```
Reglen er absolut: **Alle agenter skal opdatere planen efter hver session**. Så snart du afslutter en fase, skal du med andre ord gå til filen og markere den med `[x]`. Hvis du ikke gør det, ved det næste vindue ikke, at fasen er færdig, og vil forsøge at gentage den.
Når planen står i en fil og ikke i dit hoved:
- Kan parallelle vinduer (se tip 6) tage sig af forskellige faser.
- Hvis opgaven strækker sig over 3 dage, og du vender tilbage 2 dage senere, kan du straks se, hvor du slap.
- Er det hurtigt at kontrollere det endelige resultat (`grep -c "\[ \]"` i filen = antal åbne punkter).
Hvornår du **ikke** skal bruge det: En hastefejlrettelse på 5 minutter, en ubetydelig ændring i én fil, læsning og opsummering af en log. Ikke alle handlinger kræver en plan.
Denne teknik er en del af konceptet om den anden hjerne. Se [vejledningen til den anden hjerne](https://ailoot.ai/blog/da/claude-code-second-brain/) for en fuld gennemgang af mapperne `business/`, `plans/` og `ai-clone/`.
## Sådan opdager du på forhånd, hvor Claude vil fejle: selvkritik med 10 grunde
Vigtige punkter
Før du begynder på en kompleks funktion, skal du sætte Claude i en adversarial tilstand: ”Forestil dig, at projektet er slået fejl. Om et år har jeg mistet tid og energi. Nævn 10 grunde til hvorfor. Hold ikke igen; vær hård.” Det bryder med den tidlige optimisme og afdækker blinde vinkler, som Claude aldrig ville nævne i tilstanden ”lad os implementere det”.
Her er promptskabelonen, som jeg bruger ordret:
```
Forestil dig, at idémappen har gennemgået en metode, hvor du allerede tænker, som om projektet er slået fuldstændig fejl. Nævn 10 grunde til, at jeg om et år vil have brugt meget tid, og at idéen har vist sig at være en fiasko. Din opgave er ikke at skåne mine følelser, men at være så hård som muligt.
Efter de 10 grunde – en anden runde: forsvar hver grund mod mine modargumenter. Hvor står jeg svagest?
Tredje runde: Skriv en plan for, hvad jeg skal gøre, så disse problemer ikke opstår.
```
Jeg bruger den i tre faser:
1. **Den første idé – ”alt er fantastisk”** – når jeg er sikker. Selvkritikken skærer 30-50% af idéen.
2. **Midtvejs i planen** – når jeg allerede er dybt inde i arbejdet og er blevet blind for problemerne.
3. **Før lanceringen** – en sidste kontrol.
Claude udfordrer dig virkelig i en adversarial tilstand. GPT-5 roser først idéen i samme situation og ”forsøger derefter at finde forbedringer”. Jeg bemærkede forskellen efter et års eksperimenter:
For mig ser forskellen i adversarial tilstand sådan ud: ChatGPT siger: ”Godt set, det har du helt ret i.” Claude siger i samme situation: ”Enig, det er noget værre lort; jeg laver det om nu.” Når jeg har brug for kritik, sparer det andet svar mig for flere dages spildt arbejde.
Hvornår du **ikke** skal bruge den: Positive iterationer af UI og tekstforfatning. Adversarial tilstand passer ikke ind dér – den dræber kreativiteten.
Denne teknik kaldes en projektpremortem. Jeg tilpassede den til arbejdet med en **AI-agent**: I stedet for et team af mennesker laver du en premortem med Claude. Ingen er bange for at sige ”chef, projektet vil slå fejl” – og blinde vinkler dukker op på få minutter.
## Sådan undersøger du 5 kilder på den tid, det tager at undersøge én: parallelle underagenter
Vigtige punkter
Før du begynder at arbejde på en funktion, skal du starte 5 parallelle researchagenter via underagenter. Hver agent fokuserer på sit eget område: professionelle netværk, open source, acceleratorer, konkurrenter og sammenligninger. De vender tilbage efter 10-20 minutter. Derefter samler en særskilt synteseagent det hele i én rapport. Det sparer timer og mindsker bekræftelsesbias.
Her er promptskabelonen:
```
Du har allerede hele konteksten. Undersøg emnet grundigt, og start 5 parallelle underagenter.
Underagent 1: Gennemgå professionelle netværk – hvem løser dette problem?
Underagent 2: Open source-løsninger på GitHub – hvad er populært?
Underagent 3: Startup-acceleratorer – hvem tiltrækker
investeringer i denne niche?
Underagent 4: Direkte konkurrenters websites – hvad lover de, og
til hvilken pris?
Underagent 5: Sammenligninger og anmeldelser – hvad siger
brugerne i anmeldelserne?
Når alle er vendt tilbage, skal du starte en synteseagent,
der krydsrefererer de 5 rapporter og udarbejder en disposition
til min mappe til den anden hjerne.
```
Hvad der ændrer sig i forhold til almindelig research:
- Tid: 5 samtidige spor i stedet for 5 sekventielle. En times arbejde på 15 minutter.
- Dybde: Hver agent har sit speciale. Den ene agents bekræftelsesbias påvirker ikke de andre.
- Kontekst: Hver underagent har sin egen kontekst, adskilt fra hovedkonteksten.
Se [”Claude Code-underagenter i 2026”](https://ailoot.ai/blog/da/claude-code-subagenter/) for den fulde vejledning til underagenter. Den forklarer også forskellen mellem Skills og MCP – hvornår man skal bruge hvad.
Hvornår du **ikke** skal bruge dem: kosmetiske ændringer, fejlrettelser og små tekniske opgaver. Research er overkill til alt mindre end ”en ny funktion, der kræver 1+ dags arbejde”.
## Sådan giver du Claude opgaver fra telefonen: en Telegram-bot i lommen
Vigtige punkter
Tilslut Claude Code til din Telegram-bot via det officielle plugin. På computeren (med dvale slået fra) kører Claude Code i en terminal, der er knyttet til projektet. Du kan skrive til den fra hvor som helst via botten: ”se på de seneste commits”, ”hvad var indtægten fra kvitteringer denne uge”, ”læs alle supportspørgsmålene fra i aften”. Botten svarer med hele projektets kontekst – kode, commit-historik og hele `business/`-strukturen. En aktiv agent i din kodebase, der ser og husker alt.
Sådan sætter du det op (4 trin):
1. **En computer, der er tændt hele tiden** – jeg slår dvale fra i systemindstillingerne (macOS: Energy Saver → Prevent computer from sleeping).
2. **Claude Code kører i en terminal**, knyttet til projektmappen.
3. **Det officielle Telegram-plugin** – tilføj marketplace med `/plugin marketplace add anthropics/claude-plugins-official`, og installér derefter `/plugin install telegram@claude-plugins-official` (de præcise trin ændres over tid – de nyeste instruktioner findes i det [officielle plugin-repo](https://github.com/anthropics/claude-plugins-official)).
4. **Botten er knyttet til én session** – det er en nuværende begrænsning: én bot = ét projekt = én session. Hvis du har brug for en mere, skal du sætte en bot nummer to op.
Det bruger jeg botten til hver dag:
- Jeg er ude at gå en tur og får en idé – jeg sender den straks til botten, så jeg ikke glemmer den. Botten føjer den til `inbox.md`, så den kan behandles senere.
- Et opkald med en potentiel kunde – efter opkaldet spørger jeg botten: ”ud fra udskriften af det seneste opkald, nævn de 3 vigtigste problemer, der taler til vores fordel”. Et minut senere har jeg en fuld analyse i chatten.
- Om morgenen på en café: ”vis mig de åbne opgaver på min liste”. Jeg behøver ikke åbne computeren.
⚠️ En hage: Lige nu kan du ikke køre `/clear` eller `/compact` fra botten – botsessionen er den samme som terminalsessionen, og konteksten bliver ved med at vokse. Den kan kun genstartes manuelt fra terminalen.
For mig er det den mest nyttige Claude Code-udvidelse i de seneste to uger. Den har flyttet mig fra ”jeg arbejder med Claude, når jeg sidder ved skrivebordet” til ”jeg arbejder med Claude, når jeg får en tanke”.
## Hvad skal du tage i brug først: en 7-dages plan
Vigtige punkter
Prøv ikke at indføre alle 11 tips på én dag – du brænder ud, og de hænger ikke ved. En 7-dages plan: dag 1-2 – genveje (1-3), dag 3-4 – kommandoer (4-5), dag 5-6 – parallelt arbejde (6-7), dag 7 – planlægning og premortem (8-9). Parallelle underagenter og Telegram-botten (10-11) hører til i uge to, når du mestrer de første 9.
| Dag | Det implementerer vi | Hvor lang tid tager det |
|----|----|----|
| 1 | Shift+Tab + Esc Esc | 30 minutters øvelse |
| 2 | Bliv fortrolig med Shift+Tab + Esc Esc | arbejd en halv dag |
| 3 | /compact + /cost | 30 minutter + 1-2 arbejdssessioner |
| 4 | --model haiku/sonnet/opus | 30 minutter + lidt eksperimentering |
| 5 | --resume til navngivne sessioner | 30 minutter |
| 6 | git worktrees – hvis du håndterer 3+ parallelle opgaver | 1 time |
| 7 | Plan i `plans/` + prompten ”10 grunde til, at jeg vil fejle” | 1-2 timer én gang |
| 8-14 (uge to) | Underagenter til research + Telegram-bot | 3-4 timer til opsætning og tilvænning |
Kombinationen af teknikker betyder mere end hver enkelt for sig. Shift+Tab uden Esc Esc gør det skræmmende at eksperimentere. `/compact` uden `/cost` betyder, at du ikke ved, hvornår du skal komprimere. Planer i filer uden parallelle vinduer er besvær uden gevinst.
Når de første 9 tips sidder på rygraden, går du videre til hele systemet: **AI-klon + den anden hjerne + [kontekstarbejde](https://ailoot.ai/blog/da/context-engineering/)**. Det er den metode, jeg har brugt til at holde Claude kørende i seks måneder i træk – uden hallucinationer, tab af kontekst eller afbrydelser midt i en opgave.
Hvis du vil fortsætte arbejdet med modeller, kan du gå til [Ailoot](https://ailoot.ai/).
## Spørgsmål og svar
### Hvordan ved jeg, at jeg er i Plan Mode?
Brug Shift+Tab til at skifte tilstand, og læs tilstandsindikatoren, før du sender opgaven. Stop, når den viser `plan`. Et fast antal tryk er upålideligt, fordi starttilstanden og de aktiverede tilstande kan variere.
### Skal jeg bruge /clear eller /compact, når konteksten fyldes?
Brug `/compact`, når du fortsætter samme opgave, med et hint om planen og de beslutninger, der skal bevares. Brug `/clear`, når opgaven er færdig, og den næste har brug for frisk kontekst. Gem først vigtige fremskridt i planfilen.
## Ailoot · Virksomheden og dens projektportefølje
Ailoot bygger på solid driftserfaring, en stor kundebase, stabil service og løbende kontrol af KPI.
Virksomheden og dens projektportefølje: millioner af kunder; månedligt salg for milliarder.
Ailoot bruger denne driftserfaring til API-adgang til AI-funktioner i kundernes produkter, agenter, applikationer og automatiseringer.