Claude Code vom Smartphone starten — robust und unabhängig

Was du am Ende dieses Tutorials hast

Du startest morgens am Rechner eine Claude-Code-Session. Mittags im Zug holst du dein Handy raus, öffnest einen SSH-Client, tippst zwei Buchstaben und arbeitest in derselben Session weiter — als säßest du noch am Schreibtisch. Abends im Hotel startest du vom Handy eine neue Session in einem anderen Projekt, ohne dein Notebook auspacken zu müssen.

Das ist kein Spielzeug-Setup. Ich nutze es als Solo-Freelancer, der viel unterwegs arbeitet. Es ersetzt nicht das Arbeiten am Schreibtisch, aber es schließt eine Lücke, die mir vorher gefehlt hat: kurz reinschauen, einen Befehl absetzen, etwas anstoßen, ohne den ganzen Laptop hochzufahren.

---

Warum ich dieses Setup gebaut habe

Der Auslöser war ein bestimmtes Problem. Unterwegs habe ich oft die besten Ideen — auf dem Spaziergang, in der Bahn, beim Kaffee. Ich greife dann zur Claude-Mobile-App, bespreche etwas, klär eine Strategie, sortiere Gedanken. Dort entstehen wertvolle Konversationen, genau das, wofür die App gemacht ist.

Das Problem: Dieser Kontext lebt komplett in der Mobile-App-Welt — getrennt von dem Kontext, der in meinen Claude-Code-Sessions auf dem Hauptrechner sitzt. Zwei Gedächtnisse, zwei Welten, viel Doppelarbeit. Eine Idee, die ich unterwegs durchdacht habe, musste ich am Schreibtisch neu erklären, weil Claude Code sie nicht "kannte". Jeder Sprung zwischen den Werkzeugen war ein Kontextverlust.

Mein Lösungsansatz war: alles auf Claude Code konsolidieren — auch unterwegs. Damit landet jede Idee, jede Klärung, jede Notiz in derselben persistenten Knowledge-Schicht, die schon in deinem lokalen Setup lebt: projektspezifische CLAUDE.md-Dateien, MCP-Server, Auto-Memory, Custom Slash Commands wie mein /save, das Worklog und Memory in einem Schritt aktualisiert. Kein Kontext-Split mehr.

Das ist nicht nur ein bequemes Setup für mich. Es ist Teil davon, wie ich für Kunden arbeite. Persistenter Projekt-Kontext bedeutet: kein doppeltes Erklären, keine vergessenen Details, kein erneutes Onboarding bei jedem Folge-Auftrag. Was du Claude einmal sagst, weiß es beim nächsten Mal noch. Das ist die Disziplin hinter CLAUDE.md, Custom Skills und Memory-System — und dieselbe Disziplin, mit der ich in Kundenprojekten arbeite. Im Branchen-Jargon nennt sich das Context Engineering. Praktisch heißt es: weniger Reibung, mehr Output, ohne dass mir relevante Details auf der Strecke bleiben.

---

Diese Anleitung führt dich vollständig durch das Setup. Du brauchst keine tiefen Linux-Kenntnisse, aber ein Terminal sollte dich nicht erschrecken. Geschätzter Zeitbedarf: 45 bis 60 Minuten.

---

Zwei Wege, Claude vom Handy zu nutzen

Bevor du loslegst, solltest du den Unterschied zwischen den zwei verfügbaren Pfaden kennen. Die meisten Menschen brauchen einen davon, manche beide.

Funktion	Offizielle Claude-App (Remote Control)	SSH + Tailscale + tmux (dieses Tutorial)
Tasks an laufende Session senden	✓	✓
Neue Claude-Code-Session vom Handy starten	nein	ja
Beliebige Projektordner ansprechen	nur die laufende	ja, alle
Funktioniert, wenn Claude noch nicht läuft	nein, Desktop-Session muss aktiv sein	ja
Echtes Terminal mit beliebigen Shell-Befehlen	nein	ja
Multi-Session parallel verwalten	begrenzt	ja
Setup-Zeit	wenige Minuten	etwa eine Stunde
Vendor-Bindung	an Anthropic-Account	keine, Standard-Werkzeuge

