DEV Community: Jaga

I couldn't talk to Claude Code from my phone, so I shipped my own terminal

Jaga — Wed, 15 Jul 2026 10:27:05 +0000

I haven't gone a day without talking to Claude Code.

That sounds dramatic until you check your own terminal history. Mine is a wall of claude commands going back months — sometimes shipping a feature, sometimes just rubber-ducking a bug on the train. At some point Claude Code stopped being a tool I opened and became something closer to a coworker I check in with. The kind of coworker who waits 20 minutes for you to approve a file edit while you're at lunch.

That waiting is the part nobody warned me about. When you live with an AI coding agent, the bottleneck isn't typing — it's being away from your Mac. Every time I stepped out for coffee, every train ride, every meeting that ran long, Claude Code was sitting there, blocked on a one-key approval, while I was holding the only computer that could unblock it: my phone.

So I started trying iOS terminals.

Every option failed me in a different way

I won't name names because the people building these are working hard, but here's what I hit, over and over:

Subscriptions for a fundamentally simple tool. A terminal is plumbing. I do not want a recurring charge for plumbing.
No real Mosh. SSH on a phone dies the second you switch from Wi-Fi to LTE. You re-connect, you lose your tmux pane state, you lose your scrollback, you swear quietly. Mosh fixes this — and almost no iOS app actually ships a real Mosh implementation.
tmux on mobile is a nightmare. Prefix keys (Ctrl+B, then a letter) are fine on a hardware keyboard. They are miserable on a touchscreen. Switching panes shouldn't take three taps and a finger gymnastic.
No notifications when an agent needs you. This is the killer. Claude Code is built to wait for you, but none of the terminals I tried surfaced "your agent needs input" anywhere I'd actually see it.

I kept thinking someone would fix this. After about a year of waiting, I decided that someone was me.

What I built (in six weeks of nights and weekends)

The app is MT — Mosh Terminal. The whole thing is organized around one idea: the moment Claude Code needs me, my phone should know.

A few decisions that fell out of that (the full technical deep-dive is in my Show DEV post, this is the short version):

Real Mosh, written from scratch. Not a wrapper. I wanted to control how aggressively the client retries on a flaky LTE handoff, because that's the difference between "session survived the subway" and "session died at the platform."
One-tap tmux. Fifteen of the operations I do constantly — split, swap, zoom, kill, swipe between sessions — are now single taps from a bottom action bar. No prefix keys, no muscle memory, no leaving the home row when I do have a keyboard.

System-level push notifications via Claude Code Hooks. You paste two hook entries into your ~/.claude/settings.json, and that's it. When Claude Code needs an approval, my phone buzzes. Tap the notification → MT instantly resumes the exact tmux session over Mosh. Host, user, session name — all matched automatically. Apple Watch notifications too, because sometimes my phone is in another room.
Keyboard-first on iPad. With a Magic Keyboard or a split ergo board, iPad becomes a real terminal machine. Tabs, splits, ⌘1–9 to switch panes, drag tabs to tile them. I can run an entire dev session without lifting a finger to the screen.

The thing I did not expect is how often I now reach for my iPad mini before I reach for my MacBook. A 300-gram tablet plus a folding keyboard is somehow a faster Claude Code workstation than a 1.5 kg laptop, because I can pull it out anywhere and it's already paired to my home Mac via Tailscale. I genuinely did not see this coming.

Why one-time, not a subscription

MT is $14.99, one time. No monthly fee, no Pro tier I'm hiding the good stuff behind, no "trial." You buy it, you own it, you keep it.

This is partly philosophy and partly a promise to myself: if I'm building plumbing, I'm not going to charge rent on it. If you want to support continued development there's an optional MT Pro tier later, but everything in this post — Mosh, tmux, push notifications, iPad keyboard support — ships in the base app.

If this resonates

If you've ever stared at your phone in a coffee shop knowing your AI agent is blocked on you, MT was built for that exact feeling. The frustration that made me build it is probably the same frustration that brought you to this article.

→ MT — Mosh Terminal on the App Store

I'd love to know what your "Claude Code is waiting for me" moment looks like — drop it in the comments, or find me on X at @jaga_farm. I read everything.

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.

Show DEV: I built MT — Mosh Terminal so I could run Claude Code from my phone

Jaga — Sun, 12 Jul 2026 09:12:41 +0000

I run Claude Code every day. I also spend a lot of time away from my Mac. Those two facts are in constant tension, and this is the post about how I tried to solve it.

