Remote Coding from a Coffee Shop: A Developer's Guide

There's a specific developer scenario that keeps coming up: your Mac is running at home or the office, Claude Code is working on a task, and you're somewhere else with just your phone. Maybe a coffee shop, maybe an airport lounge, maybe a park bench.

This guide covers the practical considerations for remote coding from these environments — not the aspirational "digital nomad" pitch, but the actual logistics of making it work reliably and securely.

The Setup You Need Before Leaving

Remote coding requires preparation before you walk out the door. You can't set up infrastructure from a phone.

On your Mac (before leaving):

1. Server running — Tactic Remote's Mac app should be started with the server active
2. Cloudflare Tunnel enabled — LAN mode only works on the same network, so you need tunnel access for remote locations
3. API key configured — required for Cloudflare Tunnel connections
4. Sleep prevention active — Tactic Remote prevents Mac sleep while the server runs, but verify your Mac won't shut down on a power schedule
5. Test the tunnel connection — switch your phone to cellular and confirm you can connect through the tunnel URL

On your iPhone:

1. Tactic Remote installed with connection settings saved
2. Cloudflare connection mode configured (tunnel URL + API key)
3. Notifications enabled so you can be alerted when Claude finishes tasks

The critical point: test everything while you're still at home. Debugging connection issues from a coffee shop with only your phone is painful.

Coffee Shop WiFi: What Actually Goes Wrong

Public WiFi creates three specific problems for remote development:

1. Captive Portals Block WebSocket Connections

Many coffee shop WiFi networks require you to accept terms on a captive portal page before traffic flows. WebSocket connections can fail silently during this state — your phone appears connected, but the handshake does not complete.

Solution: Open Safari first and confirm you can load a regular webpage. Only then open Tactic Remote. If the connection fails, toggle WiFi off and back on — sometimes the captive portal state gets stuck.

2. Network Switching Drops Connections

Your phone might switch between WiFi and cellular, or between different WiFi access points in the same venue. Each switch drops the WebSocket connection.

How Tactic Remote handles this: Automatic reconnection with exponential backoff (up to 5 attempts, max 15 seconds between retries). When the app detects a reconnection, it performs multi-stage state hydration to recover the terminal state. You'll see a brief "Reconnecting..." state, then the terminal output reappears.

What you can do: If reconnection takes too long, manually switch to cellular. Cloudflare Tunnel works over any internet connection, so cellular is actually more stable than flaky coffee shop WiFi.

3. Bandwidth and Latency Variation

Terminal streaming is lightweight — much less data than video calls. But latency affects how responsive the interface feels. On good WiFi, keystrokes appear instantly. On congested networks, there's a noticeable delay.

Practical impact: For the "fire and forget" workflow (send a task, wait for notification), latency doesn't matter. It only affects real-time interaction — sending prompts, reviewing live output, approving actions. If the network is bad, batch your interactions: review output, think about what to say, type the full prompt, send. Don't try to interact keystroke-by-keystroke.

The "Fire and Forget" Workflow

The most productive remote coding pattern isn't monitoring Claude in real time. It's this:

1. Send a well-defined task from your phone
2. Put the phone away and enjoy your coffee
3. Get notified when Claude finishes
4. Review the result and send the next task

This works because Claude Code does its best work on clear, bounded prompts:

• "Fix the failing tests in the auth module" (bounded, clear success criteria)
• "Add input validation to all REST endpoints in src/routes/" (specific scope)
• "Refactor UserService to use constructor injection" (clear architectural intent)

Vague prompts like "improve the codebase" are bad at your desk too, but they're worse from a phone because you can't easily course-correct mid-task.

Task Sizing for Mobile

A useful heuristic: each task you send from your phone should be completable without needing your input. If Claude will need to ask clarifying questions, you want to be there to answer. If the task is self-contained, Claude can run it while you're not watching.

Good "leave it alone" tasks:

