Claude Code Auto Mode en Channels: bouw code vanaf elke plek

Stel je voor: je zit in de trein. Je laptop thuis is bezig met een refactor die 30 minuten duurt. Je telefoon trilt: Telegram toont een samenvatting van je eigen Claude Code-bot. Tests slagen, dit is wat er veranderde, dit is wat er brak. Je typt de volgende instructie, vergrendelt je telefoon en leest verder.

Twee features van Claude Code maken die loop mogelijk. Auto Mode haalt de goedkeuringsprompts weg die de sessie anders zouden ophouden. Channels stuurt berichten uit Telegram, Discord of iMessage door naar de live sessie alsof je ze zelf typt. 

In deze tutorial zetten we beide vanaf nul op en draaien we een schrijf-test-debugloop vanaf je telefoon.

Als je nieuw bent met de LLM’s van Anthropic, raad ik je aan eerst onze cursus Introduction to Claude Models te volgen.

Vereisten

Om deze tutorial te volgen heb je nodig:

• Claude Code v2.1.83 of nieuwer (Auto Mode vereist v2.1.83, Channels werkt vanaf v2.1.80)
• Bun-runtime geïnstalleerd (elke Channels-plugin vereist dit; Node en Deno werken niet)
• Een Claude-abonnement op Max-, Team- of Enterprise-niveau, of API-toegang. Auto Mode is niet beschikbaar op Pro, er is geen add-on om het aan te zetten (en het is ook niet beschikbaar via extra-gebruik)
• Een Telegram-account op je telefoon
• Python 3.10 of later op de hostmachine
• Een machine die wakker kan blijven terwijl jij weg bent (laptopklep open, desktop aan of een server)

Wat is Claude Code Auto Mode (en waarom combineren met Channels)?

Claude Code vraagt toestemming voordat het iets doet buiten het project. Volgens Anthropic’s eigen data keuren gebruikers 93% van die prompts toch goed. Bij dat percentage voegen de prompts frictie toe zonder extra veiligheid.

Auto Mode vervangt dat patroon door een classifier. Elke toolaanroep gaat naar een apart Claude-model (Sonnet 4.6) dat de actie beoordeelt en toestaat of blokkeert. Lange onbewaakte runs stoppen met elke dertig seconden om goedkeuring te vragen.

De classifier draait op een ander model dan het model dat de code schrijft. Een gejailbreakt of verkeerd aangestuurd hoofdmodel kan het niet misleiden om een foute call toe te staan. Een aparte probe scant tooloutput (inhoud van bestanden, webfetches, shell-stdout) op prompt-injectionpogingen voordat die de context van Claude bereiken.

Niet elke toolaanroep gaat door de classifier. Reads, tekstzoekopdrachten, codenavigatie en bestandsbewerkingen binnen je projectdirectory lopen via een snellere route zonder review. Shell-commando’s, webfetches, alles wat een bestand buiten het project raakt en elke subagentspawn gaan naar de classifier.

Anthropic publiceerde de cijfers in de aankondiging van Auto Mode. Bij 10.000 echte toolcalls produceerde de pipeline 0,4% false positives. Bij 52 zorgvuldig geselecteerde overijverige acties lag het false-negativepercentage op 17%. --dangerously-skip-permissions vervangen door Auto Mode is een duidelijke winst. Zorgvuldige menselijke review vervangen niet: de classifier mist één op de zes.

Als de classifier een call blokkeert, krijgt Claude de weigering terug als toolresultaat. Van Claude wordt verwacht dat hij een veiliger pad vindt, niet dat hij het blok omzeilt. Na drie blokkades op rij of twintig in totaal, geeft Auto Mode de controle terug aan jou. Headless claude -p-runs beëindigen in plaats daarvan.

Auto Mode vs bypassPermissions

Ik begon Auto Mode te gebruiken in de verwachting van een slimmere bypassPermissions. Mijn bezwaar tegen bypass was dat het alles toeliet: .env-bestanden lezen, configs bewerken, enzovoort. 

