DEV Community: Jaga

Reach your home Mac from anywhere with Tailscale (so Claude Code can come with you)

Jaga — Mon, 20 Apr 2026 19:55:37 +0000

If you've started running Claude Code or any other AI coding agent on a Mac at home, you've probably already had this thought: "I should be able to talk to that machine from my phone." Then you tried to actually do it, and you ran into router config, dynamic DNS, port forwarding, and somewhere around the third firewall rule you closed the tab and went back to coding at your desk like a normal person.

The good news is you don't have to do any of that anymore. Tailscale makes "reach my home Mac from anywhere" a ten-minute setup with no network knowledge required, and the free Personal plan covers everything an individual developer needs. This post is the version of that setup I wish I'd had when I started.

What Tailscale actually is (without the marketing)

Tailscale is a mesh VPN built on WireGuard. The shortest possible explanation: install the same app on each of your devices, sign in with the same account, and they can all talk to each other directly over an encrypted connection, no matter what network they're on.

Two things make this different from "regular" VPNs:

Same IP, anywhere. Each device gets a private IP in the 100.x.y.z range that never changes. Your home Mac's Tailscale IP at the cafe is the same as its Tailscale IP from your desk. You stop caring what network you're on.
Direct device-to-device traffic. Your iPad doesn't route data through Tailscale's servers. Tailscale just helps the two devices find each other and hand-shake; the actual traffic goes peer-to-peer over WireGuard. It's fast and the company can't see your data.

A useful mental model: Tailscale is the matchmaker, not the post office. It introduces your devices to each other and then steps out of the room.

Why WireGuard matters

The encryption layer is WireGuard, a relatively new VPN protocol that's "small, fast, and modern." Compared to OpenVPN or IPsec, WireGuard is a few thousand lines of code instead of a few hundred thousand, which means dramatically fewer places for bugs and exploits to hide. You don't have to think about it — Tailscale just uses it under the hood — but it's the reason the connection is both fast and trustworthy.

Pricing

Plan	Cost	Devices	Users
Personal	Free	Up to 100	Up to 3
Starter	$5/user/month	–	Unlimited
Premium	Custom	–	Unlimited

For the use case in this post — connecting your own devices to each other — Personal is plenty. I have been running on the free plan for over a year and have never bumped against a limit.

Step 1: Install Tailscale on the Mac

Go to tailscale.com/download and grab the Standalone variant for macOS, not the Mac App Store version. The Standalone variant has fewer sandbox restrictions, which matters for some advanced features later.

Open the downloaded file and drag Tailscale into Applications.
Launch it. A small Tailscale icon appears in your menu bar.
Click the icon → Log in.... A browser opens; sign in with Google, Apple, GitHub, or any other supported identity provider.
macOS will ask permission to add a VPN configuration. Allow it.

When it finishes, click the menu bar icon again. You should see your Mac's Tailscale IP — something like 100.64.0.1. Write that down, you'll use it in a minute. (You can always get it back later with tailscale ip -4 in a terminal.)

Step 2: Install Tailscale on the iPad (or iPhone)

Open the App Store on the iPad and search for "Tailscale."
Install it, open it, tap Get Started.
Sign in with the same identity provider you used on the Mac. This is the only step people get wrong. If you sign in with two different accounts, the devices end up in two different tailnets and can't see each other.
Allow the VPN configuration when iOS asks.

Once you're signed in, the Tailscale app will show a list of all your devices. You should see both your Mac and your iPad. If you do, the network half is done — they can now reach each other.

Step 3: Turn on Remote Login on the Mac

Tailscale gets the two devices on the same private network, but that's not enough to actually SSH into the Mac. macOS ships with an SSH server built in but disabled by default. Turn it on:

System Settings → General → Sharing
Toggle Remote Login on

That's it. Your Mac is now accepting SSH connections from devices that can reach it — which, thanks to Tailscale, includes your iPad from anywhere in the world.

While you're there, also check your Mac's username so you know what to type later. Easiest way:

whoami

Whatever it prints (e.g. alex) is your username.

