Claude Code Mobile Workflows: Code From Anywhere

"Can I run Claude Code from my phone?" is the wrong question, because the answer is a boring yes. The right question is which of the four distinct mobile workflows fits the situation you are actually in, because they have different capabilities, different setup costs, and different failure modes, and picking the wrong one is the fastest way to conclude that mobile coding does not work.

I run a production Laravel site and client infrastructure that I administer from wherever I happen to be, sometimes from a phone over SSH to a server on a non-standard port. Mobile access is not a novelty in my week; it is how real incidents have been diagnosed. This post is the map I wish I had at the start: all four workflows, what each one can and cannot reach, and the two I would actually recommend to most developers.

The four workflows at a glance

The first two are built into Claude Code. The last two are you owning your own plumbing. Most people need exactly two of the four.

Workflow 1: Remote Control, the two-minute default

Remote Control turns your phone into a live window on a session already running on your desktop. Type /rc in a running session (or start one with claude remote-control), scan the QR code, and the full conversation, file edits included, is on your phone. The computation stays on your machine, so your MCP servers, local databases, and project config all keep working.

I covered the full Remote Control setup, security model, and failure modes in a dedicated post, so here I will just place it on the map: this is the reactive workflow. You are at your desk, life pulls you away, and you take the session with you. Its hard limitation is that the session must already exist and the terminal must stay alive. If you are out of the house with no session running, Remote Control has nothing to offer you, which is precisely the gap workflows 3 and 4 fill.

Workflow 2: Claude Code on the web, the cloud shortcut

Claude Code on the web runs entirely in Anthropic's cloud. From the Claude app or a mobile browser, you point it at a GitHub repository; it clones the repo into a sandbox, does the work, and hands you a pull request. No desktop involved anywhere.

For self-contained tasks this is unbeatable in speed-to-fix. A documentation bug, a small feature in a repo with good CI, a scaffold for a new idea: describe it from wherever you are, review the diff on your phone, merge. The PR-shaped output is the right shape for phone review, because you are reading a diff, not driving a terminal.

What you give up is everything local. No MCP servers, no custom skills, no local databases, no files outside the repo. That rules it out for most of my Laravel work, where the app depends on services the sandbox cannot see.

One piece of friction worth removing in advance: repos must be authorized through GitHub before the cloud can touch them, and doing OAuth flows on a phone browser during an incident is misery. Pre-authorize your active repos from a desktop on a calm afternoon. Your future self, staring at a production alert in a parking lot, will be grateful.

Workflow 3: server mode over SSH, starting sessions remotely

Here is the gap the first two workflows leave: Remote Control needs a pre-existing session, and the cloud cannot reach your local environment. The bridge is starting a session on your desktop from your phone, and the honest way to do that is SSH plus Claude Code's server mode.

SSH into your machine from a phone SSH client, then:

tmux new -s claude
cd ~/projects/your-project
claude remote-control

claude remote-control runs as a waiting server: the process sits in your terminal, displays a session URL, and accepts connections from your authenticated devices. You then close the SSH client and drive the session comfortably from the Claude app, which has the mobile-grade keyboard handling and code rendering that raw terminals on phones lack. The SSH client is the ignition; the Claude app is the steering wheel.

This gives you a fresh session with your full local environment, MCP servers and all, started from a beach or a waiting room. The dependency it does not remove: your desktop must be on and reachable, which is exactly what the fourth workflow makes reliable.

Workflow 4: the power stack, Tailscale + SSH + tmux

This is the setup that removes every remaining constraint, and a version of it has been part of my life for years for a reason that predates Claude entirely: I administer production servers over SSH from wherever I am. When my site's cron scheduler silently died one June, the diagnosis did not happen at a desk. It happened in an SSH session, watching the modified time on a sitemap file that should have been regenerating every five minutes and was not. Mobile ops is not a hypothetical for me, and the same plumbing that makes server administration possible from a phone makes Claude Code fully portable.

Three pieces:

Tailscale puts your devices on a private encrypted WireGuard mesh. Your phone can reach your desktop's stable private IP from any network, with no port forwarding and nothing exposed to the public internet. The free personal tier is more than a solo developer needs.

An SSH client on the phone. Termius and Blink are the usual picks on iOS; anything with SSH key auth and saved connection profiles works. Set up key-based auth, because typing passwords on a phone during an incident is how mistakes happen.

tmux is what makes the stack survive reality. Terminal sessions on a phone die constantly: tower handoffs, app switches, the OS reclaiming memory. tmux keeps the session alive on the desktop regardless. Reconnect after an hour or a flight, run tmux attach -t claude, and everything is exactly where it was, including whatever your agent finished while you were gone.

# desktop, one time
brew install tailscale tmux
tailscale up
sudo systemsetup -setremotelogin on   # macOS SSH

# phone, in your SSH client, connect to the Tailscale IP, then:
tmux new -s claude
cd ~/projects/your-project
claude remote-control

Do not skip tmux because your connection "seems stable." Mine seemed stable too, until a session with forty minutes of context died in a tunnel. The lesson cost ten minutes once; the config costs five lines forever. tmux is also first on my list of CLI tools worth building your Claude workflow around, for exactly this class of reason.

The mental shift that makes phone sessions productive

The mistake everyone makes in week one, me included: treating mobile coding as desktop coding on a smaller screen. Reading full diffs, typing detailed multi-constraint instructions, fighting the keyboard. It is miserable, and it is also the wrong division of labor.

From a phone, you direct; you do not implement. Desk instructions sound like "refactor the auth middleware to use JWT with RS256 and add a key rotation endpoint." Phone instructions sound like "auth needs to move to JWT; you know the codebase, do it, and I'll review the PR at my desk." The agent has the project context to fill in details, and the detailed review happens later on a real screen. Building the trust to delegate at that level takes a few weeks of verifying that the agent's autonomous choices match your standards, and long-running delegated work is its own discipline, one I covered in the background agents post.

Once that shift lands, phone sessions stop being a compromised version of desk sessions and become something desk sessions are not: a way to act on ideas at the moment they occur, instead of hoping you remember them later.

Which setup should you actually build?

You mostly work at one desk and occasionally step away: Remote Control alone. Enable it for all sessions in /config, learn /rc, done. Adding more infrastructure than this creates maintenance with no payoff.

You want to ship small fixes from anywhere: add Claude Code on the web and pre-authorize your repos. These two cover most developers, most of the time. If deploys are the only thing you need from a phone, that is solvable without any agent at all.

Your work depends on a local environment and you are away from it regularly: build the power stack. Thirty minutes once, and the question "can I reach my machine" is permanently answered.

You are deciding between Claude Code and Claude Cowork for the mobile half: they are different products with overlapping reach, and the Cowork mobile and cloud writeup covers that fork.

I run Remote Control daily, the web sandbox for quick public-repo work, and the SSH stack underneath everything as the load-bearing layer. They complement rather than compete, and the whole arrangement costs me nothing on the days I never leave the desk, which is the mark of good insurance.

Most mobile setups I see break at the boring layer: no persistent session, password SSH, a laptop that sleeps at the wrong moment. Remote-ready development environments — the deploy path, the server-side plumbing, the session persistence underneath — are something I build properly for clients, once, rather than reassembled from tutorials every time it fails.