Die offizielle App ist ein guter Sidekick für leichte Eingriffe in laufende Arbeit. Wenn du aber wie ein Power-User vom Handy aus volle Kontrolle willst, ist das SSH-Setup der erwachsene Weg. Beides schließt sich nicht aus, du kannst je nach Situation wechseln.

---

Voraussetzungen

Du brauchst:

• Einen Rechner (Mac, Linux oder Windows mit WSL2), auf dem Claude Code bereits installiert ist und läuft
• Ein Smartphone (Android oder iPhone — der Setup-Ablauf ist identisch, nur die SSH-Client-App variiert)
• Einen kostenlosen Tailscale-Account (legen wir gemeinsam an)
• Etwa eine Stunde Zeit für die erstmalige Einrichtung
• Kein Hosting, kein Server, keine offene Firewall — der eigentliche Trick dieses Setups

Alle verwendeten Werkzeuge sind kostenlos: Homebrew (oder das jeweilige Paket-Tool deiner Plattform), tmux, fzf, Tailscale-Personal-Plan, Termius-Starter-Tier oder vergleichbare SSH-Clients. Die monatlichen Kosten dieses Setups sind null.

Plattform-Hinweis: Diese Anleitung zeigt die Mac-spezifischen Befehle und UI-Pfade im Detail. Das Konzept aus SSH + Tailscale + tmux funktioniert identisch auf Linux und auf Windows mit WSL2 — nur die Installations-Werkzeuge und Sleep-Konfiguration weichen ab. An den passenden Stellen weise ich auf die Linux- und Windows-Äquivalente hin. Auf dem Handy ist die Setup-Reihenfolge auf Android und iPhone praktisch gleich, nur die SSH-Client-App heißt unterschiedlich (Termius funktioniert auf beiden Plattformen, Blink Shell ist die starke iPhone-Alternative).

---

Schritt 1 — Werkzeuge installieren

Auf macOS (und auf Linux, wo Homebrew ebenfalls verfügbar ist): wenn du noch kein Homebrew hast, hol es dir zuerst:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Dann installierst du die drei CLI-Werkzeuge plus Tailscale:

brew install tmux fzf
brew install --cask tailscale

Auf Linux ohne Homebrew nimmst du den Paketmanager deiner Distribution: sudo apt install tmux fzf unter Ubuntu/Debian, sudo dnf install tmux fzf unter Fedora, sudo pacman -S tmux fzf unter Arch. Tailscale hat für die meisten Distros ein eigenes Installations-Skript unter tailscale.com/download.

Unter Windows mit WSL2 nutzt du den Paketmanager der WSL-Distribution (meist Ubuntu, gleiche Befehle wie oben). Tailscale gibt es zusätzlich als nativen Windows-Client unter tailscale.com/download/windows.

tmux ist ein Terminal-Multiplexer. Du kannst dir das wie virtuelle Bildschirme im Terminal vorstellen: Sessions, die im Hintergrund weiterlaufen, auch wenn du dich ausloggst. Das ist der Kern dafür, dass Rechner und Handy sich an dieselbe laufende Claude-Session anhängen können.

fzf ist ein Fuzzy-Finder. Statt durch lange Listen zu scrollen, tippst du zwei bis drei Buchstaben und fzf filtert. Auf der Handy-Tastatur Gold wert.

Tailscale ist ein privates Mesh-VPN auf Basis von WireGuard. Es verbindet deine Geräte untereinander, ohne dass du Ports am Router öffnen musst und ohne dass irgendetwas im öffentlichen Internet sichtbar ist.

---

Schritt 2 — Tailscale aufsetzen

Öffne Tailscale.app aus dem Programme-Ordner. Beim ersten Start fragt macOS nach Berechtigungen für eine Systemerweiterung und für die VPN-Konfiguration. Beides erlauben.