Step 4: SSH from the iPad to the Mac

Open any iOS terminal app on the iPad. Many people start with Termius or Prompt 3, and there's also my own MT — Mosh Terminal which I built specifically for this kind of mobile-to-home-Mac workflow. Any of them work for the basic SSH step below.

Run:

ssh alex@100.64.0.1

(Substitute your username and your Mac's Tailscale IP.)

The first time, it will ask if you trust the host fingerprint. Type yes. Then enter your Mac's login password (not your Apple ID — your local Mac password). You should now see your Mac's shell prompt on the iPad.

Congratulations, you're now logged into your home Mac from a tablet that doesn't know what network it's on.

Bonus: ditch the IP address with MagicDNS

Memorizing 100.64.0.1 is annoying. Tailscale has a feature called MagicDNS that lets you use device names instead.

Go to the Tailscale Admin Console
Enable MagicDNS

After that:

ssh alex@mac-mini

works just as well as the IP version. The device name is whatever shows up in your Tailscale device list.

When it doesn't work

Symptom	What to check
`Connection timed out`	Is Tailscale on, on both devices? Open the Admin Console and confirm both are "Connected."
`Permission denied (password)`	You're typing your Apple ID password, not your local Mac login password. Use the Mac one.
`Connection refused`	Remote Login is off. Re-check System Settings → General → Sharing.
`Could not resolve hostname`	MagicDNS isn't enabled, or you mistyped the device name. Use the IP directly to confirm, then debug DNS.
Works at home, not at the cafe	Some restrictive captive-portal Wi-Fi blocks WireGuard's UDP ports. Tailscale automatically falls back to a relay (DERP), but if you see persistent issues, try tethering off your phone to confirm.

What this unlocks

Once SSH-from-anywhere works, the entire "mobile AI coding" workflow opens up:

Start a long Claude Code task at home in the morning
Detach the tmux session and walk out the door
Re-attach from the iPad on the train, watch the agent's progress, answer its questions
Get home, attach from the Mac again, pick up exactly where you left off

The first time it actually works it feels almost too easy. There's no port forwarding to undo, no router rule to maintain, no dynamic DNS account to renew. You just install one app on each device and they find each other.

If you want the next pieces of this workflow, the rest of the series covers them:

Keeping your remote sessions alive across disconnects → my tmux primer (link will go here once it's published)
Why mobile terminals are painful and what I did about it → MT — Mosh Terminal, the iOS terminal I built for exactly this use case → App Store

I'm a solo iOS developer. I write about gadgets and dev tools at jaga-farm.com. MT — Mosh Terminal is my first App Store release. Find me on X at @jaga_farm.

The 300-gram AI coding rig: iPad mini + Claude Code anywhere

Jaga — Mon, 13 Apr 2026 21:15:13 +0000

For the last two months, my daily Claude Code workstation has weighed about 300 grams.

Not the laptop. Not the desk. The whole thing — tablet, keyboard, the whole rig that I actually use to send prompts to Claude Code, watch the agent work, and ship code from a coffee shop. It's an iPad mini A17 Pro and a folding split keyboard, and I'm increasingly convinced this is the right shape of "AI coding workstation" for anyone who already runs an agent on a real machine somewhere.

I expected this to be a gimmick that I'd abandon after a week. It wasn't. So this post is the actual setup, the parts I use, and the one thing about iPad mini that I now consider a feature instead of a limitation.

What "AI coding from a tablet" actually means

Let me clear up the obvious confusion first: I am not writing Swift on an 8.3-inch screen. Nobody should do that.

What I'm doing is much narrower:

Claude Code runs on a Mac mini at home. That's where the codebase lives, that's where the agent has full filesystem and shell access, that's where the actual work happens.
The iPad mini is a remote control. I SSH into the home Mac, attach to a long-running tmux session, type prompts in plain English, and watch Claude Code do its thing.
My job is the prompt and the review. I read the agent's plan, I approve or redirect, I check the diff. The iPad mini is the screen and keyboard for that conversation.

When you frame it that way — typing intent and reading output — the screen size objection disappears. I'm not in a code editor. I'm in a terminal. Terminals scale down beautifully.

The exact rig

Here's everything I carry:

Item	Weight	What it does
iPad mini A17 Pro	~293 g	The screen and the brains for the prompt-and-review loop
Folding split keyboard (I use a 40-key split board, but any Bluetooth board with Ctrl/Esc works)	~200 g	Real keys, real Ctrl, real Esc, no soft keyboard pain
A small sleeve	negligible	So I can throw it in any bag

That's it. No hub, no laptop bag, no power brick. Battery life is a full work day even with continuous SSH.

The keyboard part matters more than people expect. Any iPad terminal experience without a real Ctrl key is going to make you miserable — every shell command needs Ctrl-C, Ctrl-D, Ctrl-R, and the soft keyboard's modifier handling is nowhere near good enough. A cheap split board changes the entire experience.

The software side

Four pieces:

Tailscale — free for personal use. Lets the iPad mini reach my home Mac mini securely from anywhere, with no router config or port forwarding. I cover the install in my Tailscale post (link will go here once that one is published).
An iOS terminal app — anything that does SSH and ideally Mosh. (More on this in a moment.)
tmux on the Mac side — so the Claude Code session keeps running even when my SSH connection drops. I have a four-command tmux primer if you've never used it.
Claude Code itself — installed on the Mac, started inside the tmux session.

The flow is:

Home in the morning  →  ssh into Mac, tmux new -As work, claude
                     →  ask Claude Code to do the long task
                     →  Ctrl+b d (detach), close laptop, leave the house

On the train        →  ssh into Mac from iPad mini, tmux attach -t work
                    →  see exactly what Claude Code is doing
                    →  answer its questions, redirect, approve

Cafe                →  same thing, different network — tmux + Mosh keeps it alive

Once this loop is set up, the iPad mini becomes a passive monitor for the agent. You're not even really "using" it most of the time. You give it a prompt, you go read a book, you come back when the notification fires.

The thing I didn't expect: the constraint is the feature

Here's the part of this setup that surprised me.

iPad mini is genuinely bad at multitasking. The 8.3-inch screen makes Stage Manager pointless. You can't really run a code editor and a terminal and a browser side-by-side. You do one thing at a time.

I assumed this would be the dealbreaker. It turned out to be the killer feature.

When my workstation is a MacBook with eight tabs open, I cannot stop context-switching. I check Slack, I check email, I look something up "real quick," I lose forty minutes. When my workstation is an iPad mini with literally no room for distraction, the loop is brutally simple: prompt the agent → put the device down → read a book → pick it up when something happens. I get more deep work done in two hours of iPad mini time than in four hours at my desk.

Single-tasking, when it's enforced by physics rather than willpower, is a productivity hack disguised as a hardware limitation.

What about the terminal app?

This is the part I struggled with for a long time, and the part that eventually made me build my own.

Most iOS terminals are fine for occasional SSH. They are not fine for the rig I just described. The pain points stack up:

Tap-tap-tap to switch tmux panes because the prefix key is hostile to touch
SSH dies the moment you switch from Wi-Fi to LTE on the train, and you lose your scrollback
No system-level notification when Claude Code is waiting on you, so you keep checking your phone

After about a year of duct-taping around all of this, I built MT — Mosh Terminal — a $14.99 one-time iOS terminal that has real Mosh (so the connection survives subway tunnels), one-tap tmux operations (no prefix-key juggling), and system push notifications wired into Claude Code Hooks (so the moment the agent needs me, my phone buzzes and a tap drops me back into the exact session). If the iPad mini rig sounds appealing but the terminal-app friction is what's stopping you, that's literally the reason MT exists. I'll write more about it in another post in this series; for now, just know it's there.

You don't have to use MT for any of this to work. Any terminal that can hold an SSH connection will get you started. The rig is the rig regardless.

Who this setup is actually for

Be honest with yourself before buying anything:

✅ You already use Claude Code (or Codex, or any agent CLI) on a Mac. This setup is a remote control for a workflow you already have. It does not make sense as a starting point.
✅ You like the "give it a task, walk away, come back" rhythm. If you need to be hands-on every keystroke, the iPad mini will frustrate you.
✅ You travel, commute, or hate being chained to a desk. Every hour I spend not at my main rig is an hour I'd otherwise lose.
❌ You want to write code by hand. Get a real laptop.
❌ You don't have a home Mac to SSH into. Tailscale + Claude Code on a remote box (a cloud VM, a Raspberry Pi, anything) works too, but you do need some always-on machine on the other end.

Wrap-up

The iPad mini AI coding rig is 300 grams of tablet, 200 grams of keyboard, four free or one-time-purchase pieces of software, and a workflow that turns "I need to step away from my Mac" from an interruption into a feature. After two months I have stopped reaching for my MacBook for anything that's just "talk to Claude Code for an hour."

If this resonates and you want the mobile-terminal half of the story, → MT — Mosh Terminal on the App Store.

I'm a solo iOS developer. I write about gadgets and dev tools at jaga-farm.com. MT — Mosh Terminal is my first App Store release. Find me on X at @jaga_farm.

Stop losing Claude Code sessions: a tmux primer for mobile devs

Jaga — Sun, 12 Apr 2026 00:34:07 +0000

You ask Claude Code to refactor a module. It says "this will take a few minutes." You close your laptop and head out for coffee. You come back, open the lid, and your SSH session is dead, your terminal is empty, and Claude Code never finished — because the moment your connection dropped, the agent that was running on your remote machine got killed along with it.

If you've felt that exact frustration, the fix has existed for over a decade and it's called tmux. This post is the shortest possible introduction I can write — four commands, one analogy, and a workflow that lets you walk away from your AI agent without losing its work.

What tmux actually does

tmux (terminal multiplexer) is a small program that runs on your server or remote Mac and keeps your terminal session alive even when you're not connected to it.

The TV analogy is the easiest one I know:

Plain SSH is live broadcast. If you leave the room, you miss it. If the cable goes out, the show is gone.
tmux is recording. The show keeps running on the box at home. When you come back, you reconnect and pick up exactly where you left off.

For Claude Code, this is the difference between "I asked it to do something big and lost an hour of work" and "I asked it to do something big and watched the result roll in from my phone three hours later." The agent doesn't care that you walked away. tmux is what makes that possible.

The three layers (skim this and move on)

You don't need to memorize this. Just know these words exist:

Layer	Mental model	What it is
Session	A desk	Your workspace. You can have a "work" session and a "personal" session running side by side.
Window	A browser tab	Tabs inside a session. Switch with one key.
Pane	A split view	Splits inside a window. Useful on big screens, painful on phones.

For mobile work, one session, one or two windows, no panes is all you need. Pane splits are nice on a 27-inch monitor and miserable on a 6-inch screen.

Install it (one minute)

tmux runs on the server side — the machine you're SSH'ing into. You don't install anything on your phone or iPad. On a Mac:

# 1. Install Homebrew if you don't have it
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 2. Install tmux
brew install tmux

# 3. Verify
tmux -V

If you see something like tmux 3.6a, you're done.

On Linux servers, replace step 2 with sudo apt install tmux or sudo dnf install tmux depending on your distro.

The four commands you actually need

I have been using tmux daily for years and I genuinely use one command 95% of the time. Here are all four anyway, in increasing order of "I actually need this."

1. Create a session

tmux new -s work

work is just a name. Pick anything. When tmux starts, you'll see a green status bar at the bottom of your terminal — that's how you know you're inside a tmux session.

2. Detach (leave the session running)

While inside tmux, press:

Ctrl+b   then release   then press d

The Ctrl+b is called the prefix key. You always press it, release it, then press a second key. d is for "detach."

You'll drop back to your normal shell prompt. The tmux session is still running in the background — your processes are still working, your scrollback is preserved, Claude Code is still doing its thing. You just stepped out of the room.

You can now safely close your laptop, kill your SSH connection, lose your Wi-Fi, whatever. The session lives on the server.

3. Re-attach (come back to it)

tmux attach -t work

Boom — you're back. Same screen, same scrollback, same running processes. If Claude Code finished while you were gone, you'll see its output waiting for you. If it's still running, you'll see it in real time.

4. The one command I actually use

tmux new -As work

The -A flag means "attach if a session named work already exists, otherwise create a new one." This is the only tmux command I type. It's idempotent: it always puts me into the work session, regardless of whether one was already there.

If you only memorize one thing from this post, memorize that.

A real-world workflow

Here's how I actually use this with Claude Code on a normal day:

Morning, at home, on my Mac:

ssh me@myserver
tmux new -As work
claude

I open Claude Code inside the tmux session and ask it to do something that'll take a while — refactor a service, write tests, audit a dependency. Then I close my laptop and leave for the train.

On the train, on my phone or iPad:

ssh me@myserver
tmux attach -t work

I see exactly the screen Claude Code was looking at when I left. If it's still working, I can watch the progress. If it's finished and waiting on input, I can answer right there. If I need to think about something, I Ctrl+b d to detach again and the session keeps running while I read a book.

Evening, back at the Mac:

tmux attach -t work

Same session, same context. I never lost a thing.

This pattern — start a long-running agent task on one device, monitor and approve from another — is the killer use case for AI coding agents on mobile. tmux is what makes it work.

A small gotcha when switching devices

If you attach from your phone while your Mac is also still attached to the same session, tmux will resize the display to the smaller screen. Annoying. The fix:

tmux attach -d -t work

The -d flag detaches whoever was previously attached, so only your current device sees the session. I use this constantly when bouncing between Mac and iPad.

Common keys (for after you're comfortable)

All tmux commands start with Ctrl+b, then a second key. Press them in sequence, not together.

What you want	Keys
Detach	`Ctrl+b` then `d`
List sessions	`Ctrl+b` then `s`
New window	`Ctrl+b` then `c`
Next window	`Ctrl+b` then `n`
List windows	`Ctrl+b` then `w`
Help	`Ctrl+b` then `?`

For a phone or small tablet, I'd skip pane splitting entirely and just use windows. Two windows — one for Claude Code, one for git status and file pokes — is enough for almost everything.

Where this falls apart on mobile (and what to do about it)

Honest take: tmux's prefix-key model is great on a real keyboard and frustrating on a touchscreen. Tapping Ctrl+b then n on a soft keyboard means hunting for the Ctrl key, then the b, then the n, every single time you want to switch windows. After about ten of those, you start questioning your life choices.

This is exactly the problem I ran into when I started doing serious AI agent work from my phone. I ended up building MT — Mosh Terminal, a $14.99 one-time iOS terminal whose entire bottom action bar is just one-tap tmux operations — split, switch, detach, the works — so the prefix-key gymnastics disappear on mobile. It also gets a system push notification the moment Claude Code needs you, so you don't have to keep checking. I'll write more about that in a later post; for now just know that the option exists if mobile tmux ever drives you up a wall.

You don't need any of that to make tmux work, though. The four commands above are the whole game.

Wrap-up

tmux is a "recording device" for your terminal. Once your sessions live on the server and not on your local connection, the question of "what happens if my laptop sleeps while Claude Code is working" stops being scary.

The cheat sheet you actually need:

Action	Command
Start (or rejoin)	`tmux new -As work`
Step out	`Ctrl+b` then `d`
Come back	`tmux attach -t work`
Steal session from another device	`tmux attach -d -t work`

That's it. Try it once tonight: open a tmux session on your dev box, run a long task inside it, close your laptop, and reconnect from your phone an hour later. The first time it works you'll wonder how you ever lived without it.

→ If you want the mobile side of this story, the app I built for it is MT — Mosh Terminal on the App Store.

I'm a solo iOS developer. I write about gadgets and dev tools at jaga-farm.com. MT — Mosh Terminal is my first App Store release. Find me on X at @jaga_farm.