How I Keep Claude’s Development Loops Alive While Moving Around (ZeroTier + tmux + Terminus + GitHub Mobile)

1. The Actual Constraint

Once I started working with several Claude sessions in parallel, I ran into a new kind of bottleneck that had nothing to do with code or architecture. It was physical. Each session was tied to a different worktree, running its own Xcode builds, test suites, and debugging loops. And all of them depended on me pressing enter on some trivial test-run command or folder search.

I found myself tied to the chair in a way that made no sense. I wasn’t trying to automate myself out of the process. I wasn’t trying to “set it and forget it.” I just didn’t want the entire cycle to idle whenever I stood up to grab water or stretch my legs. The whole point of using AI for development is to keep momentum going, but my setup made that impossible unless I stayed physically planted in front of the keyboard.

So I started looking for a way to step away from the desk without breaking the flow: a way to keep Claude’s build–test–debug loop alive while still being able to interact with it whenever it needed me. The solution ended up being surprisingly simple — and built entirely on free tools.

2. The Four Tools That Make This Possible (and Why They Matter)

Once I broke down the problem, it became obvious that no single tool could solve it. I didn’t need a “remote desktop,” or a giant infrastructure setup, or anything fancy. I just needed four small, free pieces that each solved one specific weakness of the workflow. Together, they make it possible to keep Claude’s build–test–debug loop running while still having full control when I’m away from the desk.

ZeroTier — Stable, Universal Access to the Laptop

The first challenge was connection. I needed a way to reach my laptop reliably, from anywhere, without depending on my home network setup or dealing with port forwarding rules.

ZeroTier solves this elegantly. It creates a private virtual network where both my laptop and my iPhone live on the same subnet, with predictable IP addresses. No VPN configuration, no NAT issues, no router gymnastics. It just works — the phone can SSH into the laptop as if they were side-by-side on the same Wi-Fi.

Why it matters:

• Laptop and phone share the same virtual network.

• Both get fixed internal IPs.

• Zero port forwarding or router configuration.

• I can SSH into my laptop from anywhere, instantly.

tmux — A Window Into Your Running Claude Sessions

Every Claude thread runs inside its own tmux session, mapped one-to-one with its worktree. When I connect from my phone I’m not starting a new shell; I’m reattaching to the live terminal where Claude is already working. Whatever was happening keeps happening. Whatever error was printed is still there. If Claude is waiting for a command, I can send it.

Why it matters:

• You can reattach directly into the Claude session that is already running.

• No need to restart anything — you just re-enter the same terminal context.

Terminus (iOS) — A Free, Touch-Friendly SSH Terminal

Terminus is a clean, touch-friendly terminal that handles SSH without drama. It reconnects reliably, works fine on both Wi-Fi and mobile data, and makes it easy to jump straight back into the tmux session where Claude is already running. I’m not using it to write code; I’m using it to keep the loop alive — sending a command, confirming a prompt, rerunning tests. For that, Terminus is perfect.

Why it matters:

• Free for everything this workflow needs.

• Simple SSH configuration using the ZeroTier IP.

• Reattaches to tmux sessions with a single command.

GitHub Mobile App — Reviewing Output Without Fighting a Terminal

The final gap was visibility. You can technically review diffs inside claude, but doing that on a phone is… let’s say not ideal. Scrolling breaks. Line wrapping breaks. Navigation is painful.

The GitHub mobile app handles this effortlessly. Whenever Claude generates a large refactor, changes multiple files, or restructures a module, I use the GitHub app to inspect the diff cleanly. It’s fast, readable, and built for a small screen.

Why it matters:

• Terminal diffing on mobile is impractical.

• GitHub Mobile provides clean diffs, comments, and PR statuses.

• Perfect for checking what Claude changed without losing context.

3. Setup Guide (Short and Practical)

This isn’t a full walkthrough — just the essential steps needed to recreate the same workflow. All the tools are free, lightweight, and take only a few minutes to configure. The entire point is to keep the setup simple so it doesn’t add friction to your day.

ZeroTier

Steps:

1. Create a ZeroTier account.

2. Create a new network.

3. Install ZeroTier on your Mac and join that network.

4. Install ZeroTier on your iPhone and join the same network.

5. Approve both devices from the ZeroTier dashboard.

6. Write down the internal IP assigned to your Mac — you’ll use that for the SSH connection.

Terminus (iOS)

Setup steps:

1. Add a new host using the ZeroTier IP of your laptop.

2. Save your SSH key or use password auth.

3. (Optional but useful) Create a quick action/button that runs: tmux attach -t

tmux

tmux is the anchor of the whole system. Claude runs inside these sessions, and you reconnect into them from anywhere.

Setup is simple:

• One iTerm pane, one tmux session, one claude session. The following command generates a tmux session:

  tmux new -s <session>

• I usually create sessions called one, two and three, so that it matches my worktree folders and I can keep track of everything easily.

• Inside the ssh terminal on Terminus, connect to the session using tmux attach -t <session>

GitHub Mobile

The easy part, no deep setup here. Just log in and pin your main repo.

Takeaway

If everything is working, you should now be able to:

• leave the desk,

• SSH into your laptop over ZeroTier,

• reattach to an active Claude session via tmux,

• and comfortably inspect changes via GitHub Mobile.

4. Closing Thoughts

This setup isn’t about automating myself out of the process or pretending that development can run on autopilot. It’s about something much simpler: removing the physical dependency on sitting in front of the machine just to keep Claude’s build–test–debug loop alive. The work is still mine. The decisions are still mine. Claude still needs guidance and oversight. But I no longer lose momentum every time I stand up to stretch or walk to lunch.

With a few small, free tools — ZeroTier for stable private networking, tmux for persistent terminal sessions, Terminus for mobile SSH access, and GitHub Mobile for readable diffs — the entire workflow becomes flexible instead of fragile. The machine keeps working. Claude keeps iterating. And when I reconnect, I’m stepping back into the exact same session, not restarting a stalled loop.

It’s a small change, but it has a big effect on the day: less waiting, fewer interruptions, and a smoother rhythm when working with AI-assisted development.

Recap:

• ZeroTier → reach your laptop securely from anywhere

• tmux → reattach to running Claude sessions without losing state

• Terminus → clean mobile access to your terminal

• GitHub Mobile → inspect diffs and outputs comfortably

• All free tools, all lightweight

• Together: a simple, reliable way to keep progress moving even when you take a break.

Issues I found so far

Your mobile carrier may block or interfere with UDP traffic.

A simple fix is to force your ZeroTier client on macOS to fall back to TCP.

You only need these two steps:

1. Create the ZeroTier config file

Create this file on macOS:

/Library/Application Support/ZeroTier/One/local.conf

Put this inside:

{
  "physical": {
    "allowTcpFallbackRelay": true
  }
}

2. Restart ZeroTier

Run this in Terminal:

sudo launchctl unload /Library/LaunchDaemons/com.zerotier.one.plist
sudo launchctl load /Library/LaunchDaemons/com.zerotier.one.plist

(or just sudo killall zerotier-one)

That’s it — ZeroTier now uses TCP fallback and works on your UDP blocking carriers.