DEV Community: onecookie

I shipped code from my phone while lying on the couch. Here's the exact setup.

onecookie — Tue, 09 Jun 2026 09:02:57 +0000

No staging environments. No laptop.

Just an iPhone, a Mac sitting in the other room, and an AI coding agent running over SSH with Tailscale + tmux + Redock .

The short version

Mac has Remote Login (built-in SSH server). iPhone connects to it. AI agent runs on the Mac, not on the phone.

The phone is just a thin terminal, but with tmux persistence, one-tap project launchers, and background tasks that survive disconnects. You can literally start a minutes build, close the app, and check the output later.

If this sounds like a toy, I thought so too. Then I refactored a NextJS crate from bed at 2 AM and it actually worked.

Step 1: Turn your Mac into an SSH server

This is the foundation. No third-party server, no cloud VM needed.

On your Mac:

System Settings > General > Sharing > Remote Login → ON
Allow only your dev account
Find your LAN IP

ifconfig | grep "inet " | grep -v 127.0.0.1

look for 192.168.x.x or 10.x.x.x, that's your LAN address

On your iPhone:

Open the Redock app, go to Launch → Add Host
Tap "Discover Local Devices" (it scans your LAN for SSH hosts)
Or enter manually: Host 192.168.1.23, Port 22, your Mac username, your Mac password
Connect → you now have a real terminal session into your Mac

That's it. You're now SSH'd into your Mac from your phone. Navigate to a project, fire up nvim, run git status.

It all works. Latency on LAN is around 2-5ms.

Step 2: Add Tailscale so it works from anywhere

LAN is great for the couch, but useless when you're on cellular or at a coffee shop. Tailscale puts your phone and Mac on the same virtual network without exposing SSH to the public internet.

On Mac:

brew install tailscale
tailscale up

On iPhone:

Install Tailscale from App Store, sign in to same account

Now your Mac has a 100.x.y.z Tailscale IP. Use that as the Host instead of the LAN IP. Same Port 22, same credentials. Works from cellular, office Wi-Fi, other countries — wherever.

Other options if you prefer:

ngrok TCP tunnel for temporary access, or direct port forwarding if you have a public IP. But Tailscale is the zero-config sweet spot for most people.

Step 3: The workflow that makes mobile coding actually usable

Raw SSH from a phone is painful. Typing long commands, remembering project paths, losing sessions when you switch apps, it adds up. Here's what makes it fast:

Projects + Actions = one-tap launch

Define your project once (working directory, default host). Then create Actions, saved commands with a run mode.

Three run modes matter:

Terminal Interactive: opens a live terminal session. Use this for AI agents (claude, codex, opencode), REPLs, or anything you need to talk to.
Quick Task: runs a command over SSH, captures the output, saves it as a Run record. Perfect for git status, npm test, health checks.
Background Long Task: starts the command inside remote tmux, keeps running after you close the app. For builds, long tests, batch jobs.

tmux persistence

Install tmux on the Mac:

brew install tmux

Then enable tmux in the host settings. The app handles session create/attach/restore automatically.

You don't type tmux new or tmux attach, when you reconnect, it shows existing sessions and lets you pick one.

One pane for the AI agent, another pane for watching logs or running tests. If your phone disconnects mid-session, the work is still running on the Mac.

The realistic daily loop

Here's what a typical evening looks like:

Open phone, tap "My Project" from Launch
Tap the "Claude Code" action → terminal opens, agent is already in the project directory
Describe a change, agent starts working
Agent finishes, git add . && git commit -m "..." from the snippet bar

Total taps: maybe 4. Total ti0-ppme on the keyboard: mainly the prompt and the commit message. Everything else is one-tap or snippet driven.

The trick isn't the terminal, dozens of iOS SSH clients exist. The trick is that the project/action/tmux layer eliminates all the friction around the terminal: remembering paths, retyping setup commands, losing sessions, digging through history to find old task output.

Q&A

Q: Is this a gimmick or do you actually ship this way?

I use it for real work, quick fixes, PR reviews, starting long builds before bed, checking CI failures from brunch. It won't replace my desk setup for deep flow-state work, but it covers the other 60% of development moments when I'm not at my desk.

Q: What AI agents work?

Anything that runs in a terminal: Claude Code, Codex, opencode, aider, cursor-agent. The agent runs on your Mac, the phone is just the display and keyboard. No mobile app SDK integration needed.

Q: Security?

Your SSH credentials never leave your phone (stored in Apple Keychain). For Tailscale, the connection stays inside the tailnet. For public access, use SSH keys, the app supports key generation and importing existing keys.

Q: Does it work on iPad?

Yes. Same app, bigger screen. Even better for split pane tmux layouts.

