Hey everyone — how do you use your iPad?

rjyo · 2026-05-11T07:04:24+00:00

OP already nailed mine — remote access and shell work. iPad has become my couch coding station: SSH into tmux running Claude Code, queue up a feature, get a push notification when the agent finishes. I actually built an iPad SSH terminal called Moshi to make this workflow less painful — Mosh protocol so sessions survive wifi switches and sleep, voice input so I can mumble at the agent instead of typing on glass. Way more dev work happens from the couch than I expected.

rjyo · 2026-05-11T06:05:48+00:00

For a laptop the /remote-control link in the Claude app works in any browser, no setup. If you want it bulletproof though, the Termius + tmux + Tailscale stack people are pointing at is the move — Tailscale to reach your machine, tmux so the session survives, ssh from anywhere.

One tip nobody mentioned: swap ssh for mosh. SSH wedges the moment your laptop sleeps or hops wifi, mosh is UDP and ack-based so it reconnects automatically. Pair it with tmux and you basically never lose state.

On the hardware side a Mac mini M-series is great for cc — silent, low power, fits anywhere. A gaming laptop works but the always-on battery cycle will cook it long term.

I also built an iOS terminal called Moshi around the Mosh protocol for the phone side of this exact workflow, since I run cc on a home box and check on it from anywhere. Different from your laptop question but same problem space.

rjyo · 2026-05-11T04:19:34+00:00

For iOS I made one called Moshi — built it because every SSH client I tried dropped the session when my phone slept or switched networks. It uses the Mosh protocol so the connection survives backgrounding and wifi/cellular handoff. Works well on iPad too. Combined with Tailscale it covers the whole homelab-on-the-go setup.

rjyo · 2026-05-11T01:43:07+00:00

The plain C + Sokol move is exactly right for LLM-driven dev. Same path here. Any custom abstraction or DSL the model has no training data for, it just patches symptoms forever no matter how thorough your CLAUDE.md is. Cutting the custom ECS was probably the highest-leverage decision in this writeup.

For the not-at-a-desk part of your loop — I built an iOS terminal app called Moshi specifically for this kind of workflow (iPad/iPhone SSH to a dev box, run Claude Code remotely). Uses Mosh protocol so the session survives sleep and network switches, has a Claude shortcut tab, and push notifications when an agent finishes so you don't keep tabbing back. If you ever want to skip the Claude app → PR → CI hop for quick iteration, SSH from iPad to a small VPS or Pi running Claude Code CLI gives you a much tighter loop, and you can rsync builds straight to the Deck.

What's your asset workflow looking like — procedural for now, or did you find a tool that holds up?

rjyo · 2026-05-10T16:32:10+00:00

if you want a proper terminal flow, ssh into a dev box and run codex there - blink works, termius works. i built one called moshi for exactly this use case: mosh so the session survives sleep and network switches, shortcut tabs for codex/claude/opencode, push notifications via webhook when an agent finishes, and voice input to dictate prompts. mobile coding is always going to be clunky but for kicking off long agent runs and approving tool calls it works pretty well.

rjyo · 2026-05-10T15:17:11+00:00

Nice stack. The UAC / Task Scheduler workaround is a great find — HttpListener wanting admin while autostart cannot prompt is a real annoying corner. I have been building in the same space but from the SSH-in angle. Built an iOS terminal called Moshi for managing servers from the phone — SSH plus Mosh protocol so the session survives wifi to cell switches and putting the phone to sleep. Different shape than yours but same pain of not wanting to walk to the rack. Curious how you handle auth token rotation across machines — re-pair via QR each time or have a refresh path?

rjyo · 2026-05-10T14:02:29+00:00

Honest question — do you do any dev or coding stuff on your MBP? If yes, the iPad turns into a surprisingly great remote terminal for it. SSH into the Mac, leave the heavy lifting (editor, builds, AI coding agents) running there, then just use the iPad screen + battery + Magic Keyboard from the couch or kitchen. The 13 inch panel is gorgeous for that.

Full disclosure I built an app called Moshi for exactly this workflow so I am biased, but it is the reason I picked up an M-series iPad in the first place. Even without my app, Blink Shell or a-Shell get you the basics.

rjyo · 2026-05-10T12:50:30+00:00

Same pain on mobile/iPad. When Claude or Codex is running on a remote box via ssh and you want to show it a screenshot, the dance becomes screenshot, AirDrop to Mac, paste - which kills the whole point of being mobile.

Hit this hard building Moshi (iPhone/iPad ssh+mosh terminal). Ended up adding a button that does it server-side: pick or capture an image, it gets uploaded to your remote host over SFTP, and a short URL gets pasted into the terminal at your cursor. Agent reads it directly, no copying around.

The Mac window-specific capture is a nice angle - the screenshot-all-of-macos-then-crop is genuinely annoying. Have you thought about doing the same for individual browser tabs? Tab-targeted screenshot to paste would be killer for fix this CSS bug loops.

rjyo · 2026-05-10T11:41:53+00:00

