Claude Code Mobiele Workflows: Programmeer Overal

Claude Code Mobiele Workflows: Programmeer Overal

Ik zat in de wachtkamer van de tandarts toen mijn deployment crashte.

Niet een klein probleempje. Het soort waarbij een Slack-notificatie van je monitoring-bot je maag doet omdraaien — 502-fouten die door drie microservices raasden, een databasemigratie die in staging werkte maar in productie vastliep, en een klant die over vijfenveertig minuten het platform aan zijn directie zou demonstreren.

Mijn laptop lag thuis. Mijn desktop stond thuis. Alles wat ik had was mijn telefoon en een groeiend gevoel van paniek.

Zes maanden geleden eindigde dat scenario met mij die naar mijn auto sprintte. Vandaag opende ik Claude Code op mijn telefoon, maakte verbinding met mijn desktopcomputer via een beveiligde tunnel, en had binnen negentig seconden een AI-agent die de migratiefout analyseerde. Ik keurde de fix goed vanaf de passagiersstoel van mijn vrouws auto terwijl zij ons naar huis reed. De demo van de klant ging prima. Ze hebben er nooit iets van gemerkt.

Dat moment maakte iets duidelijk waar ik al weken omheen draaide: de mobiele mogelijkheden van Claude Code zijn stilletjes een van zijn krachtigste features geworden, en bijna niemand benut ze volledig. De meeste ontwikkelaars kennen Remote Control — ik schreef een uitgebreide analyse van die functie toen het uitkwam. Maar Remote Control is slechts één workflow in een spectrum dat varieert van "even snel checken vanaf de bank" tot "volledige toegang tot je lokale machine, overal ter wereld."

Ik heb de afgelopen maand elke mobiele workflow getest die Claude Code ondersteunt. Ik heb geprogrammeerd vanuit lounges op luchthavens, koffietentjes, een rijdende trein, en ja — die wachtkamer bij de tandarts. Sommige workflows zijn doodeenvoudig. Andere vereisen een power-user setup die dertig minuten kost maar maandenlang rendeert. En de afwegingen zijn niet vanzelfsprekend totdat je zelf tegen de beperkingen aanloopt.

Hier is alles wat ik geleerd heb — de setups die werkten, de setups die frustreerden, en de exacte configuratie die ik nu dagelijks gebruik.

De Vier Mobiele Workflows (En Wanneer Welke Zinvol Is)

Voordat we in setupgidsen en terminalcommando's duiken, heb je een mentaal model nodig. Claude Code heeft niet "één mobiele modus." Het heeft vier verschillende workflows, elk met andere mogelijkheden, andere beperkingen en andere setupkosten. De verkeerde kiezen voor jouw situatie is de snelste manier om gefrustreerd te raken en te concluderen dat mobiel programmeren niet werkt.

Hier is het overzicht:

De eerste drie zijn ingebouwd in Claude Code zelf. De vierde is een aangepaste setup met externe tools die alle beperkingen van de andere wegneemt. De meeste ontwikkelaars zullen een combinatie van twee of drie gebruiken, afhankelijk van de situatie.

Ik ga ze allemaal doorlopen in de volgorde waarin ik ze ontdekte — wat toevallig ook de volgorde is van toenemende kracht en complexiteit. Maar hier is wat de meeste artikelen je niet vertellen: je hebt waarschijnlijk niet alle vier nodig. De afwegingen begrijpen stelt je in staat de juiste twee te kiezen voor jouw workflow en de rest te negeren.

Workflow 1: Remote Control — De Instap

Als je Claude Code langer dan een week gebruikt, ben je Remote Control waarschijnlijk al tegengekomen. Het is de eenvoudigste mobiele workflow en degene die Anthropic als instappunt heeft ontworpen. Ik behandelde de gedetailleerde setup en het beveiligingsmodel in een eerder artikel, dus ik focus me hier op de praktische patronen in plaats van de basis te herhalen.

Het kernconcept: je start een Claude Code-sessie op je desktop, schakelt Remote Control in, en je telefoon wordt een live venster in die sessie. Elk bericht, elke bestandswijziging, elke tool-aanroep synchroniseert in realtime. Je telefoon draait Claude Code niet — het bestuurt de instantie die al op je machine draait.