• Bug fixes with clear reproduction steps
• Test additions for existing code
• Refactoring with a specific pattern to apply
• Code review comments to address

Tasks that need your presence:

• Architectural decisions Claude isn't sure about
• Multi-step features where each step depends on your preference
• Anything involving external services Claude hasn't seen before

Security on Public Networks

When your coding commands cross public WiFi, security matters.

What's Already Protected

Tactic Remote over Cloudflare Tunnel provides:

• TLS encryption — the WebSocket connection uses wss://, so traffic between your phone and Cloudflare is encrypted
• API key authentication — required for tunnel connections, preventing unauthorized access
• No exposed ports — your Mac doesn't open any ports to the internet. Cloudflare initiates the tunnel outbound from your Mac

This means someone on the same coffee shop WiFi cannot:

• See your terminal output (encrypted)
• Send commands to your Mac (needs API key)
• Even discover that your Mac is running a coding server (no inbound ports)

What You Should Still Be Careful About

• Screen visibility — someone looking over your shoulder can see your terminal output. This might include API keys, database credentials, or sensitive code. Use your phone's privacy screen if you handle sensitive data.
• API key storage — your Tactic Remote connection settings include the API key. If someone gains access to your unlocked phone, they could extract it. Use iOS Face ID / passcode.
• Shared clipboard — be careful with copy-paste if you use Universal Clipboard between your Mac and phone. Sensitive content on your Mac's clipboard might appear on your phone.

Battery and Connectivity Planning

Practical logistics that matter for extended remote sessions:

Battery: Tactic Remote is lightweight on battery — WebSocket connections are idle most of the time, with occasional data bursts. Expect minimal battery impact compared to apps like video conferencing or maps. The phone screen is your main drain, so turn it off between tasks and rely on notifications.

Cellular fallback: If coffee shop WiFi is unreliable, cellular is often better. Cloudflare Tunnel works over any internet connection. 4G/5G latency is typically better than congested public WiFi.

Offline periods: If you lose connectivity entirely, your Mac keeps running. Claude Code continues its current task inside the tmux session. When you reconnect, the session state is still there. You don't lose work — you just can't monitor or interact until connectivity returns.

A Realistic Coffee Shop Session

Here's what it actually looks like:

2:15 PM — Arrive, order coffee Connect phone to WiFi, open Safari to clear captive portal, open Tactic Remote. Connected in 5 seconds via Cloudflare Tunnel.

2:17 PM — Start a task Open existing session for the project. Type: "The CI is failing on the user-auth branch. Check the failing tests and fix them."

2:18 PM - 2:45 PM — Drink coffee, read articles Phone buzzes once: "Notification from Claude" — Claude found 3 failing tests, all related to a changed API signature. It fixed the imports and updated the assertions.

2:46 PM — Review and continue Open the session, scroll through Claude's output. Changes look correct. Type: "Run the full test suite to verify everything passes."

2:47 PM - 3:10 PM — More coffee, respond to emails Phone buzzes: "Task completed." All 47 tests pass.

3:11 PM — Final task Type: "Commit the fixes with message 'fix: update auth tests for new API signature' and push."

3:12 PM — Done Claude confirms the push. Check GitHub on your phone to verify the CI is green. Close the app.

Total active coding time: roughly 5 minutes. Total productive output: a real bug fix, committed and pushed. The coffee shop was just a location — the work happened on your Mac.

When This Doesn't Work Well

Being honest:

• Complex debugging — stepping through code, checking variable state, reading long stack traces. This is hard on a phone screen regardless of the tool.
• Design reviews — looking at UI changes, comparing layouts. You need a bigger screen.
• Multi-file exploration — understanding a large PR or reading through unfamiliar code. Better on a laptop.
• Initial project setup — creating configs, setting up environments, installing dependencies. Do this at your desk.

The coffee shop workflow is best for delegating well-defined tasks and reviewing results. It's not a replacement for focused desk work — it's an extension of it.