After about a year of fighting with iOS terminal apps that all let me down in different ways — broken on flaky networks, hostile to tmux on a touchscreen, no way to know when my AI agent was waiting on me — I gave up and built my own. It's called MT — Mosh Terminal, it's $14.99 once and you own it forever, and this is the long-form Show DEV post about what's actually inside it.

I'll cover the four things I did from scratch (Mosh, tmux on touch, push notifications via Claude Code Hooks, GPU rendering), the honest tradeoffs (what MT does not do), how it stacks up against Termius / Blink / Prompt 3, and the pricing decision that's going to either delight you or annoy you.

What MT is, in one paragraph

MT — Mosh Terminal is a SSH and Mosh terminal client for iPhone and iPad, built specifically for developers who live with AI coding agents. It connects to your own servers — your home Mac, a cloud VM, a Raspberry Pi, anything you SSH into today — and gives you a terminal experience that's actually usable on a phone. The headline features are a from-scratch Mosh implementation in Rust, one-tap tmux operations that don't require touching the prefix key, system-level push notifications via Claude Code's Hooks API, and a Metal-rendered terminal engine based on libghostty. It costs $14.99 once, no subscription.

Specs

Item	Spec
Name	MT — Mosh Terminal
Devices	iPhone, iPad, iPad mini
Price	$14.99 one-time (no subscription)
Protocols	SSH, Mosh (custom Rust implementation)
Terminal engine	libghostty (Metal GPU rendering)
CJK input	Full Japanese / Chinese / Korean IME with inline composition
Concurrent tabs	Unlimited (limited by device memory)
tmux integration	15+ one-tap actions, multi-session
External keyboard	Magic Keyboard, JIS, Bluetooth, ⌘ shortcuts
Themes	8 built-in (Tokyo Night, Dracula, Catppuccin, Gruvbox, Solarized, etc.) + custom
Scrollback	Up to 100,000 lines
Auth	Password, public key (RSA, Ed25519), SSH agent
OS	iOS 18+

The Mosh implementation

The thing I want to talk about first is also the one that took the longest to build. Let me back up.

Mosh (Mobile Shell) is the answer to "SSH dies the moment you switch from Wi-Fi to LTE." A normal SSH session is a phone call: when the line drops, the call ends, and you redial. Mosh is closer to a series of letters: even if some of them get lost in transit, the next one tells you the latest state of the world. It's a UDP-based, state-synchronization protocol designed for terminals on flaky mobile networks. If you've ever had a terminal session survive a subway tunnel or a Wi-Fi-to-cellular handoff without missing a beat, that was Mosh.

Almost every "iOS terminal with Mosh support" is wrapping the existing mosh-client binary. MT doesn't. I wrote the protocol from scratch in Rust. It implements the State Synchronization Protocol (SSP) from the Mosh paper, stays compatible with the standard mosh-server, and uses AES-128-OCB3 for encryption.

Why bother? Because the feel of Mosh on mobile — how aggressively the client retries, how quickly it gives up and reconnects, how it adapts scroll speed to the current round-trip time, what it does when the network is "almost back" — is invisible to most users and totally unfixable when you're a thin wrapper around an opaque binary. I wanted control over every one of those decisions, because the difference between "session survived the subway" and "session died at the platform" is exactly there.

I tested it on the actual Tokyo subway, in cafés with garbage Wi-Fi, on Wi-Fi-to-LTE handoffs, in elevators, in basements. SSH dies. Mosh hangs on. It's not magic — if you have zero signal for long enough you do eventually lose it — but the recovery is dramatically better than anything else I've used on iOS.

One-tap tmux

If you've ever used tmux on a touchscreen, you already know the problem.

tmux is built around a "prefix key" model: press Ctrl+B, release, then press another key for the actual command. On a hardware keyboard this is fine. On a soft keyboard it's misery. Hunting for Ctrl, then B, then n, every time you want to switch windows is the kind of friction that makes you stop using mobile terminals altogether.

MT defines 15 tmux operations as one-tap actions in a bottom action bar: detach, new window, vertical split, horizontal split, switch pane, zoom, copy mode, list sessions, kill window, and so on. No prefix key juggling. The action bar is reorderable and you can hide actions you don't use. (New to tmux? I wrote a tmux primer for mobile devs that covers the basics first.)

Two details that fell out of building this:

No accidental tmux fires while typing CJK. If you've used a Japanese, Chinese, or Korean IME inside any other iOS terminal, you've hit the bug where pressing keys mid-composition fires off random tmux commands. MT tracks IME composition state and holds tmux input until composition is committed.
Server tmux config is auto-imported. If your ~/.tmux.conf defines a custom prefix or key bindings, MT reads them on connect and adapts the action bar so the labels match what you actually have on the server. You can opt out in settings.