Wat het geweldig maakt:

Je volledige lokale omgeving blijft intact. MCP-servers, custom skills, projectconfiguraties, bestandssysteemtoegang — alles werkt precies zoals wanneer je achter je bureau zit. De AI-agent die op je machine draait, weet niet en geeft er niet om dat je instructies van een telefoon komen in plaats van een toetsenbord.

De setup duurt oprecht twee minuten. Voer claude remote-control uit in je projectmap, scan de QR-code met je telefoon, klaar. Of als je midden in een gesprek zit, typ /rc en scan. Ik heb de mijne geconfigureerd om standaard altijd ingeschakeld te zijn — één stap minder wanneer ik mijn telefoon moet pakken en van mijn bureau wegloop.

Waar het tekortschiet:

De sessie moet op je desktop beginnen. Je kunt geen Remote Control-sessie starten vanaf je telefoon. Als je het huis verliet zonder eerst Claude Code te starten, is deze workflow nutteloos. Ik leerde dit op de harde manier op een zaterdagochtend toen ik een idee voor een feature had terwijl ik boodschappen deed, mijn telefoon pakte en realiseerde dat ik geen actieve sessie had om mee te verbinden.

Er is ook de terminalafhankelijkheid. Je desktopterminal moet open blijven. Klap je laptop dicht, laat hem in slaapstand gaan, of verlies stroom — de sessie sterft. De 10-minuten netwerktimeout is ook echt. Als je thuisinternet langer dan ongeveer tien minuten hapert, verbreekt de sessie en verlies je de gesprekscontext.

Mijn werkelijke gebruikspatroon:

Ik gebruik Remote Control bijna elke dag, maar altijd reactief. Ik werk aan mijn bureau, iets trekt me weg — een vergadering, een wandeling, een kind dat aandacht nodig heeft — en ik /rc naar mobiel voordat ik opsta. Het is de "verbreek de flow niet"-workflow. Het is niet de "begin iets nieuws vanaf de bank"-workflow.

Dat onderscheid is belangrijk, en het dreef me naar de andere drie opties.

Workflow 2: Claude Code op het Web — De Cloudsnelweg

Deze verraste me. Toen Anthropic Claude Code op het web lanceerde, nam ik aan dat het een afgezwakte versie was — een marketingvinkje voor "werkt op mobiel." Ik had het mis. Het is een wezenlijk ander hulpmiddel met een wezenlijk andere use case.

Claude Code op het web draait volledig op de cloudinfrastructuur van Anthropic. Je opent het in je mobiele browser of de Claude iOS/Android-app, kiest een GitHub-repository en start een sessie. Claude kloont de repo in een beveiligde cloudomgeving, doet het werk, en als het klaar is krijg je een merge-klaar pull request.

Geen desktop nodig. Geen terminal. Geen SSH. Geen configuratie.

De workflow in de praktijk:

Ik zat in een koffietentje toen een bijdrager een issue opende op een van mijn open-source repo's — een CSS-renderingbug op de documentatiesite. Ik opende Claude Code op het web vanaf mijn telefoon, autoriseerde de repo (een eenmalige stap via GitHub), beschreef de bug en liet Claude aan het werk gaan. Acht minuten later had ik een PR met de fix. Ik bekeek de diff op mijn telefoon, keurde het goed en mergede. Totale tijd van notificatie tot gedeployde fix: twaalf minuten, vanuit een koffietentje, op een telefoon.

Dat is de magie van de cloudworkflow. Voor zelfstandige taken tegen GitHub-repo's komt niets anders in de buurt van de snelheid waarmee je van "dat zou ik moeten fixen" naar "het is gefixt" gaat.

Wat je verliest:

Alles wat lokaal is. Je MCP-servers bestaan niet in de cloudomgeving. Je custom Claude skills zijn niet geladen. Je .claude/-directoryconfiguraties, je lokale databases, je omgevingsvariabelen — niets daarvan wordt overgedragen. De cloudomgeving is een schone sandbox met je repocode en niets meer.

Dit betekent dat de cloudworkflow perfect is voor:

• Bugfixes in open-source projecten
• Snelle feature-toevoegingen aan repo's die niet afhankelijk zijn van lokale services
• Parallelle taakwachtrijen — start vijf cloudsessies op vijf verschillende repo's tegelijk
• Prototyping van nieuwe ideeën in verse repositories

En het is verschrikkelijk voor:

• Projecten die afhankelijk zijn van lokale databases of services
• Workflows die MCP-servers of aangepaste toolconfiguraties gebruiken
• Alles dat toegang nodig heeft tot bestanden buiten de repository
• Werk dat je specifieke ontwikkelomgeving vereist

De frictie van repo-autorisatie:

Hier is het gedeelte dat enigszins onhandig is. Voordat je een GitHub-repo kunt gebruiken met Claude Code op het web, moet je het autoriseren via de GitHub-integratie. Dit is een eenmalige stap per repo, maar het moet via de mobiele browser — de GitHub mobiele app ondersteunt het niet. De flow is: open github.com in je telefoonbrowser, navigeer naar de repo en autoriseer het in de instellingen van Claude Code.

Niet verschrikkelijk, maar ook niet naadloos. Ik heb al mijn actieve repositories vooraf geautoriseerd zodat ik nooit deze frictie tegenkom op het moment zelf. Als je meer dan een handvol repo's beheert, raad ik aan hetzelfde te doen tijdens een rustige middag in plaats van te worstelen met OAuth-flows wanneer je daadwerkelijk iets moet shippen.

Nieuwe repo's aanmaken vanaf mobiel:

Dit werkt, maar met een kanttekening. De mobiele GitHub-app ondersteunt het aanmaken van nieuwe repositories niet — je hebt de volledige mobiele webinterface nodig. Navigeer naar github.com/new in je telefoonbrowser, maak de repo aan, autoriseer het in Claude Code en start dan een cloudsessie. Ik heb deze flow gebruikt om nieuwe projectrepo's op te zetten vanaf mijn telefoon en Claude de hele codebase te laten opbouwen. Het werkt. Het is niet elegant. Maar wanneer inspiratie toeslaat en je momentum wilt vasthouden, verslaat "niet elegant maar functioneel" altijd "ik doe het wel als ik thuis ben."

Workflow 3: Server Mode — Desktopsessies Starten Vanaf Je Telefoon

Hier wordt het mobiele verhaal echt krachtig, en hier stoppen de meeste mensen met lezen omdat de setup intimiderend klinkt. Dat zou niet moeten. Server Mode is de brug tussen "mijn telefoon kan alleen bestaande sessies voortzetten" en "mijn telefoon kan elke sessie starten op elk project."

Het concept: je configureert je desktopmachine om Claude Code in server mode te draaien. Het zit daar te luisteren naar verbindingen. Vanaf je telefoon — via de Claude mobiele app — kun je een gloednieuwe sessie starten op elke projectmap op je desktop, met volledige toegang tot je lokale bestandssysteem, MCP-servers en custom skills.

Zie het als Remote Control, maar dan omgekeerd. In plaats van "ik zit aan mijn bureau en wil mobiel gaan," is het "ik zit op mijn telefoon en wil terug naar mijn bureau reiken."

Het opzetten:

Op je desktop, voer uit:

claude server-mode --remote-control

Dit start Claude Code in een persistente serverstatus. Het toont een sessie-URL en luistert naar inkomende verbindingen van je geauthenticeerde apparaten. De --remote-control vlag is cruciaal — zonder deze accepteert de server alleen lokale verbindingen.

Je wilt dit laten draaien in een apart terminaltabblad of, beter nog, in een terminal multiplexer zoals tmux (meer daarover in het power-user gedeelte). Het serverproces moet actief blijven voor mobiele verbindingen.

Vanaf je telefoon, open de Claude-app, en je desktopmachine verschijnt als een beschikbaar verbindingsdoel. Selecteer het, kies een projectmap, en je bent binnen — een verse Claude Code-sessie die op jouw hardware draait, bestuurd vanaf je telefoon.

Waarom dit belangrijker is dan het klinkt:

Het verschil tussen cloudsessies en server mode-sessies is het verschil tussen "AI die je code kan bewerken" en "AI die in je daadwerkelijke omgeving kan werken." Wanneer ik via server mode verbinding maak met mijn desktop, heeft Claude toegang tot:

• Mijn lokale PostgreSQL-databases voor testen
• Mijn Docker-containers en Kubernetes-clusters
• Mijn MCP-servers (de Figma-integratie, de Notion-bridge, mijn custom SEO-toolkit)
• Mijn projectspecifieke .claude/-configuraties en custom skills
• Bestanden buiten de repository — documentatie, designbestanden, configuratiebestanden

Dat laatste punt wordt onderschat. De helft van mijn workflow omvat Claude die bestanden raadpleegt over meerdere projecten heen. De cloudomgeving kan dat niet. Server mode wel.

De eerlijke beperking:

Je desktop moet aan staan, verbonden zijn met internet, en het serverproces moet draaien. Als je machine een laptop is die in slaapstand gaat als je hem dichtklapt, is server mode onbetrouwbaar. Als je thuisinternet uitvalt, verlies je toegang. Dit is geen kritiek — het is een fysieke beperking. Je telefoon maakt verbinding met je echte machine, en echte machines kunnen onbereikbaar zijn.

Wat ons brengt bij de setup die alles oplost.

Workflow 4: De Power User Stack — Tailscale + Termius + tmux

Dit is wat ik daadwerkelijk gebruik. Elke dag. Overal vandaan.

De eerste drie workflows delen allemaal een gemeenschappelijke beperking: ze zijn afhankelijk van het ingebouwde netwerk van Claude Code om je telefoon en je desktop te verbinden. Dat netwerk is goed — versleuteld, beveiligd, goed ontworpen — maar het is beperkt. Je hebt een actieve Claude-sessie nodig voordat je kunt verbinden. Je terminal moet open blijven. Netwerkonderbrekingen verbreken de verbinding.

De power user stack omzeilt al die beperkingen door je rauw terminaltoegang te geven tot je desktop vanaf je telefoon. Zodra je dat hebt, kun je Claude Code starten, stoppen, tussen projecten wisselen, processen beheren en letterlijk alles doen wat je zou kunnen als je achter je toetsenbord zat. Je telefoon wordt een volwaardige terminal, niet alleen een afstandsbediening voor Claude Code.

Drie tools maken dit mogelijk:

Tailscale creëert een beveiligd, versleuteld mesh-netwerk tussen al je apparaten. Je telefoon, je desktop, je laptop, een cloud-VM — ze nemen allemaal deel aan hetzelfde privénetwerk en kunnen elkaar direct bereiken, ongeacht welk WiFi-netwerk of mobiele verbinding ze gebruiken. Geen port forwarding. Geen routerconfiguratie. Geen blootstelling van je machine aan het publieke internet.

De gratis laag van Tailscale ondersteunt tot 3 gebruikers en 100 apparaten — meer dan genoeg voor een individuele ontwikkelaar. Ik zit al maanden op het gratis plan zonder enige frictie. De betaalde plannen beginnen bij $5/maand als je meer gebruikers of functies nodig hebt, maar eerlijk gezegd heb ik nog niet hoeven upgraden.

Termius (of Blink Shell, of elke SSH-client) geeft je een echte terminalinterface op je telefoon. Termius is mijn keuze omdat de iOS-toetsenbordervaring het minst pijnlijk is die ik gevonden heb — en "minst pijnlijk" maakt enorm veel uit wanneer je commando's typt op een telefoon. Het ondersteunt SSH-sleutelauthenticatie, verbindingsprofielen en persistente sessies.

tmux is het geheime wapen dat de hele stack betrouwbaar maakt. Het is een terminal multiplexer — een programma dat terminalsessies actief houdt onafhankelijk van je verbinding. Start een tmux-sessie, draai Claude Code erin, verbreek SSH, sluit de Termius-app, stop je telefoon in je zak, vlieg naar een ander land, maak opnieuw verbinding — en je Claude Code-sessie is precies waar je hem achterliet. Elk bericht, elk bestand, elke agentstatus. tmux geeft er niet om dat je drie uur verdwenen was. De sessie draaide de hele tijd door op je desktop.