Auto Mode lost dat op. Bewerkingen aan gevoelige bestanden en expliciete removals worden standaard geweigerd. De override is het bestand in de prompt benoemen, waardoor de classifier de bewerking kan toestaan. Dat is beter dan bypass, dat geen dergelijke check had.

Wat me verraste aan Auto Mode is dat het een beslismodus is, niet alleen een toestemmingsmodus. Ik draaide eerder een keten van Claude Code-skills achter elkaar, een pipeline om een feature te implementeren of te debuggen. Onder bypassPermissions stopte Claude tussen de stappen en vroeg toestemming om door te gaan. 

Dat patroon vond ik prettig: de pauze was het moment om het werk te reviewen of Claude te laten doorgaan. In Auto Mode beslist Claude zelf of hij genoeg context heeft om naar de volgende stap te gaan. De reviewcheckpoints waar ik op vertrouwde, zijn weg. Je verwelkomt óf de snellere runs óf je mist de pauzes met een mens in the loop.

De andere verrassing ging de andere kant op. Onder bypassPermissions weigerde Claude als ik vroeg om zijn eigen config of skills te bewerken. Bypass of niet, hij vroeg het me toch. In Auto Mode heeft Claude daar meer vrijheid: skillbestanden, .claude/-instellingen en zijn eigen configuratie zijn bewerkbaar zonder te vragen. Dat is handig voor zelfonderhoudende skills, maar een risico als je verwacht dat Claude van zijn eigen config afblijft.

Auto Mode vs andere toestemmingsmodi

Claude Code wordt geleverd met vier modi, op een spectrum tussen “alles goedkeuren” en “niets goedkeuren”. De tabel hieronder is de korte versie. De officiële docs geven de lange versie.

Mijn advies: gebruik default voor gevoelige repo’s waar elke write een extra blik nodig heeft, auto voor je eigen projecten en bypassPermissions alleen binnen een wegwerpcontainer waar de risico-omvang beperkt is.

Hoe channels in het plaatje passen

Claude Code-channels zijn MCP-servers die events in je draaiende sessie sturen. We gebruiken de Telegram-plugin; de Discord- en iMessage-plugins werken hetzelfde. Je stuurt een DM naar de bot, de plugin stuurt het bericht door naar de sessie en Claude werkt aan je lokale bestanden. Een antwoord komt terug via de bot zodra de beurt klaar is.

Claude stuurt je alleen een bericht aan het einde van de beurt. Er is geen streaming tussendoor, geen live preview van wat Claude op de host doet. Wat Claude in een beurt draait, draait gewoon. Je hoort het pas bij de samenvatting. Daarom telt de toestemmingsmodus via een channel zwaarder dan aan de terminal.

Channels kunnen toestemmingsprompts doorsturen naar je telefoon in default of acceptEdits. Je antwoordt yes of no vanuit Telegram. Voor een handvol prompts is dat prima. Een echte build-test-debugsessie stuurt er tientallen, en door elk daarvan tikken gaat snel vervelen.

Het andere uiterste is erger. --dangerously-skip-permissions haalt de prompts weg, maar via een channel mis je het live overzicht van toolcalls in de terminal. Niets vertelt je dat er net een risicovol commando draaide. Aan de terminal kun je bij bypass in elk geval meekijken en op Esc slaan. Via Telegram typ je een prompt en ontdek je aan het einde van de beurt wat er gebeurde.

Auto Mode zit tussen die twee. Geen promptspam. De classifier blokkeert zelfstandig de duidelijk gevaarlijke stappen. De eindboodschap van de beurt geeft je een controleerbaar overzicht van wat er draaide. Voor remote werk is dat de beste trade-off.

Het demoproject

Ik heb een kleine demo gebouwd genaamd libcache. Het is een Python-CLI die boekmetadata haalt van de OpenLibrary-API en responses cachet onder ~/.cache/libcache/. 

De stack is expres saai: uv beheert dependencies, typer handelt de CLI af, httpx doet de HTTP-calls en pytest draait de tests.

Drie dingen aan libcache zijn van belang. 

1. Het is multi-file, dus een build-from-scratch in default-modus zou zeker een dozijn toestemmingsprompts opstapelen. 

