I like doing real work from a keyboard.

But I don’t like babysitting long-running sessions.

If I start a Claude Code / Codex / OpenCode session that’s going to take 20–60 minutes, I want to be able to check on it from my phone.

Not with a full SSH setup.

Not with remote desktop.

Just: open a browser, see what it’s doing, answer anything it needs, and keep moving.

That “browser-only from phone” requirement sounds simple, but it hides a big fork in the road:

• cloud UI (easy from phone, but not your local repo by default)
• local execution (your repo/tools are there, but you need a remote surface)

This guide is the setup I use when I want local execution and phone check-ins.

TL;DR

1. Decide which world you want:
   • Cloud UI: easiest phone access, but you’ll rebuild your repo workflow around cloud projects/patches.
   • Local/server execution: your repo and tools stay on your machine, but you need a remote surface.
2. If you pick local/server execution, run sessions on a machine that won’t sleep (home server / desktop / dev box).
3. For browser-only access from a phone, you need HTTPS (secure context). If you’re self-hosting, Tailscale Serve is the simplest way to get an https://*.ts.net URL.
4. Happier is one of the options that works well here because the served web UI is phone-friendly, and Tailscale Serve is a first-class path in the docs.

The problem

There are two separate pains here:

1. Where the session runs (your laptop sleeps; Wi‑Fi drops; terminal closes).
2. How you observe/control it from a phone.

Most workflows solve (1) but not (2).

• Running on a server helps, but doesn’t automatically give you a good phone UI.
• A cloud UI gives you a phone UI, but doesn’t automatically give you your local repo.

What I tried first (and where I bounced off)

• SSH from my phone: works, but it turns my phone into a terminal.
• Remote desktop: works, but it’s heavy and misclick-prone.
• Cloud UIs: great phone experience, but the “this is my repo” story changes.

What I wanted was:

• sessions run on a stable machine that owns the repo
• a phone-friendly browser UI

Happier is one of the tools that fits that combination.

Option map: the three ways people actually do this

Option A: Cloud UI (phone-first, not local-repo-first)

This is the easiest “browser-only from phone” path.

Trade-off: you usually don’t get your exact local filesystem and toolchain unless you invest in sync/patch workflows.

Option B: Terminal-first (SSH / Mosh) + accept the UX

This keeps everything local.

Trade-off: you’re still doing terminal work on a phone.

Option C: Local execution + a real remote surface (what we want)

This is the sweet spot for “my repo stays on my machine” + “phone check-ins are easy.”

That remote surface can be:

• an official remote UI (Claude Remote Control)
• a self-hosted dashboard
• a companion app/web UI like Happier

If you’re new to Happier

If you haven’t seen Happier before: it’s an open-source companion app (mobile/web/desktop) for coding sessions like Claude Code, Codex, and OpenCode.

The workflow is: keep sessions and repos running on a machine you trust, and use Happier from your phone to check progress, handle approvals, and send follow-ups.

Get set up:

• How to run Happier from your phone
• GitHub: https://github.com/happier-dev/happier
• Install/download: https://github.com/happier-dev/happier#how-it-works
• Discord: https://discord.gg/W6Pb8KuHfg

A workflow that works (Happier + Tailscale Serve)

This is the browser-only workflow I recommend if you control the machine:

1) Run Happier on the machine that owns your sessions

Pick a stable machine:

• home server
• desktop
• always-on dev box

2) Give yourself an HTTPS URL for the web UI (secure context)

Browsers treat http://localhost as secure, but http://<lan-ip> and http://<tailscale-ip> are not secure contexts.

So for remote phone access, use HTTPS.

Happier’s recommended path is Tailscale Serve, which gives you an https://*.ts.net URL inside your tailnet.

In the Happier stack tooling, the quickstart looks like:

hstack tailscale enable
hstack tailscale url

Then open that https://*.ts.net URL from your phone (also signed into Tailscale).

3) Keep multi-server sane if you have more than one machine

If you end up with multiple servers (personal + work + self-host), treat server profiles as first-class:

• auth is per-server
• notifications are server-aware

This matters because “browser-only check-ins” fail when you’re on the wrong server profile.

4) Use phone check-ins as an explicit loop

From your phone, I try to keep it simple:

• open the session
• check if it’s waiting on approval
• answer one question or send one follow-up

If I need to do real editing or refactoring, I wait for a keyboard.

Troubleshooting

The web UI loads, but crypto features are broken

That’s almost always “not a secure context.”

Use HTTPS (Tailscale Serve / proper TLS) instead of plain LAN HTTP.

I can reach the machine, but sessions don’t show up

Check:

• you’re on the correct server profile
• the daemon/runtime on that machine is connected to the same server

Related guides

• How to keep Claude Code/Codex/OpenCode running when your laptop sleeps
• How to monitor Claude Code from your phone
• How to use multiple Happier servers from your phone