Im Tailscale-Menüleisten-Icon dann auf Log In klicken. Der Browser öffnet sich, du wählst einen Auth-Provider (Google, Microsoft, GitHub oder E-Mail). Wenn du noch keinen Tailscale-Account hast, legt dich der Login direkt an — kostenlos für bis zu sechs Nutzer und unbegrenzt viele Geräte.

Sobald du eingeloggt bist, prüfst du den Status im Terminal:

tailscale status

Du solltest deinen Rechner mit einer IP aus dem Bereich 100.x.x.x sehen. Dieser Adressraum existiert ausschließlich innerhalb deines Tailscale-Netzwerks und ist im öffentlichen Internet nicht erreichbar.

100.125.149.102  dein-rechner-name  du@  -  -

MagicDNS ist standardmäßig aktiviert. Statt der IP kannst du den Rechner später auch direkt unter seinem Hostnamen ansprechen, sofern beide Geräte im selben Tailnet sind.

Architektur-Notiz: Tailscale baut zwischen deinen Geräten eine direkte verschlüsselte Verbindung auf (WireGuard). Der Tailscale-Server selbst routet keinen Traffic, er koordiniert nur, wer mit wem verbunden ist. Das heißt: Deine Daten gehen nie über fremde Server. Anders als bei klassischen VPNs.

---

Schritt 3 — SSH-Server aktivieren

Auf dem Mac

Öffne Systemeinstellungen → Allgemein → Teilen und scrolle zum Abschnitt "Erweitert". Schalte den Toggle "Entfernte Anmeldung" ein.

Direkt daneben das (i)-Info-Icon anklicken, um die Detail-Einstellungen zu öffnen:

• "Vollzugriff auf die Festplatte durch Remotebenutzer:innen erlauben" → unbedingt aus lassen. Das wäre ein viel zu weitreichender Zugriff für unseren Zweck.
• "Zugriff erlauben für" → wähle "Nur diese Benutzer" und füge den User hinzu, mit dem du am Rechner arbeitest. So können andere lokale Accounts nicht über SSH rein.

Auf Linux

Den OpenSSH-Server installieren (Beispiel Ubuntu/Debian) und aktivieren:

sudo apt install openssh-server
sudo systemctl enable --now ssh

Erlaubte User regelst du in /etc/ssh/sshd_config mit der AllowUsers-Direktive. Andere Distributionen nutzen dnf install openssh-server oder pacman -S openssh.

Auf Windows

In Einstellungen → Apps → Optionale Features "OpenSSH-Server" hinzufügen. Danach in einer Admin-PowerShell den Dienst aktivieren:

Set-Service -Name sshd -StartupType Automatic
Start-Service sshd

Verifikation: In Termius oder einem anderen SSH-Tool sollte sich der Rechner jetzt unter seiner Tailscale-IP erreichen lassen. Dazu kommen wir gleich.

Sicherheits-Einordnung: Eingebaute SSH-Server hören nach dem Aktivieren standardmäßig auf allen Netzwerk-Interfaces. Das klingt riskant, ist es aber in unserem Fall nicht: Der Rechner steht nicht im öffentlichen Internet, sondern hinter Tailscale. Selbst wenn dein WLAN im Café offen wäre, kommt niemand ohne Tailscale-Mitgliedschaft auf deinen Rechner.

---

Schritt 4 — SSH-Key am Handy einrichten

Auf dem Rechner legst du zuerst die Verzeichnisstruktur an (Befehle identisch unter macOS und Linux, unter Windows-WSL2 ebenfalls — natives Windows ohne WSL nutzt %USERPROFILE%\.ssh\authorized_keys und entsprechende ACL-Permissions):

mkdir -p ~/.ssh
chmod 700 ~/.ssh
touch ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

Diese Permissions sind wichtig — SSH lehnt Keys ab, wenn die Datei zu offen liegt. Das ist eine eingebaute Sicherheitshürde.

Jetzt zum Handy:

Termius installieren. Im Play Store nach "Termius" suchen, die App vom Anbieter Termius Corporation installieren. Erster Start erfordert einen kostenlosen Account (E-Mail plus Passwort). Cloud-Sync ist ein Pro-Feature, das du nicht brauchst.