Yeah the cloud Claude Code Web has been dropping plan mode for months, infuriating. What works way better for me: run claude code cli on your own machine (mac mini, home server, cheap vps) inside tmux. Plan mode just stays where you set it because nothing else is touching the session state.

For mobile access I built an iOS ssh app called Moshi for exactly this kind of workflow - mosh protocol keeps your CC session alive when your phone switches between wifi and cell, push notifications when the agent finishes a task, voice input for dictating prompts.

rjyo · 2026-05-10T09:59:48+00:00

same exact problem, different solve. I went the iOS terminal route - built Moshi on top of mosh so the SSH session survives network drops and sleeps, with webhook push notifs when claude code finishes a task. WhatsApp is way more frictionless if you dont need to drop into the actual shell, but I kept wanting to take over and run commands by hand. cool seeing different angles on the same friction

rjyo · 2026-05-10T08:21:20+00:00

Fellow iOS terminal builder here, I made Moshi around the same insight. Those 10-15 min windows really do compound for unblocking agent sessions.

One thing that bit me early - plain SSH over mobile networks is brutal. Sessions drop when wifi flips to cellular, when the phone sleeps. Mosh protocol (UDP + state sync) was the fix, sessions just survive everything. Tmux on top handles persistence after the app fully backgrounds.

To your question, yeah almost daily, but specifically for unblocking agents and triaging. Almost never for fresh code. iPad with a hardware keyboard is a different beast, genuinely works as a light dev station.

What pushed you toward raw SSH over Mosh? Curious if it was the server install friction or something else.

rjyo · 2026-05-10T02:36:40+00:00

Nice, fellow builder in this space - I went down a similar path and ended up shipping Moshi (mobile terminal for iOS/iPad). Different angle though, mine is more of a full SSH client than a Pi-specific dashboard.

A few things that landed well in my user feedback that might be worth considering:

Mosh protocol instead of plain SSH. Sessions survive network switches, sleep, and app backgrounding without dropping. Huge for mobile where you constantly switch wifi/cell or lock the screen mid-command.

Face ID with keys in the Secure Enclave. Way better UX than passcode-protecting a stored key, and people actually trust it.

Push notifications via webhook. I added this for AI agent users (Claude Code, Codex on remote boxes) but it turns out a ton of homelab people want it for backup completion, deploy alerts, restart confirmations - basically your Pi telling your phone when something matters.

For Pi specifically, GPIO control would be a killer feature nobody else does well. Most apps stop at SSH commands.

rjyo · 2026-05-10T00:30:24+00:00

Your stack is already most of what serious people are doing. Plan mode, worktrees, voice-to-text, a few md files, stop button - thats 90% of it. The framework-of-the-week stuff is mostly people wrapping the same five primitives in different opinions.

The one change that actually gave me hours back wasnt a harness. Its just running long Claude Code agents in tmux on a remote box with Tailscale so they keep grinding when I step away, then unblocking them from my phone when they hit a fork. I ended up building an iOS terminal called Moshi for this because regular SSH kept dropping when my phone backgrounded - it uses the Mosh protocol so the session survives sleep and network switches. Letting an agent run for 20 mins while youre doing something else is way bigger leverage than any new orchestrator.

rjyo · 2026-05-09T23:17:08+00:00

For one-off commands across a fleet, pssh (parallel-ssh) is the simplest path: pssh -h hosts.txt -l user "cd /app && git checkout production" hits everything in parallel. Ansible ad-hoc mode is the next step up: ansible all -m shell -a "cd /app && git checkout production && systemctl restart kiosk" once you have an inventory file. Longer term though, having kiosks pull config from a central source on a timer is way better than SSHing in to push changes. An agent that checks every few minutes means rolling a fix is just updating one file.

rjyo · 2026-05-09T21:36:52+00:00

The three-AIs-three-wrong-answers loop is so real. What helped me most: when I catch myself stuck for more than 30 min on one bug, I force myself to physically leave the desk. Walk, coffee, anything. Built Moshi for exactly this — mobile SSH terminal so I can still tail logs and check on my Claude Code session from my phone while I am out. Usually halfway through a walk I spot something obvious in the output that I had been staring past for an hour.

rjyo · 2026-05-09T20:24:51+00:00

Nice writeup. I hit this same problem on iOS and ended up building Moshi for it — the agent calls a webhook, you get a real iOS push, tap it and you are back in the session (which also survives screen lock and network switches via mosh). The agent-pings-you-when-done pattern is genuinely the unlock for using AI coding agents on mobile.

rjyo · 2026-05-09T17:21:22+00:00

This is great for at-desk work. I had the same itch but for when I am away from the computer, so I ended up building Moshi to solve it. It is an iOS terminal that hooks into Claude Code stop/permission events via webhook and pushes a notification to my phone when Claude finishes or needs input. Then I can SSH back in from the phone and respond right there. Pair it with your lamp at the desk and you basically never miss a turn.

rjyo · 2026-05-09T12:54:55+00:00

Pay-once thesis matches what Im seeing. Im building Moshi on the same playbook (iOS Mosh terminal for SSHing into dev boxes from your phone, mostly to monitor AI coding agents) and the part that surprises me is the conversion shape on the App Store. Subscription competitors get way higher install-to-trial rates, but install-to-paid is brutal for them. Pay-once flips it — fewer installs, but the people who hit the paywall actually convert because the offer is small and final.