You can also run multiple tmux sessions side by side with horizontal swipe to switch. On iPhone where screen real estate is tight, this is the workflow I use most: one session per task, swipe to switch, no memorization of pane layouts.

Push notifications via Claude Code Hooks

This is the feature MT was named after, in spirit. The whole reason I built it.

The pain: I'd ask Claude Code to do something big, walk away, come back twenty minutes later to find the agent had been waiting on a one-key approval the whole time. That's twenty minutes of nothing happening because I had no way to know.

The fix: system-level push notifications wired into Claude Code's Hooks API. You paste two hook entries into your ~/.claude/settings.json, you're done. When Claude Code (or Codex) needs input — task completion, permission request, anything — your iPhone buzzes. Tap the notification → MT auto-resumes the exact tmux session over Mosh. Host, user, and session name are matched automatically. Apple Watch is supported too, because half the time my phone is in another room.

There's no proprietary daemon and no vendor lock-in. The push relay is self-hostable if you don't want to use the default one. The whole hook setup is two YAML entries you can read and audit.

This is the closest thing to "Claude Code in your pocket" that I know how to build, and it's the feature I use most.

iPad: keyboard-first

iPad with an external keyboard is, unironically, my favorite Claude Code workstation right now. I have a MacBook. I still reach for the iPad first when the work is "talk to the agent."

What MT does on iPad:

Stage Manager support — multi-window, resize, tile.
External keyboard, mouse, trackpad — full ⌘ shortcuts.
- ⌘1–⌘9: switch tab
- ⌘N: new connection
- ⌘W: close
- ⌘D: split pane
- ⌘+/⌘-: font size
- ⌘K: clear terminal
Hold ⌘ to surface a shortcut overlay (the macOS convention; nice that iPadOS exposes it).
Binary-tree pane splits with no hard limit — split as many times as you want, zoom in on one pane, drag tabs between windows.
JIS keyboard auto-detection with ¥→\ conversion for the Japanese-keyboard crowd. (If you're not on a JIS layout this doesn't affect you.)

The result, with a Magic Keyboard or a split ergo board, is a terminal experience that genuinely doesn't feel like a compromise. I've done full debug sessions on a 13" iPad Pro and forgotten I wasn't on a Mac. My daily setup is actually the iPad mini — I wrote about the 300-gram AI coding rig separately.

iPhone: the L1 soft key bar

"iPhone for terminal work? The screen is too small."

I thought so too. Then I built it and discovered it's totally usable, with two tricks.

The L1 soft key bar. Always-on at the bottom of the screen: ESC, TAB, sticky Ctrl, arrow keys, F1–F12, Page Up/Down. The Ctrl key is sticky — tap it, then the next key — so one-handed operation is genuinely possible. This is the feature that turns "I can technically run a terminal on iPhone" into "I can actually do work on iPhone."

Horizontal swipe between sessions. I commute with five tmux sessions running, one per Claude Code task, and switching between them is one swipe. The combination of swipe-to-switch and the L1 bar means you can run a real multi-agent workflow on a 6-inch screen, which I would not have believed before I built it.

libghostty + Metal

The terminal engine is libghostty, the library form of the popular desktop terminal Ghostty. Metal GPU rendering, 60 fps everywhere, 120 fps on ProMotion iPads, smooth scroll, no tearing.

Getting libghostty (which was designed for macOS) to run cleanly on iOS / iPadOS was not a one-line port. There's a non-trivial amount of glue code in MT for the iOS-specific bits — view lifecycle, background-to-foreground redraws, touch and pointer event routing — that I won't get into here. The user-visible result is that I can have a dozen tabs open and the app stays smooth.

Themes ship with the usual suspects (Tokyo Night, Dracula, Catppuccin Mocha, Gruvbox Dark, One Dark, Solarized Dark/Light, default). Fonts include Menlo, Courier New, JetBrains Mono, and you can import your own .ttf / .otf files. Pinch-to-zoom on the terminal text is a real-time font-size change, which is very satisfying after years of "Settings → Display → Font Size → Apply → Restart."

Other things in the box