Neuen Host anlegen. Auf das Plus-Icon tippen, "New Host" wählen. Felder:

• Alias: Mac (frei wählbar, dein Anzeigename)
• Hostname: deine Tailscale-IP aus Schritt 2, etwa 100.125.149.102
• Port: 22
• Username: dein lokaler User-Name auf dem Rechner (nicht der Anzeige-Name aus dem Login-Screen, sondern das technische Konto — meist klein geschrieben und ohne Leerzeichen; ermittelst du im Terminal mit whoami)
• Password-Feld: leer lassen, wir nutzen Key-Authentifizierung
• Mosh, Agent Forwarding, Tailnet, Host Chaining: alle aus (mehrere davon sind Pro-Features und nicht nötig)

SSH-Key generieren. Im Host-Setup gibt es einen Bereich "SSH ID". Dort auf "New SSH Key" tippen, dann "Generate" wählen:

• Type: ED25519 (modern, kompakt, sicher)
• Name: frei wählbar, etwa mac-ssh
• Passphrase: leer lassen (eine Passphrase schützt zusätzlich, ist aber auf Handy-Tastatur unbequem)

Nach dem Generieren zeigt dir Termius den Public Key. Diesen kopierst du in die Zwischenablage.

Public Key auf den Rechner übertragen. Du brauchst eine Möglichkeit, den Public Key vom Handy auf den Rechner zu bekommen. Die einfachste: per E-Mail an dich selbst, dann am Rechner öffnen und die Zeile kopieren. Alternativ funktionieren Notizen-Apps mit Sync, oder du tippst den String von Hand ab — er fängt mit ssh-ed25519 an und ist circa 80 Zeichen lang.

Auf dem Rechner fügst du den Public Key in die authorized_keys-Datei ein:

echo "ssh-ed25519 AAAAC3NzaC1...DEIN_KEY mac-ssh@handy" >> ~/.ssh/authorized_keys

Wichtig: Public Keys sind nicht geheim. Du kannst sie auch öffentlich posten, ohne Sicherheitsrisiko. Nur der Private Key, der im Termius-Keychain auf dem Handy verschlüsselt liegt, ist sicherheitsrelevant.

Tailscale am Handy installieren. Aus dem Play Store (oder App Store für iPhone), mit demselben Account einloggen, den du am Rechner verwendet hast. Auf dem Startbildschirm der Tailscale-App siehst du jetzt beide Geräte — Rechner und Handy.

Erster Test-Connect. In Termius auf den Host tippen. Beim ersten Connect kommt eine Host-Key-Verifikation: einfach Continue wählen. Du landest im Terminal-Prompt deines Rechners. Geschafft.

---

Schritt 5 — Den Rechner wachhalten

Das größte praktische Problem dieses Setups ist nicht technisch, sondern banal: Wenn dein Rechner in den Ruhezustand geht, ist er per SSH nicht erreichbar. Drei Varianten lösen das.

Auf dem Mac

Variante A — Permanent wach am Stromnetz. Im Terminal:

sudo pmset -c sleep 0
sudo pmset -c disablesleep 1

Das bewirkt: solange der Mac am Strom hängt, schläft er nie ein. Display darf weiter dunkel werden, das stört nicht. Wichtig: Der Deckel muss offen bleiben. Mit geschlossenem Deckel schickt macOS den Mac trotzdem schlafen, es sei denn, ein externer Monitor ist angeschlossen (Clamshell-Modus).

Variante B — Caffeinate on-demand. Wenn du nicht permanent wach willst, sondern nur in Reisephasen, hilft caffeinate:

caffeinate -d &

Der Prozess hält den Mac wach, solange er läuft. Per kill beendest du ihn wieder.

Auf Linux

Auf Linux-Systemen erreichst du dasselbe meist über systemd-inhibit oder die Energieeinstellungen deines Desktop-Environments. Mit GNOME zum Beispiel:

gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-ac-type 'nothing'

Bei Headless-Servern oder Distributionen ohne GUI kann auch /etc/systemd/logind.conf direkt editiert werden (HandleLidSwitch=ignore).