Dit is het cruciale verschil met de 10-minuten timeout van Remote Control. tmux-sessies overleven oneindig. Je Claude Code-agent kan midden in een taak zitten, een complexe refactoring over twintig bestanden verwerken, en je kunt naar believen verbinding verbreken en weer maken zonder ook maar één byte aan context te verliezen.

De Power Stack Opzetten (Eenmalig, 30 Minuten)

Hier is de exacte setup die ik gebruik. Dit gaat uit van een Mac-desktop, maar dezelfde aanpak werkt op Linux. Windows-gebruikers kunnen WSL2 gebruiken.

Stap 1: Installeer en configureer Tailscale op je desktop

# macOS - Installeer via Homebrew
brew install tailscale

# Start de Tailscale daemon
sudo tailscaled install-system-daemon

# Authenticeer - dit opent een browservenster
tailscale up

Na authenticatie, noteer het Tailscale IP-adres van je machine. Het zal zoiets zijn als 100.x.x.x. Je kunt het vinden met:

tailscale ip -4

Stap 2: Installeer Tailscale op je telefoon

Download Tailscale uit de App Store (iOS) of Play Store (Android). Log in met hetzelfde account dat je op je desktop gebruikte. Je telefoon en desktop zitten nu op hetzelfde privénetwerk. Je kunt dit verifiëren door het Tailscale IP van je desktop te pingen vanaf je telefoon.

Stap 3: Schakel SSH-toegang in op je desktop

Op macOS, schakel Remote Login in:

# Schakel SSH in via de opdrachtregel
sudo systemsetup -setremotelogin on

# Of: Systeeminstellingen → Algemeen → Delen → Remote Login → Aan

Controleer of SSH werkt via Tailscale door te testen vanaf een ander apparaat:

ssh [email protected]

Pro tip: Stel SSH-sleutelauthenticatie in in plaats van wachtwoordauthenticatie. Het is zowel veiliger als sneller vanaf een telefoon waar wachtwoorden typen pijnlijk is.

# Op je telefoon (in Termius, genereer een sleutelpaar)
# Kopieer de publieke sleutel naar je desktop:
ssh-copy-id [email protected]

Stap 4: Installeer tmux op je desktop (als het nog niet aanwezig is)

brew install tmux

Maak een minimale tmux-configuratie die mobiel gebruik draaglijk maakt:

# ~/.tmux.conf
set -g mouse on           # Schakel touch-scrollen in
set -g history-limit 50000 # Bewaar voldoende scrollgeschiedenis
set -g status-style 'bg=#333333 fg=#ffffff'
set -g default-terminal "screen-256color"

Stap 5: Installeer Termius op je telefoon

Download Termius uit de App Store. Maak een nieuwe hostverbinding aan:

• Hostname: het Tailscale IP van je desktop (100.x.x.x)
• Gebruikersnaam: je Mac-gebruikersnaam
• Authenticatie: SSH-sleutel (geconfigureerd in stap 3)

Sla de verbinding op. Tik erop. Je zou de terminalprompt van je desktop moeten zien.

Stap 6: De daadwerkelijke workflow

Open Termius op je telefoon en maak verbinding met je desktop. Dan:

# Start een nieuwe tmux-sessie met de naam 'claude'
tmux new -s claude

# Navigeer naar je project
cd ~/projects/jouw-project

# Start Claude Code met remote control ingeschakeld
claude --remote-control

Nu heb je twee manieren om met Claude te communiceren:

1. Direct via de terminal in Termius (commando's typen)
2. Via de Claude mobiele app via Remote Control (de mooiere interface)

Ik start de sessie meestal in Termius en schakel dan over naar de Claude-app voor het daadwerkelijke gesprek. De interface van de Claude-app is ontworpen voor mobiel — betere toetsenbordafhandeling, markdown-rendering, syntax highlighting voor code. Termius is mijn backstage-pas; de Claude-app is waar ik het echte werk doe.

Wanneer je de verbinding wilt verbreken:

Sluit gewoon Termius. Of sluit de Claude-app. Of stop je telefoon in je zak. tmux houdt de sessie actief op je desktop. Wanneer je terugkomt — of dat nu vijf minuten of vijf uur later is — maak opnieuw verbinding via Termius en herverbind:

tmux attach -t claude

Alles is precies waar je het achterliet. Claude heeft misschien een taak afgerond terwijl je weg was. De output staat daar in je terminal, wachtend tot je het leest.

Waarom Deze Stack Beter Is Dan De Ingebouwde Opties

Ik wil eerlijk zijn over de afwegingen, want die begrijpen is het hele punt.

Het ingebouwde Remote Control is eenvoudiger — geen twijfel mogelijk. Twee minuten setup versus dertig minuten. Geen extra software. Anthropic regelt het netwerk. Voor casual mobiel gebruik — even een agent checken, een paar bewerkingen goedkeuren terwijl je de hond uitlaat — is Remote Control de juiste keuze. Ik gebruik het nog steeds dagelijks.

Maar Remote Control heeft een hard plafond. Je kunt geen nieuwe sessies starten vanaf mobiel. Je kunt niet tussen projecten wisselen. Je kunt je machine niet beheren. De 10-minuten netwerktimeout betekent onbetrouwbare verbindingen op wispelturige mobiele netwerken. En als je terminal sluit, is de sessie weg.

De power stack heeft geen plafond. Ik heb Claude Code-sessies gestart vanaf luchthaven-WiFi in drie verschillende landen. Ik heb gewisseld tussen vijf projecten in één mobiele sessie. Ik heb een langlopende agenttaak opgestart, mijn telefoon twee uur weggelegd, en ben teruggekomen bij een afgeronde feature branch met zevenentwintig bestandswijzigingen — allemaal zonder dat de sessie ooit risico liep om te time-outen.

De dertig minuten setupkosten verdienen zichzelf terug de eerste keer dat je echt werk moet doen vanaf je telefoon en de ingebouwde tools niet toereikend zijn.

Wat Ik Fout Deed (En Wat Jij Waarschijnlijk Ook Fout Zult Doen)

Ik wil drie fouten delen die ik maakte bij het opbouwen van mijn mobiele workflow, omdat ik andere ontwikkelaars dezelfde fouten zie maken.

Fout 1: Mobiel programmeren behandelen als "desktopprogrammeren op een kleiner scherm."

Mijn eerste instinct was om mijn telefoon op dezelfde manier te gebruiken als mijn desktop — code-diffs lezen, bestandsbomen bekijken, gedetailleerde instructies typen. Dit is ellendig. Telefoonschermen zijn klein. Telefoontoetsenborden zijn onnauwkeurig. Tegen die realiteit vechten leidt tot frustratie.

De mentale verschuiving die alles veranderde: mobiel Claude Code is voor aansturen, niet voor implementeren. Ik geef instructies op een hoger niveau vanaf mijn telefoon dan vanaf mijn desktop. In plaats van "refactor de authenticatie-middleware om JWT te gebruiken met RS256-ondertekening en voeg het publieke sleutelrotatie-endpoint toe," zeg ik "het auth-systeem moet naar JWT — je kent de codebase, regel het, en ik review de PR." Claude heeft genoeg context uit de projectbestanden en gespreksgeschiedenis om de details in te vullen die ik normaal zou specificeren.

Dit vergde echt vertrouwensopbouw. Ik moest verifiëren dat Claude's autonome beslissingen overeenkwamen met mijn standaarden over een dozijn projecten voordat ik me comfortabel voelde om dat niveau van vrijheid te geven. Maar zodra het vertrouwen er was, werd mobiel programmeren dramatisch productiever. Ik ben geen typist op mijn telefoon — ik ben een regisseur.

Fout 2: GitHub-repo's niet vooraf autoriseren.

De eerste keer dat ik Claude Code op het web probeerde te gebruiken vanaf mijn telefoon voor een noodgeval bij een klant, besteedde ik vier minuten aan het worstelen met GitHub's OAuth-flow in een mobiele browser. Vier minuten klinkt niet als veel, maar wanneer een productiesysteem plat ligt, voelt elke seconde als een jaar. Autoriseer elke repo die je mogelijk nodig hebt vooraf. Doe het nu, op je desktop, waar de flow vijftien seconden duurt. Je toekomstige zelf, in paniek op een parkeerplaats, zal je dankbaar zijn.

Fout 3: tmux negeren tot ik het nodig had.

Ik draaide de power-user stack zonder tmux de eerste twee weken, denkend "mijn verbinding is stabiel genoeg." Het werkte prima totdat ik in een trein zat, midden in een gesprek met Claude over een lastige databaseschemawijziging, en mijn telefoon van zendmast wisselde. De SSH-verbinding viel weg. De Claude Code-sessie — die al veertig minuten draaide en diepe context had over het schemaontwerp — was weg. Ik moest opnieuw beginnen.

Ik installeerde tmux diezelfde avond. De volgende keer dat mijn verbinding wegviel in de trein, verbond ik opnieuw en typte tmux attach -t claude. Elk bericht was er nog. Claude was midden in een zin toen ik de verbinding verloor. Het maakte de zin af toen ik opnieuw verbond. De sessie had niet eens gemerkt dat ik weg was geweest.

tmux is niet optioneel voor mobiele workflows. Het is de veiligheidsgordel. Je slaat het niet over omdat de weg er glad uitziet.

Je Workflow Kiezen: Een Besliskader

Na een maand van het testen van elke combinatie, hier is mijn praktische aanbeveling op basis van wie je bent en hoe je werkt.

Als je programmeert vanaf één desktop en af en toe even wegloopt: Gebruik Remote Control. Schakel het standaard in in je Claude Code-instellingen. Leer de /rc-sneltoets. Dat is alles. Je hebt de complexiteit van de andere workflows niet nodig, en onnodige infrastructuur toevoegen creëert onderhoudslasten zonder rendement.

Als je bugs wilt fixen en snelle PR's wilt shippen vanaf je telefoon: Voeg Claude Code op het web toe aan je toolkit. Autoriseer je actieve GitHub-repo's vooraf. Gebruik het voor zelfstandige taken die je lokale omgeving niet nodig hebben. Gecombineerd met Remote Control dekt dit 80% van de mobiele use cases.

Als je volledige lokale toegang wilt vanaf mobiel en je bent comfortabel met wat setup: Voeg Server Mode toe. Configureer je desktop om claude server-mode --remote-control te draaien bij het opstarten. Dit geeft je de kracht van je lokale omgeving vanaf je telefoon zonder third-party tools. De enige beperking is dat je desktop aan en online moet zijn.

Als je de "programmeer letterlijk overal"-setup wilt zonder compromissen: Bouw de volledige power stack. Tailscale (gratis), Termius (gratis tier werkt), tmux (gratis, vooraf geïnstalleerd op de meeste systemen). Dertig minuten setup, en je hoeft nooit meer na te denken over beperkingen van mobiel programmeren.

Ik draai alle vier. Remote Control voor even snel wegstappen. Cloudsessies voor parallel open-source werk. Server Mode als backup. En de Tailscale + Termius + tmux stack als mijn dagelijkse werkpaard voor alles serieus. De workflows vullen elkaar aan in plaats van te concurreren.

Wat Er Komt — En Waarom Ik Oplettend Volg

De mobiele programmeerervaring is de afgelopen drie maanden alleen al dramatisch verbeterd. Toen Remote Control voor het eerst werd gelanceerd als research preview in februari 2026, was het de enige optie. Nu hebben we vier verschillende workflows, door de community gebouwde tools zoals Happy die alternatieve mobiele clients bieden, en Anthropic die actief de cloud-omgevingsfeatures doorontwikkelt.

Een paar dingen die ik in de gaten houd:

De cloudomgeving wordt steeds capabeler. Toen gh CLI-ondersteuning eind 2025 werd toegevoegd, ontsloot het GitHub-operaties direct vanuit cloudsessies. Als Anthropic MCP-serverondersteuning toevoegt aan cloudomgevingen — zelfs een samengestelde subset — wordt het verschil tussen cloud- en lokale sessies aanzienlijk kleiner.

Sessiepersistentie is de volgende grens. Op dit moment sterven Remote Control-sessies wanneer je terminal sluit. De tmux-workaround lost dit op, maar een native oplossing zou de drempel verlagen voor ontwikkelaars die geen terminal multiplexers willen beheren. Het zou me niet verbazen als Anthropic dit direct adresseert.

En de mobiele app zelf wordt steeds beter. De toetsenbordafhandeling, de codeweergave, het gespreksmanagement — elke update maakt programmeren op de telefoon minder een compromis en meer een echte workflow. We zijn nog niet op gelijk niveau met desktop. Maar we zijn dichter bij dan ik had verwacht in maart 2026.

Hier is waar ik steeds op terugkom: de vraag is niet meer "kun je programmeren op je telefoon?" Dat is beantwoord. De vraag is "naar welke programmeerworkflow grijp je wanneer je niet achter je bureau zit?" En het antwoord hangt af van wat je bouwt, waar je bent, en hoeveel setup je bereid bent vooraf te investeren.

Mijn tandartsmoment leerde me iets onverwachts. De waarde van mobiel programmeren gaat niet over meer uren werken. Het gaat over het loskoppelen van je creatieve en productieve momenten van je fysieke locatie. Sommige van mijn beste architecturale beslissingen zijn genomen tijdens wandelingen, in wachtkamers en in treinen — momenten waarin de afstand tot mijn bureau me afstand gaf van mijn aannames. De mogelijkheid hebben om meteen op die inzichten te handelen, in plaats van te hopen dat ik ze later herinner, heeft niet alleen veranderd waar ik werk maar hoe ik over werk denk.

Stel dit weekend een van deze workflows in. Begin met Remote Control als je het nog nooit geprobeerd hebt. Stap over naar de power stack wanneer je tegen het plafond aanloopt. En de volgende keer dat je ergens vastzit zonder je laptop, pak je telefoon en begin te bouwen.

Veelgestelde Vragen

Kan ik Claude Code op mijn telefoon gebruiken zonder enige setup?

Ja — Claude Code op het web draait volledig in de cloud van Anthropic en vereist geen lokale setup. Open het in de Claude iOS- of Android-app, koppel een GitHub-repository en begin te programmeren. Je hebt geen toegang tot lokale bestanden of MCP-servers, maar voor zelfstandige taken tegen GitHub-repo's werkt het meteen.

Werkt Claude Code Remote Control op Android?

Remote Control werkt op zowel iOS als Android via de officiële Claude-app. Het setupproces is identiek — voer claude remote-control uit op je desktop, scan de QR-code met je telefoon. De functie vereist een Claude Pro of Max abonnement.

Wat gebeurt er met mijn Claude Code-sessie als mijn telefoon de verbinding verliest?

Dat hangt af van je setup. Met alleen Remote Control verbreekt een netwerkonderbreking langer dan ongeveer 10 minuten de sessie. Met de tmux power-user stack overleeft je sessie oneindig — tmux houdt het draaiend op je desktop ongeacht de verbindingsstatus van je telefoon. Verbind opnieuw en typ tmux attach om precies te hervatten waar je gebleven was.

Is de Tailscale + Termius + tmux setup veilig?

Tailscale creëert een versleuteld WireGuard mesh-netwerk tussen je apparaten — geen verkeer raakt het publieke internet. SSH voegt een extra versleutelingslaag toe. Gecombineerd met sleutelgebaseerde authenticatie (geen wachtwoorden) is deze setup aantoonbaar veiliger dan de meeste cloudgebaseerde alternatieven. Het gratis Personal-plan van Tailscale ondersteunt tot 3 gebruikers en 100 apparaten per maart 2026.

Kan ik een nieuw project starten vanaf mijn telefoon met Claude Code?

Ja, via twee methoden. Claude Code op het web laat je nieuwe repo's aanmaken en opzetten vanuit je mobiele browser (maak de repo aan op github.com/new, autoriseer het en start een cloudsessie). Met de power-user stack kun je via SSH verbinding maken met je desktop vanaf je telefoon en Claude Code starten in elke map — nieuw of bestaand — met volledige lokale omgevingstoegang.

Laten We Samenwerken

Wilt u AI-systemen bouwen, workflows automatiseren of uw technische infrastructuur opschalen? Ik help u graag.

• Fiverr (maatwerk & integraties): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise-oplossingen): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (beveiligingsdiensten): xcybersecurity.io