Forem: Jaga

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.