Auf Windows

In den Windows-Einstellungen unter System → Strom & Akku → Bildschirm und Ruhezustand lassen sich Display-Aus und Ruhezustand getrennt steuern. Für das hier beschriebene Setup setzt du "Bei Verwendung von Netzstrom in Ruhezustand wechseln nach" auf Nie. Den OpenSSH-Server gibt es seit Windows 10 als optionales Feature und ist im Settings-Panel unter "Apps → Optionale Features" nachinstallierbar.

Variante: Dedizierter Server

Wenn du das Setup ernsthaft 24/7 nutzen willst, lohnt sich ein dedizierter Rechner als stationärer Server — ein gebrauchter Mac mini, ein kleiner Intel-NUC, ein Raspberry Pi 5 oder ein günstiger Mini-PC mit Linux. Dein eigentliches Arbeitsgerät ist dann frei für die normale Nutzung. Investition: ab etwa 100 Euro für einen Pi, ab 300 Euro für einen gebrauchten M1 Mac mini.

---

Schritt 6 — tmux + cc-Skript: der eigentliche Komfort-Trick

Bis hier kannst du dich vom Handy aus einloggen und Befehle absetzen. Aber das volle Erlebnis kommt mit zwei Konfigurationsdateien.

tmux-Konfiguration

Lege auf dem Rechner die Datei ~/.tmux.conf an mit folgendem Inhalt (unter nativem Windows ohne WSL den Pfad sinngemäß übertragen):

# Prefix auf Ctrl-a (auf Handy-Tastatur leichter zu treffen)
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# Mouse-Support (Touchscreen-Scrolling)
set -g mouse on

# Längeres Scrollback
set -g history-limit 50000

# Status-Bar groß und lesbar
set -g status-position bottom
set -g status-style "bg=colour235 fg=colour255"
set -g status-left "#[bg=colour39,fg=colour16,bold] #S #[bg=colour235] "
set -g status-right "#[fg=colour248]%H:%M  #[fg=colour244]%a %d.%m."

# Splits: prefix + | (vertikal) und - (horizontal)
unbind '"'
unbind %
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

# Vim-Keys für Pane-Navigation
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# True-Color für Claude-Code-Farben
set -g default-terminal "tmux-256color"
set -ga terminal-overrides ",xterm-256color:Tc"

Diese Konfiguration ist explizit auf Mobile-Nutzung optimiert: Ctrl-a statt Ctrl-b als Prefix (auf der Handy-Tastatur einfacher zu treffen), Mouse-Support, groß lesbare Statusleiste, vim-Keys für die Pane-Navigation.

Das cc-Skript

In deiner ~/.zshrc (oder ~/.bashrc) fügst du am Ende folgende Funktion ein. Passe den Pfad in der ersten Zeile an dein Projektverzeichnis an:

cc() {
    local PROJECTS_ROOT="$HOME/projekte"

    if [ -n "$TMUX" ]; then
        echo "Bereits in tmux-Session. Mit Ctrl-a d lösen, dann erneut starten."
        return 1
    fi

    local sessions choice
    sessions=$(tmux list-sessions -F "#S" 2>/dev/null)
    choice=$(printf "%s\n+ Neue Session\n" "$sessions" | sed '/^$/d' \
        | fzf --prompt="cc » " --height=40% --reverse \
              --header="Session attachen oder neue starten")
    [ -z "$choice" ] && return 0

    if [ "$choice" = "+ Neue Session" ]; then
        local project
        project=$(
            {
                find "$PROJECTS_ROOT" -maxdepth 6 -type d -name .git 2>/dev/null
                find "$PROJECTS_ROOT" -maxdepth 6 -type f -name CLAUDE.md 2>/dev/null
            } | sed -E 's|/\.git$||; s|/CLAUDE\.md$||' | sort -u \
              | sed "s|^$PROJECTS_ROOT/||" \
              | fzf --prompt="Projekt » " --height=60% --reverse
        )
        [ -z "$project" ] && return 0

        local sess_name
        sess_name=$(basename "$project" | tr -c '[:alnum:]_-' '_' | sed 's/_*$//')

        if tmux has-session -t "$sess_name" 2>/dev/null; then
            tmux attach -t "$sess_name"
        else
            tmux new-session -d -s "$sess_name" \
                -c "$PROJECTS_ROOT/$project" "claude"
            tmux attach -t "$sess_name"
        fi
    else
        tmux attach -t "$choice"
    fi
}

