# Claude Code in 2026: 11 tips, sneltoetsen en opdrachten
> 11 praktische Claude Code-technieken: sneltoetsen, CLI-flags en /commands, plus 6 strategieën uit 6 maanden dagelijks werk. Minder tokens, minder hallucinaties.
Source: https://ailoot.ai/blog/nl/claude-code-tips/
Canonical: https://ailoot.ai/blog/nl/claude-code-tips/
Language: nl
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-001
Revision: sha256-51e6d75e7008cd8daf7a9eab7f6eb4c77a8911bff543c80275197746a2fc40f7
Raadpleeg voor aanvullende instructies over het werken met Ailoot de [documentatie](https://ailoot.ai/docs/).
## Welke Claude Code-tips helpen bij sneltoetsen, tokens en parallel werk?
Belangrijkste punten
Dit is geen lijst met de “beste Claude Code-functies” en ook geen navertelling van de Anthropic-documentatie. Dit zijn 11 technieken uit zes maanden dagelijks werk: 5 tactische (sneltoetsen, flags, /commands) en 6 strategische (hoe je een plan opsplitst, hoe je 5 vensters beheert, hoe je blinde vlekken opspoort). Eén avond is genoeg om 11 gewoonten aan te leren.
Bij vibe coding is de vraag niet langer “werkt Claude Code?” - de vraag is “hoe werk je ermee zonder je limieten op te maken of hallucinaties te krijgen?” Mijn 9 eerdere gidsen behandelen de concepten: [CLAUDE.md](https://ailoot.ai/blog/nl/claude-md-template/), [Plan Mode](https://ailoot.ai/blog/nl/claude-code-plan-mode/), [context engineering](https://ailoot.ai/blog/nl/context-engineering/), [Skills](https://ailoot.ai/blog/nl/claude-code-skills-library/), [Subagents](https://ailoot.ai/blog/nl/claude-code-subagents/), [MCP](https://ailoot.ai/blog/nl/mcp-servers-claude-code/), [/rewind](https://ailoot.ai/blog/nl/claude-code-undo-changes/), [limieten](https://ailoot.ai/blog/nl/claude-code-token-limits-saving/), [second brain](https://ailoot.ai/blog/nl/tweede-brein-claude-code/). Dit is een verzameling tactieken die daarbij passen.
Elke tip lost één hoofdpijnpunt op. Je kunt ze op volgorde lezen of meteen naar de urgentste springen: voor sneltoetsen ga je direct naar tip 1; voor tokens besparen naar tips 4 en 5; voor parallel werken naar tip 6; voor de technieken van de auteur naar tips 8-11.
Ik schrijf voor mensen die Claude Code **al** hebben geïnstalleerd en het minstens een week hebben gebruikt. Als je het net installeert, begin dan met de [CLAUDE.md-gids](https://ailoot.ai/blog/nl/claude-md-template/) en kom daarna terug.
## Claude Code-sneltoetsen in het Nederlands: modi wisselen met Shift+Tab {#claude-code-modi-wisselen-met-de-shifttab-sneltoets}
Belangrijkste punten
Shift+Tab doorloopt de toestemmingsmodi: `default`, `acceptEdits`, `plan` en alle ingeschakelde modi (`auto`, `bypassPermissions`). Schakel vóór een complexe taak naar [Plan Mode](https://ailoot.ai/blog/nl/claude-code-plan-mode/) en controleer de modusindicator voordat je de taak verstuurt. Kies vóór routinewerk `acceptEdits` en controleer dat label; het aantal toetsaanslagen hangt af van de beginmodus en ingeschakelde modi.
De meest voorkomende beginnersfout is de hele dag in `default` blijven en elke wijziging handmatig goedkeuren. Na een uur wordt dat vermoeiend en kom je in de verleiding `--dangerously-skip-permissions` te gebruiken (daarover meer aan het einde van de tip). Shift+Tab is de middenweg: je kiest wanneer je `acceptEdits` en wanneer je `plan` nodig hebt.
Dit is de specifieke regel die ik volg bij het wisselen:
1. **Een complexe taak beginnen** - gebruik Shift+Tab totdat de modusindicator `plan` toont. Claude denkt erover na en maakt een plan; het schrijft geen code totdat ik akkoord geef.
2. **Plan goedgekeurd, over naar de uitvoering** - schakel door totdat de modusindicator `acceptEdits` toont. Claude bewerkt bestanden zonder om goedkeuring te vragen, maar vraagt nog wel toestemming voor Bash-opdrachten.
3. **Routinebewerkingen (hernoemen, triviale refactoring)** - ga direct naar `acceptEdits`, zonder plan.
4. **Gevarenzone (databasemigraties, bestanden verwijderen)** - ik keer met Shift+Tab terug naar `default`.
```bash
# Gangbare machtigingsmodi (controleer het actieve label, niet een vast aantal toetsaanslagen):
# default - standaard toestemmingsvragen
# acceptEdits - bestandsbewerkingen worden geaccepteerd; andere toolmachtigingen blijven gelden
# plan - onderzoeken en plannen vóór implementatie
# Extra modi hangen af van je versie, instellingen en organisatiebeleid.
```
Als Shift+Tab niet werkt in jouw versie van Claude Code (`claude --version`), controleer dan of je de nieuwste versie hebt. De opdracht `/doctor` laat alles over de installatie zien.
Shift+Tab doorloopt de toestemmingsmodi. Welke modi beschikbaar zijn, hangt af van wat je in de instellingen hebt ingeschakeld.
— Anthropic Docs, https://code.claude.com/docs/en/interactive-mode
## De laatste actie ongedaan maken zonder context te verliezen: Esc Esc
Belangrijkste punten
Twee keer Esc is een snelle manier om Claude's laatste actie ongedaan te maken zonder een volledige `/rewind`. Als het invoerveld leeg is, verschijnt het checkpointmenu. Staat er iets in het veld, dan wordt het gewist maar in de geschiedenis opgeslagen (met de pijl omhoog haal je het terug). Hiermee wordt in 80% van de gevallen de angst weggenomen van “ik heb het stukgemaakt en kan het niet ongedaan maken”; je hoeft niet naar git.
Esc en Esc Esc doen verschillende dingen, en daarom worden ze vaak door elkaar gehaald:
- **Eén keer Esc** - onderbreekt Claude op dat moment, terwijl het ergens mee bezig is. Alles wat het tot dan toe heeft gedaan, blijft behouden. Handig als het de verkeerde kant op gaat en je het wilt bijsturen.
- **Twee keer Esc Esc** - als het invoerveld leeg is, opent het het checkpointmenu (code herstellen, gesprek herstellen, allebei herstellen of samenvatten). Staat er tekst in het veld, dan wordt die gewist en in de geschiedenis gezet (met de pijl omhoog haal je die terug).
```bash
# Vanuit het Esc Esc-menu met een leeg veld:
# 1. Alleen code herstellen - herstel de bestanden, behoud het gesprek
# 2. Alleen gesprek herstellen - herstel het gesprek, behoud de bestanden
# 3. Code en gesprek herstellen - herstel beide (de meest gebruikelijke keuze)
# 4. Vanaf hier samenvatten - vat het gesprek vanaf dit punt samen
# 5. Tot hier samenvatten - vat samen tot dit punt
```
Voor elke prompt die je verstuurt, worden automatisch checkpoints gemaakt - je hoeft nergens aan te denken en kunt altijd teruggaan. Zie voor het volledige overzicht de [gids over /rewind](https://ailoot.ai/blog/nl/claude-code-undo-changes/), die ook de combinatie met git voor uitgebreide terugdraaiingen behandelt.
Elke gebruikersprompt maakt een nieuw checkpoint. Checkpoints worden tussen sessies bewaard, zodat je ernaar kunt terugkeren in hervatte gesprekken.
— Anthropic Docs, https://code.claude.com/docs/en/checkpointing
Esc Esc is een van de eerste technieken voor beginners. Zodra ze niet meer bang zijn dat ze “iets stukmaken en het niet ongedaan kunnen maken”, gaan ze vrijmoediger experimenteren en verbeteren de resultaten vele malen.
## Wanneer gebruik je /compact in plaats van /clear?
Belangrijkste punten
`/clear` reset de sessie volledig en laat een schoon contextvenster achter. Met `/compact [hint]` laat je de LLM de gespreksgeschiedenis comprimeren tot een samenvatting, waarbij de betekenis van het eerdere werk behouden blijft. De regel is eenvoudig: taak afgerond - `/clear`. Ga je verder met dezelfde taak, maar is het venster vol - `/compact`. Haal je ze door elkaar, dan verlies je context of loop je tegen de limiet aan.
Zo werkt `/compact` intern: Claude neemt de volledige berichtgeschiedenis, verwerkt die en geeft een korte samenvatting terug met de belangrijkste details. Een handige truc is om een aanwijzing mee te geven: `/compact keep the coding principles and current plan, discard the CSS discussion`. Zo wordt de compressie gericht.
```bash
# Wanneer gebruik je wat:
/clear # functie afgerond, verder met een nieuwe
/compact # lange sessie, context is voor >50% vol
/compact keep the architecture and plan # gerichte compressie met focus
```
Het signaal dat het tijd is voor `/compact`: de opdracht `/cost` of de statusbalk laat zien dat 70%+ van het contextvenster is gebruikt, terwijl de sessie pas halverwege is. Als je dit negeert, begint Claude het begin van het gesprek te “vergeten” en verspil je tijd aan dingen opnieuw uitleggen.
In Claude Code doen we dit bijvoorbeeld door de berichtgeschiedenis naar het model te sturen om die samen te vatten en de belangrijkste informatie te comprimeren.
— Anthropic Engineering, https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
Zie voor de volledige theorie over het contextvenster de gids over [context engineering](https://ailoot.ai/blog/nl/context-engineering/). Daarin wordt ook uitgelegd waarom context een eindige hulpbron is met afnemende meeropbrengst.
## Tokens in realtime bijhouden met de opdracht /cost
Belangrijkste punten
`/cost` toont de huidige uitgaven in dollars en tokens. Met `/statusline` voeg je dezelfde informatie toe aan de statusbalk - je ziet dan altijd het model, de map, het contextpercentage en de kosten zonder een opdracht uit te voeren. De belangrijkste manier om de angst voor “alles op één dag uitgeven” aan te pakken, is de uitgaven voortdurend zichtbaar te maken.
De angst om “alles op één dag uit te geven” is een van de grootste zorgen onder vibe coders. De belangrijkste manier om die angst aan te pakken, is de uitgaven **zichtbaar** te maken.
```bash
/cost # toont de uitgaven van de huidige sessie (tokens + $)
/statusline # configureert de statusbalk: model + map + context % + kosten
```
Een eenvoudige regel: controleer `/cost` elke 30-60 minuten. Als je in een uur minder dan een paar dollar hebt uitgegeven, is dat prima. Is het meer, dan klopt er iets niet: misschien ben je `/compact` vergeten en groeit de context, misschien heb je het verkeerde model gekozen (meer daarover in de volgende tip), of misschien leest Claude grote bestanden 10 keer opnieuw.
De volledige gids over limieten besparen is [“Claude Code-limieten niet in één dag opgebruiken”](https://ailoot.ai/blog/nl/claude-code-token-limits-saving/), met 8 regels. De tactiek hier is de uitgaven zichtbaar maken met `/cost` en `/statusline`.
Wil je niet alleen tokens bijhouden, maar ook een systeem bouwen waarin een **AI-agent** zijn limieten niet zelfstandig overschrijdt? `/cost` is slechts een indicator. De volledige combinatie — **AI-kloon + Second Brain + [Context Engineering](https://ailoot.ai/blog/nl/context-engineering/)** — maakt van Claude een hulpmiddel dat lang en voorspelbaar kan werken in plaats van een “assistent met limieten”.
## Welk Claude-model kies je voor een taak: Haiku, Sonnet of Opus?
Belangrijkste punten
De flag `--model` overschrijft het model alleen voor de huidige sessie. De basisregel: Haiku voor scripts en snelle bewerkingen, Sonnet voor routinematig diep nadenken, Opus voor architectuur en complexe debugging. Volgens openbare interviews gebruikt het Claude Code-team zelf Opus met thinking “voor alles”, maar dat is een optie voor mensen die een abonnement betalen zonder zich zorgen te maken over tokens. Voor een ondernemer geldt een andere regel: begin goedkoper en betaal meer wanneer dat nodig is.
```bash
claude --model haiku # ~3× goedkoper dan sonnet, voor routinewerk
claude --model sonnet # standaard, balans tussen prijs en kwaliteit
claude --model opus # ~1.7× duurder dan sonnet, voor complexe taken
```
Volgens de openbare prijzen van Anthropic in mei 2026: Haiku \$1/\$5 per 1M input/output, Sonnet \$3/\$15, Opus \$5/\$25. Dat betekent dat Haiku 3 keer goedkoper is dan Sonnet en Opus 1.7 keer duurder dan Sonnet.
Zo kies ik elke dag:
| Taak | Model | Waarom |
|----|----|----|
| Een variabele/functie hernoemen | Haiku | Eenduidige handeling; je hoeft niet na te denken |
| Eenvoudige refactoring (een functie eruit halen) | Sonnet | Standaard, goedkoop, nauwkeurig |
| Een nieuwe functie met architectuur toevoegen | Opus | Diep redeneren is nodig |
| Een vreemde bug debuggen die Sonnet na 3 pogingen niet heeft gevonden | Opus | Minder bijsturen, grotere kans op succes |
| Lange logs lezen en samenvatten | Haiku | Eenvoudige categorisering, goedkoper |
Een punt van discussie is of je Sonnet en Haiku überhaupt moet gebruiken als Opus het gemiddeld “bij de eerste poging” goed doet. Mijn antwoord: voor een ondernemer die niet programmeert, zijn Haiku en Sonnet bij 70% van de taken de moeite waard. Opus kun je beter bewaren voor de 30% die echt moeilijk zijn.
## Hoe je 3-5 taken parallel uitvoert: /resume + git worktrees
Belangrijkste punten
Parallel werken in Claude Code berust op 2 dingen: `--resume` (een benoemde sessie voortzetten) en `git worktree` (een aparte map voor elke branch). In de praktijk heb ik 5-10 Claude-vensters tegelijk open, elk bezig met een eigen microtaak. De context overlapt niet en je verspilt geen tokens aan “alles in één venster”.
De logica is eenvoudig: één lang Claude-venster **vreet** context op. Elke opdracht laadt alles wat in dat venster stond in het model - zelfs als je het nu over iets heel anders hebt. 5 korte vensters voor microtaken onthouden elk alleen hun eigen werk. In totaal geef je minder uit.
```bash
# Start een benoemde sessie voor een specifieke taak:
claude --resume "auth-refactor"
claude --resume "homepage-redesign"
claude --resume "db-migration"
# Gebruik een worktree zodat git niet door elkaar loopt:
git worktree add ../my-project-auth feature/auth
cd ../my-project-auth
claude --resume "auth-refactor"
```
Als je niet meer weet wat er in elk venster staat, voer je `claude --resume` zonder argument uit om een lijst met recente sessies en hun namen en tijden te zien. Binnen een actieve sessie controleert `/agents` de actieve subagents.
Als ik aan een functie werk met een lange ontwikkelcyclus, doe ik meestal het volgende:
1. **Venster 1** - plan in `plans/YYYY-MM-DD-feature.md`. Alleen overleg, geen code.
2. **Venster 2** (volgens het plan) - fase 1 uitvoeren. Werk het plan na de fase bij (`[x]`).
3. **Venster 3** - fase 2 parallel met venster 2 uitvoeren, als de fasen elkaar niet overlappen.
4. **Venster 4** - een synthese-agent controleert de resultaten van beide vensters.
5. **Venster 5** - een beveiligingsreview na het samenvoegen (zie tip 8).
Wanneer je worktrees **niet** moet gebruiken: als je 1-2 projecten per dag beheert, kost het wisselen tussen worktree-mappen meer tijd dan het oplevert. Worktrees gaan renderen bij 3+ parallelle taken per dag.
## Hallucinaties vermijden met bestandsverwijzingen via @file
Belangrijkste punten
Schrijf in plaats van “doorzoek het project en vind auth.ts” `@src/lib/auth.ts`, waarna Claude het bestand direct laadt, zonder te zoeken. Dat bespaart tokens (de boomstructuur hoeft niet te worden doorzocht) en haalt een bron van hallucinaties weg (Claude hoeft het pad niet te raden; je hebt het opgegeven). Hetzelfde geldt voor opdrachten: `!git status` wordt uitgevoerd zonder toolaanroep en de uitvoer komt in de context.
Bestandsaanvulling begint met het symbool `@`. Begin een pad te typen en Claude toont suggesties. Je kunt naar meerdere bestanden tegelijk verwijzen: `@src/lib/auth.ts @src/lib/session.ts @prisma/schema.prisma`.
```bash
# Prompt zonder exacte paden (slecht):
> Bekijk de auth-logica en los de sessiebug op
# Prompt met @-verwijzingen (goed):
> @src/lib/auth.ts @src/lib/session.ts - los de bug op: na uitloggen wordt de cookie niet gewist
```
De tweede truc in dezelfde groep is de shellmodus met `!`:
```bash
> !git status # wordt uitgevoerd zonder Claude aan te roepen, uitvoer komt in context
> !npm test # hetzelfde
> !cat /var/log/app.log | tail -50 # hetzelfde
```
Waarom: je verspilt geen tokens aan “Claude, bekijk git status” - Claude zou via de tool toch hetzelfde antwoord krijgen. `!` is korter en goedkoper.
Dit hangt samen met `CLAUDE.md`: het hoofdbestand moet maximaal 200 regels met projectregels bevatten. Specifiekere regels (bijvoorbeeld API-conventies) horen in `.claude/rules/api-design.md` met YAML-frontmatter `paths: ["src/api/**/*.ts"]`. Ze worden dan alleen geladen wanneer Claude bestanden in `src/api/` bewerkt. Zie voor het volledige overzicht de [CLAUDE.md-gids](https://ailoot.ai/blog/nl/claude-md-template/).
## Voortgang bij lange taken behouden met plannen in fasen en \[ \] / \[x\]
Belangrijkste punten
Elke taak die meer dan 30 minuten werk kost, heeft een plan in een apart bestand nodig: `plans/YYYY-MM-DD-name.md`, met fasen en selectievakjes `[ ]` / `[x]`. Het plan hoort in een bestand, niet in de chat. Zo kunnen parallelle vensters verschillende fasen oppakken zonder elkaar in de weg te zitten en zie je makkelijk de voortgang, in plaats van die uit de chat te moeten “onthouden”.
Dit is het sjabloon voor het planbestand dat ik in elk project gebruik:
```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.
```
De regel is absoluut: **elke agent moet het plan na elke sessie bijwerken**. Zodra je een fase afrondt, ga je naar het bestand en markeer je die als `[x]`. Als je dat niet doet, weet het volgende venster niet dat de fase klaar is en zal het die opnieuw proberen uit te voeren.
Als het plan in een bestand staat en niet in je hoofd:
- Parallelle vensters (zie tip 6) kunnen verschillende fasen oppakken.
- Als de taak 3 dagen duurt, zie je wanneer je 2 dagen later terugkomt meteen waar je was gebleven.
- De eindcontrole aan de hand van het daadwerkelijke resultaat is eenvoudig (`grep -c "\[ \]"` in het bestand = het aantal dat nog openstaat).
Wanneer je het **niet** hoeft te gebruiken: een hotfix van 5 minuten, een triviale bewerking in één bestand, een log lezen en samenvatten. Niet elke handeling heeft een plan nodig.
Deze techniek maakt deel uit van het Second Brain-concept. Zie voor het volledige overzicht van de mappen `business/`, `plans/`, `ai-clone/` de [gids over de Second Brain](https://ailoot.ai/blog/nl/tweede-brein-claude-code/).
## Vooraf zien waar Claude zal falen met zelfkritiek aan de hand van 10 redenen
Belangrijkste punten
Zet Claude vóór je aan een complexe functie begint in de adversariële modus: “Stel je voor dat het project is mislukt. Een jaar later ben ik tijd en energie kwijt. Noem 10 redenen waarom. Spaar me niet; wees hard.” Zo prik je door vroeg optimisme heen en komen blinde vlekken boven die Claude in de modus “laten we het implementeren” nooit zou noemen.
Dit is het promptkader dat ik letterlijk gebruik:
```
Stel je voor dat de ideeënbundel is doorlopen met een methode waarbij je al denkt alsof het project volledig is mislukt. Noem 10 redenen waarom ik over een jaar veel tijd zal hebben besteed en het idee een mislukking blijkt te zijn. Je taak is niet om mijn gevoelens te sparen, maar om zo hard mogelijk te zijn.
Na de 10 redenen - een tweede ronde: verdedig elke reden tegen mijn tegenargumenten. Waar ben ik het zwakst?
Derde ronde: schrijf een plan om te voorkomen dat deze problemen zich voordoen.
```
Ik voer dit uit in drie fasen:
1. **Het eerste idee “alles is geweldig”** - wanneer ik zeker ben. Zelfkritiek snoeit 30-50% van het idee weg.
2. **Halverwege het plan** - wanneer ik al diep in het werk zit en blind ben geworden.
3. **Vóór de lancering** - een laatste filter.
Claude daagt je in de adversariële modus echt uit. GPT-5 prijst in dezelfde situatie eerst het idee en “probeert daarna verbeteringen te vinden”. Ik merkte dit verschil na een jaar experimenteren:
Voor mij ziet het verschil in adversariële modus er zo uit: ChatGPT zegt: “Goed gezien, dat klopt helemaal.” Claude zegt in dezelfde situatie: “Mee eens, dat is complete onzin; ik doe het nu opnieuw.” Wanneer ik kritiek nodig heb, bespaart de tweede reactie me dagen verspild werk.
Wanneer je het **niet** moet toepassen: positieve iteraties op UI en copywriting. De adversariële modus past daar niet - die smoort de creativiteit.
Deze techniek staat bekend als een projectpremortem. Ik heb de techniek aangepast voor samenwerking met een **AI-agent**: in plaats van met een team mensen voer je een premortem uit met Claude. Niemand is bang om te zeggen “baas, het project gaat mislukken” - en blinde vlekken komen binnen enkele minuten boven.
## 5 bronnen onderzoeken in de tijd die één bron kost met parallelle subagents
Belangrijkste punten
Start vóór je aan een functie begint 5 parallelle onderzoeksagents via subagents. Elk richt zich op een eigen gebied: professionele netwerken, open source, accelerators, concurrenten, vergelijkingen. Ze zijn binnen 10-20 minuten terug. Daarna voegt een aparte synthese-agent alles samen in één rapport. Dit bespaart uren en vermindert bevestigingsbias.
Dit is het promptkader:
```
Je hebt al de volledige context. Doe diepgaand onderzoek; start 5 parallelle subagents.
Subagent 1: doorzoek professionele netwerken - wie lost dit probleem op?
Subagent 2: open-sourceoplossingen op GitHub - wat is populair?
Subagent 3: startupaccelerators - wie trekt
investeringen aan in deze niche?
Subagent 4: websites van directe concurrenten - wat beloven ze en
tegen welke prijs?
Subagent 5: vergelijkingen en recensies - wat
zeggen gebruikers in beoordelingen?
Wanneer iedereen terug is, start je een synthese-agent
die de 5 rapporten onderling vergelijkt en een overzicht opstelt
voor mijn second-brain-map.
```
Wat er verandert ten opzichte van gewoon onderzoek:
- Tijd: 5 gelijktijdige stromen in plaats van 5 opeenvolgende. Een uur werk in 15 minuten.
- Diepgang: elke agent specialiseert zich. De bevestigingsbias van één agent besmet de andere niet.
- Context: elke subagent heeft een eigen context, los van je hoofdcontext.
Zie voor de volledige gids over subagents [“Claude Code-subagents in 2026”](https://ailoot.ai/blog/nl/claude-code-subagents/). Daarin wordt ook het verschil tussen Skills en MCP uitgelegd - en wanneer je welke gebruikt.
Wanneer je dit **niet** moet toepassen: cosmetische bewerkingen, bugfixes, kleine technische taken. Onderzoek is overkill voor alles onder “een nieuwe functie die 1+ dag werk kost”.
## Claude vanaf je telefoon opdrachten geven met een Telegram-bot op zak
Belangrijkste punten
Koppel Claude Code via de officiële plugin aan je Telegram-bot. Op je computer (waarvan de slaapstand is uitgeschakeld) draait Claude Code in een terminal die aan het project is gekoppeld. Je kunt het overal via de bot berichten sturen: “bekijk de nieuwste commits”, “wat was de omzet van bonnetjes deze week”, “lees alle supportvragen van vanavond”. De bot antwoordt met de volledige projectcontext - code, commitgeschiedenis, de hele structuur van `business/`. Een actieve agent in je codebase die alles ziet en onthoudt.
Zo stel je het in (4 stappen):
1. **Een computer die continu aanstaat** - ik schakel de slaapstand uit in de systeeminstellingen (macOS: Energy Saver → Voorkom dat de computer in de sluimerstand gaat).
2. **Claude Code draait in een terminal**, gekoppeld aan de projectmap.
3. **De officiële Telegram-plugin** - voeg de marketplace toe met `/plugin marketplace add anthropics/claude-plugins-official` en installeer vervolgens `/plugin install telegram@claude-plugins-official` (de exacte stappen veranderen in de loop der tijd - de nieuwste instructies staan in de [officiële pluginrepo](https://github.com/anthropics/claude-plugins-official)).
4. **De bot is gekoppeld aan één sessie** - dit is momenteel een beperking: één bot = één project = één sessie. Als je een tweede nodig hebt, stel je een tweede bot in.
Wat ik elke dag met de bot doe:
- Ik ben aan het wandelen en krijg een idee - ik stuur het meteen naar de bot zodat ik het niet vergeet. De bot voegt het toe aan `inbox.md` om later te verwerken.
- Een gesprek met een potentiële klant - na het gesprek vraag ik de bot: “noem op basis van het transcript van het laatste gesprek de 3 belangrijkste pijnpunten die in ons voordeel werken”. Een minuut later heb ik een volledige analyse in de chat.
- 's Ochtends in een café - “toon de openstaande huiswerkopdrachten uit mijn lijst”. De laptop hoeft niet open.
⚠️ Een addertje onder het gras: voorlopig kun je `/clear` of `/compact` niet vanuit de bot uitvoeren - de botsessie is dezelfde als de terminalsessie en de context blijft groeien. Opnieuw starten kan alleen handmatig via de terminal.
Voor mij is dit de nuttigste Claude Code-uitbreiding van de afgelopen twee weken. Het bracht me van “ik werk met Claude als ik aan mijn bureau zit” naar “ik werk met Claude zodra ik een idee heb”.
## Wat pak je als eerste op: een 7-dagenplan
Belangrijkste punten
Probeer niet alle 11 tips op één dag toe te passen - je raakt uitgeput en ze beklijven niet. Een plan van 7 dagen: dag 1-2 - sneltoetsen (1-3), dag 3-4 - opdrachten (4-5), dag 5-6 - parallel werken (6-7), dag 7 - planning en premortem (8-9). Parallelle subagents en de Telegram-bot (10-11) zijn voor week twee, zodra je de eerste 9 onder de knie hebt.
| Dag | Wat we implementeren | Hoe lang het duurt |
|----|----|----|
| 1 | Shift+Tab + Esc Esc | 30 minuten oefenen |
| 2 | Vertrouwd raken met Shift+Tab + Esc Esc | een halve dag werken |
| 3 | /compact + /cost | 30 minuten + 1-2 werksessies |
| 4 | --model haiku/sonnet/opus | 30 minuten + wat experimenteren |
| 5 | --resume voor benoemde sessies | 30 minuten |
| 6 | git worktrees - als je 3+ parallelle taken doet | 1 uur |
| 7 | Plan in `plans/` + de prompt “10 redenen waarom ik zal falen” | 1-2 uur eenmalig |
| 8-14 (week twee) | Subagents voor onderzoek + Telegram-bot | 3-4 uur om in te stellen en eraan te wennen |
De combinatie van technieken is belangrijker dan elk afzonderlijk. Shift+Tab zonder Esc Esc maakt experimenteren eng. `/compact` zonder `/cost` betekent dat je niet weet wanneer je moet comprimeren. Plannen in bestanden zonder parallelle vensters leveren complicatie zonder voordeel op.
Zodra de eerste 9 tips vanzelf gaan, stap je over op het volledige systeem: **AI-kloon + Second Brain + [Context Engineering](https://ailoot.ai/blog/nl/context-engineering/)**. Dit is de methode waarmee ik Claude zes maanden achter elkaar heb laten werken - zonder hallucinaties, contextverlies of halverwege een taak te stoppen.
Om verder met modellen te werken, kun je naar [Ailoot](https://ailoot.ai/).
## Vragen en antwoorden
### Hoe weet ik dat Plan Mode actief is?
Gebruik Shift+Tab om van modus te wisselen en lees de modusindicator voordat je de taak verstuurt. Stop zodra die plan toont; een vast aantal toetsaanslagen is onbetrouwbaar omdat de beginmodus en beschikbare modi kunnen verschillen.
### Gebruik ik /clear of /compact als de context volraakt?
Gebruik /compact wanneer je aan dezelfde taak verdergaat, met een aanwijzing over het plan en de beslissingen die bewaard moeten blijven. Gebruik /clear wanneer de taak klaar is en de volgende taak verse context nodig heeft; bewaar belangrijke voortgang eerst in het planbestand.
## Ailoot · Het bedrijf en zijn projectenportefeuille
Ailoot bouwt op opgebouwde operationele ervaring, een groot klantenbestand, een stabiele dienst en doorlopende KPI-controle.
Het bedrijf en zijn projectenportefeuille: miljoenen klanten; maandelijkse verkopen in de miljarden.
Ailoot gebruikt die operationele ervaring voor API-toegang tot AI-functies in klantproducten, agents, applicaties en automatiseringen.