Q: Can I use it with a VPS instead of a Mac?

Yes. Linux VPS works the same way. SSH in, enable tmux, set up projects. If it has a public IP, skip Tailscale entirely and connect directly.

AI coding agents made mobile development practical, so I built Redock

onecookie — Sat, 09 May 2026 14:17:12 +0000

For a long time, I did not think mobile development was very practical.

Yes, you could install an SSH client on an iPhone or iPad, connect to a server, and run a few commands. But for real development work, it usually felt too awkward. The screen was small, typing was slow, terminal interaction was not designed for touch, and anything more than a quick check often became frustrating.

AI coding agents changed that for me.

With tools like Claude Code, Codex CLI, and other terminal based agents, mobile development no longer means writing every line of code on a phone. The phone can become more like a control surface for a real development machine.

You connect to your Mac, Linux box, or remote server, guide the agent, review the output, trigger builds, and verify results. The actual heavy work still happens on the development machine.

That shift made me think mobile development could become practical in a new way.

So I built Redock.

Redock is an iOS and iPadOS terminal app designed around SSH, tmux, and AI coding agent workflows.

The problem I wanted to solve

The original use case came from my own workflow.

Sometimes I am not at my desk. I might be outside, waiting in line, or just away from my Mac. But that is often exactly when a small product idea, bug fix, or implementation detail comes to mind.

In the past, I would usually write it down and handle it later.

But now, with AI coding agents, a lot of small development tasks can be started and verified remotely.

For example:

connect to my development machine
resume a previous tmux session
ask the agent to inspect or modify part of the codebase
run tests or scripts
keep the session alive even if the phone disconnects

Traditional mobile SSH clients can technically do some of this. But they are still mostly designed as generic terminals.

Redock is designed around the development loop.

How Redock is different from a generic SSH client

A normal mobile SSH client gives you a terminal.

That is useful, but it does not remove much friction from the workflow.

When working with coding agents, I found myself repeatedly doing the same things:

navigating to the same project directory
starting the same agent command
attaching to the same tmux session
running the same test, build, or deploy scripts
copying and editing prompts before sending them

On a desktop, that is manageable. On a phone, every repeated command becomes friction.

So Redock adds a few workflow layers on top of SSH.

Projects

A Project groups a host, working directory, and common context together.

Instead of thinking only in terms of “connect to this server,” Redock lets me think in terms of “continue working on this project.”

This matters because agent workflows are context heavy. I usually want to land directly in the right machine, right directory, and right session.

Actions

An Action is a reusable command.

It can be something like:

start Claude Code
run tests
open a project directory
trigger a build script

The goal is not to hide the terminal. The goal is to avoid typing the same operational commands over and over on a small screen.

For mobile workflows, tappable commands make a big difference.

Agent TUI friendly terminal UX

Coding agents often use terminal UIs, long running output, and conversational history.

Redock adapts the terminal experience for that kind of usage:

scrollable history
gesture navigation
voice input
a draft input area for preparing prompts before sending
better handling of long agent output on a small screen

The draft input area is especially important to me.

When I am using a phone, I do not want every typed character to go directly into the terminal. I often want to compose a prompt, edit it, and then send it as one message.

That feels much closer to how I actually interact with AI coding agents.

Built-in tmux workflow

Mobile connections are unreliable.

The app can be backgrounded. The network can change. The phone can disconnect. Long running agent sessions, builds, and deploy scripts should not die because of that.

So tmux is central to the workflow.

Redock makes it easy to create, resume, and keep sessions alive. The development task keeps running on the machine, while the phone is just the interface.

This is one of the biggest differences between “mobile terminal as a quick emergency tool” and “mobile terminal as a real workflow.”

Why terminal first instead of chat first

There are also remote agent controller products that provide a more chat like interface.

I considered that direction, but I wanted Redock to stay terminal first.

The reason is flexibility.

With SSH, I can use any CLI agent, any script, any shell tool, and any development environment. I can inspect files, run commands and verify things myself.

Redock does not proxy coding sessions through my server. It connects to your own machine over SSH.

That means the workflow is not tied to one specific agent or one hosted backend.

For my use case, that matters.

Link

You can find Redock here:

https://redock.dev

The bigger question

I do not think the phone will replace a desktop development setup.

That is not the point.

The more interesting question is whether AI coding agents make small pockets of development time more useful.

If the agent can do more of the implementation work on a real development machine, then maybe the phone becomes good enough for:

starting a task
guiding an agent
reviewing progress
running verification
resuming a session
shipping a small fix

That is the workflow I wanted to explore with Redock.

I am curious how other developers think about this.

Do you ever do real development work from a phone or tablet? Or prefer to keep coding strictly tied to a desktop setup?