Was das Skript macht: Du tippst cc und siehst sofort alle laufenden tmux-Sessions plus eine Option "+ Neue Session". Bei "Neue Session" sucht fzf rekursiv nach Projektordnern (alles, was eine .git- oder CLAUDE.md-Datei enthält) und zeigt sie in der Fuzzy-Suche. Du tippst zwei bis drei Buchstaben, drückst Enter, und Claude Code startet in dem Projektordner als neue tmux-Session.

Erster Test

Im neuen Terminal-Tab cc tippen. fzf öffnet sich, du wählst "+ Neue Session", pickst einen Projektordner, Claude Code startet in einer tmux-Session — erkennbar am Statusbalken unten.

Mit Ctrl-a d (erst Ctrl-a gedrückt halten und loslassen, dann d alleine) löst du dich aus der Session. Sie läuft im Hintergrund weiter. cc erneut zeigt sie jetzt in der Liste — du kannst sie wieder anhängen, vom Rechner oder vom Handy.

---

Voice-First-Variante: Der Hybrid mit Remote Control

Bis hier hast du ein vollwertiges SSH-Setup. Wer aber primär per Voice diktieren statt tippen will, läuft auf eine architektonische Wand: Terminal-Apps auf Android wie Termius nutzen keine Standard-Texteingabefelder, sondern lesen Tastatur-Events direkt. Voice-to-Text-Apps wie Wispr Flow oder das GBoard-Diktat hängen sich aber genau an solche Standard-Felder — beides verträgt sich systembedingt nicht. Du müsstest tippen, statt zu sprechen.

Die saubere Lösung ist ein Hybrid mit Anthropics eigener Mobile-App.

So funktioniert es

Anthropic hat seit Februar 2026 ein Feature namens Remote Control, das genau diesen Anwendungsfall abdeckt: eine lokal laufende Claude-Code-Session über die offizielle Claude-App weiterführen. Die Session selbst läuft weiter auf deinem Rechner — die Mobile-App ist nur ein zusätzliches Fenster in dieselbe Session.

Konkreter Ablauf, ausgehend vom Handy:

1. In Termius einloggen und mit cc eine Session im gewünschten Projekt starten
2. Innerhalb der Claude-Session den Befehl /remote-control eingeben — die Session registriert sich bei Anthropic und wird in der Mobile-App sichtbar
3. Termius zur Seite legen und die offizielle Claude-App öffnen
4. Im Code-Tab erscheint die Session mit grünem Status-Dot — antippen
5. Voice-Befehle reinsprechen wie gewohnt

Die Voice-Eingabe in der Claude-App ist eines ihrer Kern-Features und entsprechend ausgereift. Damit ist das Diktier-Problem nicht durch ein anderes Tool gelöst, sondern durch das passende Tool für den Job.

Was über Remote Control funktioniert

Die Mobile-App ist über Remote Control ein vollwertiger Zugang zur lokalen Claude-Code-Instanz, nicht nur ein abgespeckter Chat. Aus der Anthropic-Dokumentation:

Use your full local environment remotely: your filesystem, MCP servers, tools, and project configuration all stay available.

Konkret heißt das für dich:

• Globale Rules und Skills aus ~/.claude/rules/ und ~/.claude/skills/ wirken weiter
• MCP-Server laufen — GitHub, Drive, Klaviyo, Shopify-Dev, was auch immer du eingebunden hast
• Projekt-CLAUDE.md wird normal geladen
• Memory-System schreibt und liest wie üblich
• Custom Slash Commands wie /save und /exit funktionieren genauso