2. Er is een HTTP-grens, waardoor de classifier een echte afweging moet maken. 

3. Het is snel genoeg klaar dat de hele scaffold in één Telegram-beurt past.

Auto Mode en Telegram Channels instellen

Drie dingen op volgorde: hostmachine wakker, plugin gekoppeld, Auto Mode actief. Als een van die drie faalt, werkt de rest niet.

De hostmachine voorbereiden

Claude Code is een lokaal proces. Als de machine slaapt, stopt het proces met het ontvangen van events. De Telegram-plugin kan je berichten dan nergens afleveren. Events komen alleen binnen zolang de sessie open is.

Op macOS open je een aparte terminal en voer je uit:

caffeinate -d

De -d-vlag voorkomt dat het scherm slaapt. Linux-hosts kunnen in plaats daarvan de sleeptargets maskeren:

sudo systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target

Dat is omkeerbaar met unmask.

Voor alles langer dan een middag draai je de sessie binnen tmux. Dat houdt je shell in leven over gesloten vensters en verbroken SSH-verbindingen heen. Start een nieuwe sessie:

tmux new -s claude

Start Claude erin, ontkoppel met Ctrl+B, dan D, en koppel later weer aan:

tmux attach -t claude

Nog één ding voor je start. Elke CLI-tool die Claude vanaf Telegram zou kunnen aanroepen, moet al geauthenticeerd zijn op de host. Interactieve logins of authenticaties kunnen niet vanaf de telefoon. Controleer gh, de GitHub-CLI die we vandaag gebruiken:

gh auth status

Als die niet geauthenticeerd is, voer gh auth login uit en rond de browserflow af. Doe hetzelfde voor elke andere CLI die je door Claude wil laten bereiken (aws, gcloud, docker, package registers) voor je andere projecten.

De Telegram-plugin installeren en configureren

Installeer Bun als je dat nog niet hebt. Op macOS of Linux:

curl -fsSL https://bun.sh/install | bash

Op Windows:

powershell -c "irm bun.sh/install.ps1 | iex"

Bevestig de installatie:

bun --version

Maak vervolgens de Telegram-bot aan.

Open BotFather in Telegram, stuur /newbot, kies een weergavenaam en een gebruikersnaam die eindigt op bot (zoiets als libcache_dev_bot). Kopieer de token die BotFather terugstuurt.

Terug in een Claude Code-sessie, installeer de plugin:

/plugin install telegram@claude-plugins-official

Als Claude Code meldt dat de marktplaats hem niet heeft, voeg hem dan handmatig toe en probeer opnieuw:

/plugin marketplace add anthropics/claude-plugins-official

Als de installatie klaar is, herlaad de plugins zodat de Telegram-tools zichtbaar worden:

/reload-plugins

Configureer de bot met de token van BotFather:

/telegram:configure <your_bot_token_here>

De token wordt weggeschreven naar ~/.claude/channels/telegram/.env.

Na /telegram:configure sluit je Claude Code volledig af (druk Ctrl+D of voer /exit in) en start opnieuw. /reload-plugins is niet altijd betrouwbaar om de pairingcode bij het eerste DM te tonen.

Start de sessie opnieuw, open de bot in Telegram en stuur /start. De bot antwoordt met een 6-teken pairingcode.

Terug in Claude Code, koppel met de code:

/telegram:access pair <code>

Pairing is symmetrisch. Beide kanten moeten akkoord gaan voordat de sessie berichten accepteert.

Laatste stap. Vergrendel de bot tot alleen jouw account:

/telegram:access policy allowlist

Iedereen die niet op de allowlist staat en de bot een DM stuurt, wordt stilletjes gedropt, zonder pairingcode.

Starten met Auto Mode en Channels actief

Start vanaf een projectdirectory Claude met beide flags:

claude --channels plugin:telegram@claude-plugins-official --permission-mode auto

Een bestaande sessie kan halverwege naar Auto Mode schakelen: druk herhaaldelijk op Shift+Tab tot de statusbalk auto toont. Om Auto Mode standaard te maken bij elke start, voeg dit toe aan ~/.claude/settings.json:

{ "permissions": { "defaultMode": "auto" } }

Bij het inschakelen van Auto Mode laat Claude Code brede allowregels uit settings.json vallen. Blanket-Bash(*), wildcard-interpreters zoals Bash(python*) en brede Agent-toestemmingen worden bij binnenkomst gedropt en bij verlaten hersteld. Smalle regels zoals Bash(pytest) blijven ongewijzigd.

Verifieer de setup. DM de bot iets en wacht op een reply. Vraag Claude dan om een klein bestand in het project te schrijven en zie het zonder prompt verschijnen. Als beide werken, is de setup klaar.

Claude Code Auto Mode en Channels in actie

Laten we kijken hoe we dit in de praktijk vanaf Telegram opstarten.

Eén prompt, veel toolcalls, nul goedkeuringen

Stuur een openingsprompt vanuit Telegram. Wat telt is het soort taak: een die in default-modus een dozijn goedkeuringsprompts zou opstapelen. Voor libcache was de prompt ongeveer:

Create a Python CLI that fetches book metadata from OpenLibrary and caches it to disk, use uv for deps, typer for the CLI, httpx for requests, pytest for tests, scaffold the directory and add a README, and when you're done, summarize what you built in under 80 words.

De “vat samen in minder dan 80 woorden”-staart is een kleine channel-specifieke gewoonte. Antwoorden aan het einde van de beurt komen op je telefoon binnen, en een telefoon is geen fijne plek om lange output te lezen.

De plugin stuurt het telefoonbericht de draaiende sessie op de host in. Het verschijnt als een ← telegram · <sender>: ...-banner in de terminal.

Bestandsschrijfacties binnen het project nemen de snelle route en slaan de classifier volledig over. Dependency-installaties, de initiële pytest-run en de afsluitende git init gaan via de classifier en worden standaard toegestaan. Niets pauzeert en de beurt draait van begin tot eind in één keer door.

Op de telefoon is de samenvatting het enige signaal terug tijdens de beurt.

Lange prompts typen op een telefoon is pijnlijk. Spraak-naar-tekst doet het meeste werk, en korte, declaratieve prompts zijn prima. “Scaffold libcache, OpenLibrary + disk cache, onder 80 woorden” is genoeg.

De iteratieloop: vraag, werk, antwoord, herhaal

Elke vervolgactie draait dezelfde loop. Eén bericht vanuit Telegram, één beurt werk, één samenvatting terug. De samenvatting is het relaas van Claude, niet de feitelijke staat. Vraag Claude om de tests te draaien en de letterlijke output te plakken:

uv run pytest -v

Vraag om cat op een specifiek bestand. Vraag om bestandsgroottes of regeltellingen, of een recente commitgeschiedenis:

git log --oneline

Auto Mode draait verificatiecalls via dezelfde snelle paden als de rest. De kosten van vragen zijn laag. Het resultaat is een claim die je vanaf je vergrendelscherm kunt checken zonder naar de laptop te lopen.

Nog een beurt om te bewijzen dat de loop echte externe systemen bereikt. Vanaf de telefoon:

push libcache to a new public GitHub repo called libcache, clean commit, decent message, send me the URL when it's up.

Claude gebruikt de gh-CLI die je eerder authenticeerde en antwoordt met de repo-URL.

Als Auto Mode werkt, voelt de loop rustig. De volgende sectie laat zien wat er gebeurt als dat niet zo is.

Wanneer Auto Mode tegenwerkt

Auto Mode onderbreekt je op twee manieren. 

De classifier hardblokkeert een kleine set patronen: 

• curl | bash-pipes

• Force-pushes naar main

• Massale verwijderingen in cloudopslag. 

Zachter en vaker pauzeert Claude zelf bij acties die onomkeerbaar zijn. Beide verschijnen op de telefoon hetzelfde: geen rode banner, geen modal, gewoon normale tekst. Claude benoemt de actie, somt de commando’s op en vraagt om een specifieke bevestigingszin voordat hij doorgaat.

