Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mint.skeptrune.com/llms.txt

Use this file to discover all available pages before exploring further.

There’s a mini gold rush to put Claude Code on your phone. Some startups are building custom apps, others are creating managed cloud environments. They’re solving real problems, but you’re trading raw Unix power for convenience. If you have a desktop and 20 minutes, you can get full kernel access with SSH, Termux, and Tailscale. This approach was proven in practice: shipping a feature to a live blog from the passenger seat of a car driving from San Francisco to Apple Hill, CA — SSH’d into an office desktop, prompted Claude to make changes, tested on the phone’s browser, and pushed to production in 10 minutes. This guide walks through SSH-based mobile development with Claude Code. If you have a desktop that stays on (or a cheap VPS), you can get full terminal access from your phone with session persistence, port forwarding, and the ability to test your code on your actual mobile browser. The initial setup takes about 20 minutes and just works once configured.

​
The architecture

The setup uses five standard Unix tools that work together without custom integration:
ToolRole
DesktopRuns Claude Code and your development environment
TailscaleCreates a private encrypted network between your devices
TermuxGives you a real terminal on Android
SSHHandles the connection between phone and desktop
tmuxKeeps your sessions alive when you disconnect

​
Setup

1

Set up your desktop

You need a computer that stays on. This could be a home desktop, an office desktop, a cloud VM, or a home server. It doesn’t need to be powerful — Claude Code just makes API calls, the actual compute happens at Anthropic.Install Claude Code globally using npm:
npm install -g @anthropic-ai/claude-code
Install tmux for session persistence. When you disconnect from SSH (phone locks, network drops, whatever), tmux keeps your Claude Code session running in the background:
sudo apt install tmux
With Claude Code and tmux installed, your desktop is ready to host development sessions.
2

Install Tailscale everywhere

Tailscale creates a private network between all your devices. Your phone gets a stable IP address that can reach your desktop, even when you’re on different networks.On your desktop, run the Tailscale installer and bring up the connection:
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up
The tailscale up command will prompt you to authenticate in your browser. Install Tailscale on your phone from the Play Store and sign in with the same account. Your devices are now on the same private network.Grab your desktop’s Tailscale IP address — you’ll need it to connect:
tailscale ip -4
You’ll get something like 100.64.0.5. That’s your desktop’s address on the Tailscale network. It’s stable, private, and works from anywhere.
3

Install Termux on your phone

Termux is a terminal emulator for Android that gives you a real Linux environment — not a toy terminal. A real one with bash, ssh, and full package management.
Install Termux from F-Droid, not the Play Store. The Play Store version is outdated and broken. Get it from https://f-droid.org/en/packages/com.termux/.
Once installed, update the package repositories and install the SSH client:
pkg update
pkg install openssh
4

SSH into your desktop

Open Termux and SSH to your desktop using the Tailscale IP you grabbed earlier. Replace 100.64.0.5 with your actual IP and your-username with your desktop username:
ssh your-username@100.64.0.5
The first time you connect, SSH will ask you to verify the host fingerprint. Type yes, then enter your password.You’re now running a shell on your desktop, from your phone, over a secure encrypted connection that works anywhere you have internet.
5

Use tmux for session persistence

From your SSH session, start a new tmux session with a name you’ll remember. Name it after the project you’re working on:
tmux new -s code
Inside the tmux session, launch Claude Code:
claude
You’re now coding from your phone using Claude Code running on your desktop.When you need to disconnect, don’t exit Claude Code and don’t exit tmux. Just close Termux or let your phone lock. The tmux session stays running on your desktop.When you want to code again, SSH back in and reattach:
ssh your-username@100.64.0.5
tmux attach -t code
Your conversation with Claude is still there, your file context is still loaded, and you can continue immediately.

​
Why this works better than custom apps

Every startup trying to solve “Claude Code on mobile” is building abstractions on top of these primitives. They’re not giving you anything you can’t already do with SSH and Termux. They’re just wrapping it in a prettier UI and charging for hosting. When you do it yourself, you get several advantages: Port forwarding just works. With Tailscale, your desktop’s ports are directly accessible from your phone. No configuration, no exposing services to the public internet, no proxies adding latency. Full CLI access. Want to run your dev server with --host so you can test on your phone’s browser? Just add the flag. Need to adjust firewall rules, modify server configs, or install system packages? You have root access. Native mobile coding apps can’t offer this level of control. Session persistence that actually works. tmux was built for this. Your session survives network disconnections, phone reboots, and SSH reconnects. You never lose your place. Your own hardware. Your desktop has your SSH keys, your git credentials, your environment exactly how you configured it. You’re not coding in a disposable cloud container.