Laut Anthropic-Dokumentation sind lokal-only ausschließlich Commands, die einen interaktiven Picker im Terminal öffnen — etwa /mcp, /plugin, /resume. Alles, was Text-Output produziert oder Tools aufruft, läuft über Remote Control problemlos.

Push-Notifications als Bonus

In der lokalen Claude-Session /config eingeben und "Push when Claude decides" aktivieren. Claude pingt dich aufs Handy, wenn ein langlaufender Task fertig ist oder eine Entscheidung von dir braucht. Du musst nicht mehr selbst nachschauen.

Wann welcher Pfad

Aufgabe	Geeignetes Werkzeug
Voice-Befehle ohne Tippen geben	Mobile-App + Remote Control
Beliebige Shell-Befehle ausführen (cd, git, sed, etc.)	Termius via SSH
Neue Session in einem neuen Projekt starten	Termius via SSH mit cc
Aus dem Kontext heraus diktieren	Mobile-App + Voice
Status-Check bei lang laufenden Tasks	Termius oder Mobile-App
Mehrere Sessions parallel verwalten	Termius via SSH (tmux)

Termius und die Mobile-App nebeneinander zu haben ist nicht doppelt — sie ergänzen sich. Termius ist der Power-Modus für volle Shell-Kontrolle und freie Projektauswahl. Die Mobile-App ist der Voice-Modus für schnelles Diktieren in laufende Sessions. Du wechselst je nach Situation, beide arbeiten auf derselben tmux-Session.

---

Der Aha-Moment im Alltag

So sieht ein typischer Tag mit dem Setup aus:

Morgens am Schreibtisch: Du startest cc, wählst dein Hauptprojekt, Claude beginnt mit einer Code-Recherche oder Refactoring-Aufgabe. Du läufst los zum Termin.

Mittags im Café: Termius am Handy auf, deinen Host antippen, cc tippen, deine laufende Session auswählen. Du siehst, was Claude inzwischen gefunden hat, gibst zwei Folge-Befehle, schließt die App.

Abends im Hotel: Du fällst dir auf, dass ein anderer Kunden-Job angeschoben werden müsste. Termius auf, cc, "+ Neue Session", das andere Projekt picken. Eine zweite Session läuft parallel, ohne dass die erste gestört wird.

Nächster Morgen am Schreibtisch: cc zeigt dir beide laufenden Sessions. Du wählst die wichtige, machst weiter, als hättest du sie nie verlassen.

Der Witz an tmux ist das Multi-Attach: Rechner und Handy können gleichzeitig dieselbe Session sehen. Was du auf der einen Seite tippst, erscheint live auf der anderen. Praktisch, wenn du zwischen den Geräten ohne mentalen Kontextwechsel hin und her gehen willst.

---

Sicherheit — drei Layer

Das Setup ist deutlich sicherer als ein typischer Cloud-Server mit offenem SSH-Port. Drei Schichten greifen ineinander:

Layer 1 — Tailscale. Dein Rechner ist nicht im öffentlichen Internet erreichbar. Kein Port am Router offen, kein NAT-Forwarding, kein DynDNS. Selbst wenn jemand wüsste, dass dein Rechner existiert, kann er ihn nicht erreichen, weil er nicht Mitglied deines Tailnets ist. Alle Verbindungen sind End-to-End mit WireGuard verschlüsselt.

Layer 2 — SSH-Key-Authentifizierung. Nur wer den Private Key besitzt, kommt rein. Der liegt verschlüsselt im Termius-Keychain auf deinem Handy. ED25519-Keys gelten nach aktuellem mathematischen Stand als nicht knackbar. Optional kannst du Passwort-Login komplett deaktivieren, indem du in /etc/ssh/sshd_config die Zeile PasswordAuthentication no setzt — dann ist der Key die einzig mögliche Methode.

Layer 3 — Account-Scope. Nur User, die du im OS-eigenen Sharing- bzw. SSH-Configuration explizit zugelassen hast, dürfen sich überhaupt einloggen. Wenn dein Rechner mehrere Accounts hat, bleibt der Rest ausgesperrt.

Realistische Restrisiken:

Szenario	Möglich?	Was schützt
Brute-Force-SSH-Login aus dem Internet	nein	Tailscale — kein öffentlicher Port
Tailscale-Account übernommen	sehr selten	2FA bei deinem Auth-Provider (Google, Microsoft) aktivieren
Handy gestohlen und entsperrt	denkbar	Termius-App-Lock (Biometrie), zusätzlich: Gerät in Tailscale-Admin entfernen — sofort kein Zugang mehr

---

Häufige Stolperfallen

Der Rechner schläft trotz Setup ein. macOS' Standard-Setting ist sehr aggressiv (nach einer Minute Inaktivität geht das Notebook schlafen) — pmset -c sleep 0 löst das am Stromnetz. Linux- und Windows-Nutzer kontrollieren das über ihre jeweiligen Energieeinstellungen. Bei Notebooks mit geschlossenem Deckel bleibt das Schlaf-Verhalten oft aktiv, es sei denn, ein externer Monitor ist angeschlossen.

Tailscale-Login läuft ab. Tailscale-Sessions sind standardmäßig zeitlich begrenzt. Bei Personal-Plan-Nutzern liegt das Ablauf-Intervall bei 180 Tagen. Du wirst rechtzeitig per E-Mail erinnert und musst dich dann neu einloggen — ist eine Minute Arbeit.

Erste SSH-Verbindung scheitert. Häufige Ursachen: Tailscale am Handy noch nicht aktiv, SSH-User-Name falsch geschrieben (gibst du den im Apple-Menü angezeigten Namen ein, scheitert es — du brauchst den technischen User-Namen aus dem Terminal: whoami), oder Permissions an ~/.ssh/authorized_keys zu offen (muss chmod 600 sein).

Die installierte Tailscale-App bietet keine tailscale-CLI im Terminal. Die App-Variante hat eine andere Architektur als die Standalone-Version. Du kannst dir mit einem kleinen Wrapper-Skript helfen, das die App-Binary mit korrektem argv[0] aufruft.

Tastenkombination am Handy ungewohnt. tmux-Befehle sind immer sequenziell, nicht gleichzeitig. Ctrl-a d heißt: Ctrl-a drücken und loslassen, dann d alleine drücken. Auf der Termius-Tastatur findest du Ctrl als Hilfstaste in der Werkzeugleiste über der Tastatur.

---

Wann was — Empfehlung

Wer regelmäßig vom Handy aus arbeitet und mehr will als nur Folge-Befehle an eine laufende Session zu geben, kommt um das SSH-Setup nicht herum. Es bietet vollen Zugriff, beliebige Projekte, neue Sessions vom Handy aus und ist herstellerunabhängig.

Die offizielle Claude-App mit Remote Control ist die richtige Wahl, wenn du nur gelegentlich einen Befehl an deinen Desktop-Claude senden willst und kein technisches Setup haben magst.

Beide Wege schließen sich nicht aus. Ich nutze die App für schnelle Statuschecks am Bahnsteig und das SSH-Setup, wenn echte Arbeit ansteht. Wer Solo-Freelancer oder Solo-Engineer ist und mobilen Zugriff zum festen Bestandteil seiner Arbeitsweise machen will, sollte beide Werkzeuge im Werkzeugkasten haben.

---

Nächste Schritte

Wenn das Setup bei dir steht, lohnt sich der Blick auf zwei weiterführende Themen:

Für die Einrichtung von Claude Code selbst und den dahinterliegenden Workflow lies Claude Code Tutorial: Von Null auf produktiv an einem Tag. Das Tutorial geht auf Projektkontext via CLAUDE.md, MCP-Server und produktive Session-Gewohnheiten ein.

Für die größere Frage, wie sich KI-gestützte Entwicklung als Arbeitsweise vom klassischen Coding unterscheidet, siehe Was ist Agentic Coding?.

Wer Hilfe beim Aufsetzen, der Integration in Shopify-Projekte oder generell beim Einbinden von Claude-Code-Workflows in seine Arbeit braucht, kann sich direkt mit mir verbinden.