Een destructief verzoek als “verwijder het project, haal de GitHub-repo ook neer” triggert de onomkeerbaarheidspauze. Het antwoord zet de commando’s uiteen en biedt veiligere alternatieven: archiveren, alleen lokaal of alleen remote. Er wordt gewacht op een zin die Claude kiest, niet op ja/nee.

Dezelfde screenshot toont een tweede-orde-gedrag. Halverwege de verwijdering liep Claude tegen een ontbrekende scope op de gh-CLI (de token had geen delete_repo). In plaats van half werk te leveren, pauzeerde Claude en vroeg me een interactief commando aan de terminal te draaien:

gh auth refresh -h github.com -s delete_repo

Auto Mode kan geen browsergebaseerde authflows aansturen en Claude probeerde het ontbrekende scope-recht niet te omzeilen.

Sessiegeschiedenis is geen impliciete toestemming. Zelfs voor een repo die Claude zelf een kwartier eerder in dezelfde sessie maakte, triggert de pauze nog steeds bij verwijderen. Dezelfde limiet van 3 op rij / 20 totaal geldt. Opgestapelde onderbrekingen geven uiteindelijk de controle terug aan de mens.

Twee bekende bugs om op te letten. Berichten worden soms niet bezorgd wanneer Claude Code inactief is bij de REPL-prompt (issue #48404). Na één response stopt de plugin soms met het doorsturen van nieuwe berichten totdat je hem een zetje geeft (issue #36477). Workarounds zijn een beurt in gang houden of de sessie herstarten. Geen van beide heeft al een fix.

Auto Mode-veiligheidsregels tunen

Voor het meeste werk aan je eigen codebase zijn de standaardinstellingen van Auto Mode voldoende. Als je specifieke paden wilt verharden of andere juist versoepelen, begin dan met lezen wat Anthropic voor je heeft ingericht:

claude auto-mode defaults

Dat print de ingebouwde block- en allowregels als JSON. De structuur is bedoeld om uit te breiden, niet te vervangen: bewerk de baseline, begin niet from scratch. Elke regel die je laat vallen, dwingt de classifier tot een beslissing, en elke beslissing is een kans op een false negative.

Voeg projectspecifieke regels toe in settings.json onder de sleutel permissions. Smalle allows blijven in Auto Mode ongewijzigd. Brede worden bij binnenkomst gedropt. Een regel als Bash(pytest) of Bash(gh pr create *) is specifiek genoeg dat de classifier je oordeel vertrouwt. In de praktijk: één smalle allow per tool die het project echt draait, geen wildcards.

Als je workflow leunde op toestemmingsprompts als reviewgates tussen pipelinestappen, breng die checkpoints expliciet terug. Voeg ask-regels toe voor de toolpatronen of paden waarop je Claude wil laten pauzeren. Of verplaats die workflow naar acceptEdits in plaats van auto om de promptcheckpoint te behouden op alles behalve in-project bestandsbewerkingen.

Nog een onderbenutte feature: de classifier behandelt grenzen die in het gesprek worden vermeld als blocksignalen. Zeg tegen Claude: “niet pushen tot ik heb gereviewd”, en het blokkeert bijpassende acties zelfs als standaardregels ze zouden toestaan. Een simpel alternatief voor het schrijven van een formele regel voor één sessie.

Om de effectieve config te zien nadat je settings.json met de defaults is samengevoegd:

claude auto-mode config

Enterprise-beheerders kunnen de feature org-breed uitzetten via permissions.disableAutoMode: 'disable' in managed settings.

Conclusie

Auto Mode plus Channels verandert Claude Code van een bureautool in een async partner die je overal vandaan aanstuurt. De classifier beslist welke toolcalls doorgaan. Claude beslist wanneer een actie serieus genoeg is om te pauzeren. Jij bepaalt de prompts, de scope en de regels. De terminal is één plek waar je kunt werken, niet de enige.

Voor meer verdieping raad ik onze gidsen aan over Claude Code Remote Control, Claude Code Plugins en Claude Code Best Practices.