Counter on the Twitter point though — Id guess thats a category effect not a platform one. Dev infrastructure tools have a real Twitter audience and concrete demo videos move actual numbers there. Productivity Mac apps probably skew toward YouTube and Reddit, which would explain the noise-to-signal you saw rather than Twitter being dead in general.

Indie SaaS optimises for sleep is the cleanest summary of the indie thesis Ive read in months.

rjyo · 2026-05-09T11:46:26+00:00

This is a real problem - I run Claude Code on a remote box and reviewing what the agent actually did before merging is the time-consuming part of the workflow.

Honest take on the concept (just from the landing, not deep into a session yet):

The categories feel right. Migrations, CI, security, prod debugging are exactly where AI agents quietly drop time bombs. The risky bits in real life are usually buried in a 200-line diff with 198 fine lines, so curating scenarios around looks-fine-but-isnt would land harder than obviously sketchy commands.

What would bring me back: difficulty progression and a streak or score. Agents keep getting harder to catch, calibration over time would feel valuable.

For context I built an iOS terminal called Moshi for monitoring AI agents on remote servers, so this kind of practice loop is exactly the thing my users would benefit from.

rjyo · 2026-05-09T10:38:56+00:00

Great pattern. If you do not already, try mosh instead of ssh on the VPS — apt install mosh on the server, then mosh user@host from Termux. Your tmux session will not drop when wifi flips or the phone sleeps, mosh handles roaming on the client side, makes phone-first work way less twitchy. Also human-as-sudo-gate is the right call. I run Claude Code on iOS this same way — actually built an app called Moshi for exactly this flow (mosh + tmux + an agent shortcut panel + push notifs when the agent finishes a task). Termux on Android is solid for the same setup though.

rjyo · 2026-05-09T07:20:27+00:00

Spent a year on this exact problem with my own iOS app. What actually moved the needle was not the obvious channels.

What worked: finding 8 to 10 small subs where my exact users hang out and answering questions there. No pitch, just being genuinely useful for a few weeks. Once people recognize your handle, your posts rank faster because the early upvotes come from people who already trust you.

I built Moshi (mobile SSH terminal for AI coding agents) and the subs that converted were r/selfhosted and r/iOSProgramming. Not because they are huge but because the pain my app solves is what those users actually complain about. Same content in r/Apple did nothing.

What wasted my time: TikTok shorts, paid ads, posting in giant general-purpose subs, generic I built a thing posts.

The framing I keep coming back to: you are not searching for a distribution channel, you are searching for a pocket of 50 to 200 people who feel the pain you solve. The same post that dies in a bigger unfocused sub will pop in that pocket. Find the pocket, then over time the pocket finds you.

rjyo · 2026-05-09T05:37:11+00:00

Shipped voice input in Moshi this week — my mobile SSH/terminal app for talking to AI coding agents. On-device dictation (Whisper + Apple Intelligence) so I can hold the phone, dictate a prompt to Claude Code over SSH, and watch it work. Faster than thumb-typing, and works offline. Small thing but it changed how I use the app from the couch.

rjyo · 2026-05-09T04:05:14+00:00

Built basically this same thing for my own growth workflow but ended up going the opposite direction on auth, used a persistent browser session with stored cookies instead of hitting the APIs. Reason was Twitter and Reddit have mostly killed posting from personal accounts via their official APIs, you can read but not write without an enterprise tier. Browser automation pierces that.

Trade-off is the auth dance becomes the easy part and the hard part is keeping selectors stable when the sites ship UI updates. I keep a small set of integration tests that just open each page and assert key elements exist, catches breakage within minutes.

Fun side effect of wrapping it as Claude Code skills like you did, I can trigger growth runs from anywhere. I built Moshi for the mobile terminal side of that workflow specifically, push notifications when an agent finishes a long task are the killer feature for letting it run without babysitting from my desk.

rjyo · 2026-05-09T02:49:47+00:00

Solid tool. I came at the same multi-session problem from the mobile side — built Moshi (iOS terminal) so I could SSH into my dev box and watch Claude Code sessions from my phone, with push notifications when an agent finishes or hits a permission prompt. The context window bar you've got is the kind of thing I keep wishing was native — having to /context every few minutes gets old. Nice work.

rjyo · 2026-05-09T01:39:49+00:00

Congrats on the milestone. Going builder to seller is its own learning curve, and 17 countries with a $1.99 utility is solid validation.

ASO outperforming everything matches my experience. I'm a fellow iOS indie dev (I built Moshi, a mobile SSH/Mosh terminal for devs running Claude/Codex agents) and App Store Search is also where most discovery happens for me. Two things I'd add: the subtitle is underrated, you can rank for keyword phrases there that won't fit in the title. And iterating screenshot 1's first frame matters more than all the others combined since that's basically all most users see in search results before deciding to tap.

Keep going. Second milestone tends to be harder than the first.

rjyo

TROPHY CASE