iCloud Sync — Connection profiles, tmux settings, and terminal settings sync across devices. Per-category toggles. Passwords and SSH keys are gated behind a separate iCloud Keychain toggle and are E2E encrypted. All sync is off by default, because that's the safe default.
Security — SSH keys live in iOS Keychain protected by Secure Enclave. Face ID / Touch ID gating for keys. Host key verification (TOFU) with fingerprint display. No analytics, no tracking, no ads, no third-party SDKs of any kind.
Localization — English, Japanese, Korean, Simplified Chinese, Traditional Chinese. Full UI translations for each, including the tmux action bar labels.

Honest tradeoffs

I would lose your trust if I didn't write this section.

MT does not do:

SFTP file transfer. If you need to move files in and out of remote machines as a primary use case, MT isn't your tool yet. Termius and Prompt 3 are better at this.
Port forwarding. Same story. MT is laser-focused on the terminal experience, not the SSH-as-network-tool experience.
Always-on cloud sessions. MT is a client. It connects to servers you set up. It is not a VPN, not a proxy, not a tunnel — those are explicit non-goals because they're a different category of app and Apple reviews them as such (more on that in a separate post).
Push notifications might be Pro-only later. Maintaining the push relay infrastructure costs money, and it's the one thing that doesn't fit cleanly into a one-time-purchase model. As of v1.2.1 they're free. If they ever move to MT Pro, existing users at least get a heads-up.
Mosh requires mosh-server on the remote machine. This is a Mosh-protocol limitation, not an MT one. SSH connections need no server-side install; Mosh does. If mosh-server isn't installed or UDP is blocked, MT auto-falls-back to SSH.

If those tradeoffs are dealbreakers, the table below should help you pick something else.

How MT compares to Termius / Blink Shell / Prompt 3

	MT	Termius	Blink Shell	Prompt 3
Price	$14.99 one-time	$10/month and up	$19.99/year	$20/year or $100 one-time
Mosh	✅ Custom Rust impl	✅	✅	✅
tmux integration	15 one-tap actions	Limited	Limited	Good
Pane splits	Unlimited	Yes	Yes	Yes
GPU rendering	✅ Metal	❌	❌	Partial
Push notifications	✅ via Claude Code Hooks	❌	❌	❌
SFTP	❌	✅	✅	✅
Port forwarding	❌	✅	✅	✅

I'm not going to claim MT is "better than" any of those apps in a vacuum — they all have years of head start and feature surface I don't match. What MT has that none of them have is the specific intersection I built it for: from-scratch Mosh + one-time pricing + one-tap mobile tmux + Claude Code Hooks notifications. If that intersection is what you need, MT is currently the only option. If you need a Swiss-army-knife SSH tool, one of the others is probably a better fit.

Why one-time pricing

Quick personal note.

I do not enjoy paying subscriptions for tools that are fundamentally simple infrastructure. A terminal client is plumbing. Plumbing should not have a monthly fee. So I shipped MT as a one-time $14.99 purchase and gritted my teeth about everything that decision makes harder (notification servers, future updates, my own runway).

$14.99 is more than a single month of Termius. It is dramatically less than a year. You break even at month two and own it forever. That's the deal I wanted as a customer, so that's the deal I built.

There will eventually be an MT Pro tier for things that genuinely cost ongoing money to operate. Everything in this post — Mosh, tmux, Claude Code notifications, the iPad/iPhone experience — is in the base app. I'm not playing the "feature gating" game.

Who this app is for

You run Claude Code, Codex, or another AI coding agent on a remote machine and you want to be able to talk to it from your phone or iPad without losing your mind. (No remote machine yet? Tailscale turns your home Mac into one in about ten minutes.)
You commute, travel, or work from places that aren't your main desk.
You don't want another monthly subscription for the small set of dev tools you use every day.
You use tmux and want it to not be hostile on touch.
You care about your terminal feeling fast at any tab count.

If that's you, MT — Mosh Terminal is on the App Store now for $14.99.

If it's not you, no hard feelings — Termius and Prompt 3 are excellent for the use cases MT doesn't cover, and I've used both.

What's next

I'm shipping MT updates monthly and watching what users actually ask for. The current short list:

Better SFTP-style file ops (I know, I know — see "Honest tradeoffs" above; a minimal version is coming)
More hook integrations beyond Claude Code (Codex CLI is already in, more agent CLIs being added)
Per-host theme overrides so prod and dev look different
Android version — not soon, but on the long-term roadmap

If you try MT, the thing that helps me most right now is honest feedback. I read every review, every X reply, and every email. Tell me what's missing and I'll prioritize.

→ MT — Mosh Terminal on the App Store — $14.99 one-time, no subscription. Requires iOS 18 or later.

*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. If you want the personal-essay version of why I built this, I wrote one — link will go here once that post is up.

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.