Claude Code in My Pocket: Building cc-remote
At the end of my Split writeup I said the next iteration of this lifestyle isn't a nicer office on the road - it's no office. I'd spent a month on a roof terrace thinking about how to drive my agents from a phone instead of a laptop, and I came home with an itch and no answer.
This is the answer. Or at least version one of it. It's called cc-remote, and it's deployed and working right now.
The Problem
I already had all the pieces. A Raspberry Pi 5 sitting at home, perfectly capable of running Claude Code. A Tailscale network connecting my phone, my Mac, and the Pi into one private mesh. And a phone that's with me constantly.
What I didn't have was a good way to connect them. The official Claude app is fine for chat, but its remote-control story - actually driving coding sessions on your own machines - was iffy at best when I tried to lean on it. And SSH-ing into a Pi from a phone keyboard to squint at a terminal is technically possible in the same way that eating soup with a fork is technically possible.
What I wanted was the full capability of Claude Code - the real thing, with all its tools, running against my actual projects - wrapped in a UI that feels good on a phone. So I built it.
What cc-remote Is
The stack is simple to describe:
- Claude Code runs on the Pi 5 (pi5-1, the same box that runs half my homelab), inside persistent
tmuxsessions - Tailscale connects my phone to the Pi from anywhere - no port forwarding, no exposed services
- A custom Android app, Claude-branded because I wanted it to feel like a real product and not a hack, gives me a proper chat interface
The clever-ish bit is how the app renders the conversation. It doesn't reimplement Claude Code's protocol or wrap some API. It tails the tmux transcript - the actual text of the terminal session - and parses it into chat bubbles. Claude's replies become messages. My prompts go in through a text box and get injected into the session. From my phone it looks and feels like a chat app; underneath it's a bog-standard terminal session that has no idea it's being puppeted.
From the app I can pick which folder a session lives in, restart a session that's gone sideways, and scroll back through what the agent has been doing. That's most of what you need, most of the time.
The tmux Bonus I Didn't Fully Appreciate Until I Used It
Because the sessions live in tmux on the Pi rather than on any client device, they don't belong to the phone at all. Which means when I sit down at my MacBook, I open Ghostty, ssh to the Pi, attach to the session - and I'm looking at the exact same conversation, exactly where I left it on my phone, now in a normal full-terminal view. No sync step, no handoff, no "let me just find where I was". It's one session with two windows into it.
There's a quieter benefit too: Claude Code isn't running on my Mac anymore. Long agent sessions used to mean my laptop fans spinning and the battery draining while it churned. Now the Pi does the churning, plugged into the wall at home, and my Mac is just a screen. My battery life has noticeably improved for the most mundane reason possible: I offloaded the work to a computer that costs less than a pair of trainers.
The Actual Point
Here's the thing I keep coming back to, and it's the reason this project matters to me more than its size suggests.
I've shifted my AI off my laptop. Which means I've shifted my coding off my laptop. The phone in my pocket is now a fully capable window into my codebase, with an agent on the other end that can read, write, build, and test.
Everyone has dead phone time. Waiting for a train, standing in a queue, sitting in a pub while your mate's at the bar. The default fill for that time is doomscrolling - and I'm not above it, I've lost as many hours to feeds as anyone. But now that exact same phone, in those exact same moments, can be pointed at my projects instead. I fire off a prompt while I'm out, the Pi grinds away at home, and I check the result when I next glance at my phone. Time spent outside, doing things is now also potentially coding time. That reframing - not the app, not the Pi, the reframing - is the real product here.
What I've Actually Used It For
It's brand new, so the honest answer is: not much yet, but the first real use was a good one. I used cc-remote to audit my home CCTV setup - poking around configs and camera feeds from my phone - to scope out building a CCTV "sentry" system that would send me smart, filtered alerts instead of the usual motion-detection spam.
The funny part: having done all that scoping from my phone, I then went and built the sentry on my Mac anyway. Old habits. The phone was the reconnaissance vehicle and the laptop was still the workshop. I'd like to tell you I shipped a whole feature from a beach chair, but we're not there yet. Give it a month.
What Broke
Two failures worth being honest about, because this is a v1 and it behaves like one.
The Tailscale IP changed and took the whole thing down. The app was pointed at a hardcoded Tailscale address, the Pi got a new one, and the app just sat there loading forever with no error, no timeout message, nothing. From the outside it looked like cc-remote had simply died. Debugging "my phone app spins forever" down to "the overlay network re-addressed a node" is not a fun afternoon. The fix is obvious in hindsight - use MagicDNS names instead of raw IPs, and fail loudly - but I earned that lesson the annoying way.
Terminal output is not a stable API. Tailing a tmux transcript works brilliantly when Claude is replying in ordinary prose. But Claude Code's terminal UI has many faces: model selection menus, interactive yes/no prompts, multi-choice questions rendered as little TUI widgets. My parser was built for the happy path, and some of these formats made it fall over - the app would show garbage or just stall, waiting for a "message" that was actually a menu wanting arrow-key input. I've patched the worst cases, but scraping a UI meant for humans is an arms race, and I know it.
Where This Goes
Version one proved the shape is right: agent on the Pi, phone as the window, tmux as the shared substrate, Mac as the optional big-screen view. The rough edges are all fixable - stable addressing, a smarter parser, maybe intercepting the interactive prompts and rendering them as native UI instead of garbled text.
But even rough, it's already changed something. Back in Split I was staring at the Adriatic wishing I could ship code from a beach chair. I'm back in Manchester now, so the beach chair is more of a bus stop - but the wish itself is done. The office is wherever my phone is.