​
The mobile experience

Coding on a phone isn’t as good as coding on a desktop. The screen is small, the keyboard is mediocre, and you can’t see multiple files at once. But Claude Code is different from traditional coding. You’re not typing out functions character by character. You’re describing what you want, reviewing Claude’s changes, and approving or rejecting them. That workflow translates to mobile well. You’re reading more than you’re typing, and phones are great for reading. The Apple Hill example isn’t cherry-picked. Real features ship from a phone. Production bugs get fixed while getting coffee. Pull requests get reviewed from the back of an Uber. It’s not a primary development environment, but it’s shockingly capable when needed.

​
Practical tips

Once the basic setup is running, these tweaks make the mobile coding experience dramatically better.

​
Test your changes on your phone’s browser

This is the killer feature. You’re not just editing code remotely — you can test it on your phone while the dev server runs on your desktop. Start your dev server with the --host flag, which makes it accessible on your Tailscale network instead of just localhost: 
yarn dev --host
This binds the dev server to 0.0.0.0 instead of 127.0.0.1.
Then navigate to http://100.64.0.5:4321 on your phone’s browser (replace with your Tailscale IP and port). You’re now viewing your local dev server in your phone’s browser, testing on the actual target device with the actual screen size and layout.

​
Use SSH keys

Don’t type your password every time you SSH. Generate an SSH key on your phone and add it to your desktop’s authorized keys: 
ssh-keygen -t ed25519
ssh-copy-id your-username@100.64.0.5

​
Create an SSH config

Make connecting faster by adding an alias in Termux’s SSH config at ~/.ssh/config: 
Host desktop
    HostName 100.64.0.5
    User your-username
Now you can type ssh desktop instead of the full IP and username every time.

​
Use a better keyboard

Termux works with external Bluetooth keyboards. When actually trying to get work done on a phone, a small keyboard makes a massive difference. The phone screen is fine for reading; the keyboard makes typing bearable.

​
Set up tmux keybindings

tmux’s default keybindings are terrible on mobile. On your desktop, create or edit ~/.tmux.conf: 
# Use Ctrl-A instead of Ctrl-B (easier to type on phone)
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# Split panes with | and -
bind | split-window -h
bind - split-window -v

​
Run multiple sessions

You can have multiple tmux sessions for different projects: 
tmux new -s backend
tmux new -s frontend
tmux new -s experiments
List running sessions with tmux ls, then attach to whichever one you want: 
tmux attach -t frontend

​
Security considerations

You’re SSH’ing into your desktop over the internet. Do it right with a few precautions.
Never expose SSH directly to the public internet. Always use Tailscale to create a private network between your devices. Your SSH traffic stays encrypted and never touches the public internet directly.
Disable password authentication. Keys are longer, stronger, and can’t be brute-forced. Edit /etc/ssh/sshd_config on your desktop: 
PasswordAuthentication no
PubkeyAuthentication yes
Restart sshd after saving. Keep your phone secure. Your phone now has SSH access to your development machine. Use a strong PIN or biometric lock, enable disk encryption, and consider using a password manager for your SSH key passphrase. Monitor SSH access. Check who’s connected with who or w. Check SSH logs with: 
sudo tail -f /var/log/auth.log
If you see connections you don’t recognize, revoke SSH keys and investigate.

​
When this doesn’t work

No persistent desktop. If you don’t have a computer that stays on, rent a $5/month VPS from DigitalOcean or Hetzner, install Tailscale and Claude Code, and SSH into it the same way. iOS instead of Android. Termux isn’t available on iOS. Use a different SSH client like Blink or Prompt instead. The rest of the setup is identical. Unstable internet. Mosh (mobile shell) is designed for high-latency or unreliable connections. Install it on both your phone and desktop, then use mosh desktop instead of ssh desktop. It handles disconnections gracefully and keeps your terminal responsive even on bad networks.

​
The bottom line

Mobile development with Claude Code doesn’t require new infrastructure or custom applications. The components you need are SSH, Tailscale, Termux, and a desktop that stays on — standard Unix tools that have been solving remote access problems for decades. SSH has been the standard for secure remote access since 1995. Tmux has provided session management since 2007. Tailscale is built on WireGuard, which has undergone extensive security audits. These tools are mature, well-documented, and widely deployed in production environments. If you have a desktop or VPS and 20 minutes for setup, you can have this working today.