My Daily Tactic Remote Workflow: Sessions, Notifications, and the Mobile Review Loop

I run Claude Code on three projects simultaneously. Each one works on a different task — frontend, backend, tests. When any of them finishes or needs my approval, I get a push notification on my phone. I tap, review, approve, and walk away.

This is my actual daily workflow with Tactic Remote. No theory. Just what I do every day.

TL;DR: Three tmux sessions, one per project or task. Hooks auto-configured by the Mac companion app send push notifications. Review from your iPhone, approve with one tap, keep walking.

The Session Layout

I organize tmux sessions by project, not by tool. Each project gets its own session with its own working directory:

┌─────────────────────────────────────────────────┐
│                  Your Mac                        │
│                                                  │
│  tmux session: webapp      (~/code/webapp)       │
│    └─ Claude: "Refactoring auth to use JWT..."   │
│                                                  │
│  tmux session: api         (~/code/api)          │
│    └─ Claude: "Adding rate limiting..."          │
│                                                  │
│  tmux session: mobile      (~/code/mobile-app)   │
│    └─ Claude: "Fixing navigation crash..."       │
│                                                  │
└─────────────────────────────────────────────────┘
                      │
                      │  push notification:
                      │  "Claude Task Completed — webapp"
                      ▼
              ┌──────────────┐
              │   iPhone     │
              │  Claude      │
              │  Remote      │
              └──────────────┘

Why sessions instead of windows? Because each Claude Code instance needs its own working directory and its own 50,000-line scrollback buffer. Sessions give you clean isolation — switching between projects is switching between sessions, not remembering which window number maps to which task.

Creating Sessions from Your Phone

From the Tactic Remote app:

1. Tap the session picker (top of the screen)
2. Tap "Create Session"
3. Name it (e.g., webapp)
4. Browse to the project directory using the path picker
5. Tap "Start Claude"

Behind the scenes, this triggers:

tmux new-session -d -s webapp -c ~/code/webapp
tmux set-option -t webapp history-limit 50000
tmux send-keys -t webapp -l 'claude'
tmux send-keys -t webapp C-m

Then repeat for api and mobile. Three sessions, three independent Claude Code instances, each scoped to the right project.

The Notification Pipeline

This is the part that makes the whole workflow practical. Without notifications, you'd have to keep checking your phone to see if Claude finished. With them, you can genuinely walk away.

How It's Set Up

The Mac companion app auto-configures Claude Code hooks on server start. No manual setup required. It writes three shell scripts to ~/.claude/hooks/:

#!/bin/bash
# claude-remote-stop.sh (auto-generated)
 
PORT="${CLAUDE_REMOTE_PORT:-8765}"
HOOK_SERVER_URL="http://localhost:${PORT}/hook"
 
TMUX_SESSION=""
if [ -n "$TMUX" ]; then
    TMUX_SESSION=$(tmux display-message -p '#S')
fi
 
PROJECT="$(basename "$PWD")"
TIMESTAMP=$(date +%s)
 
curl -s -X POST "$HOOK_SERVER_URL" \
    -H "Content-Type: application/json" \
    -d "{\"event\":\"Stop\",\"project\":\"$PROJECT\",\"tmux_session\":\"$TMUX_SESSION\",\"timestamp\":$TIMESTAMP}" \
    > /dev/null 2>&1 &
exit 0

Then it registers these scripts in ~/.claude/settings.json so Claude Code calls them on lifecycle events:

{
  "hooks": {
    "Stop": [
      {
        "matcher": "*",
        "hooks": [{ "type": "command", "command": "~/.claude/hooks/claude-remote-stop.sh" }]
      }
    ],
    "Notification": [
      {
        "matcher": "*",
        "hooks": [{ "type": "command", "command": "~/.claude/hooks/claude-remote-notification.sh" }]
      }
    ]
  }
}

The Event Flow

Claude finishes task
    │
    ▼
Claude Code hook fires: claude-remote-stop.sh
    │
    ▼
curl POST http://localhost:8765/hook
  {"event": "Stop", "project": "webapp", "tmux_session": "webapp"}
    │
    ▼
Node.js server receives hook → broadcasts to all WebSocket clients
    │
    ├─► If iPhone is in foreground:
    │     Terminal shows: 📢 [Claude] Project completed
    │
    └─► If iPhone is in background:
          System push notification appears
          Tap → opens directly into the session

Deduplication

Claude sometimes fires multiple hook events in rapid succession — for example, when it completes several subtasks in a row. The iOS app deduplicates with a 3-second window. If the same event (same project, same session, same timestamp) arrives twice within 3 seconds, the duplicate is silently dropped. No notification spam.

The Review Loop

This is what a typical review cycle looks like:

Step 1: Get Notified

My phone buzzes: "Claude Task Completed — webapp"

I'm at a coffee shop, or on the couch, or walking to lunch. Doesn't matter.

Step 2: Review the Output

Tap the notification. Tactic Remote opens directly into the webapp session. I see Claude's full output — what it changed, what it's asking about, any test results.

The terminal view preserves all of Claude Code's formatting: syntax highlighting, diff colors, box-drawing characters for its UI. It's not a stripped-down summary — it's the real terminal output, rendered with ANSI colors on your phone.

If the output is long, scroll up. The 50,000-line tmux scrollback buffer means nothing is lost, even if Claude produced pages of output while I was away. The app can fetch up to 5,000 lines with "Load More."

Step 3: Approve or Redirect

Three common scenarios:

Claude is waiting for permission to run a command:

Claude shows something like:

> Need permission to run: npm install bcrypt
> [y/n]

I tap the Y button on the keyboard toolbar. One tap. Claude continues.

Claude finished and is at its prompt:

I type a new instruction: "Now write tests for the auth module." Hit send. Claude starts working on the next task. I put my phone away.

Claude hit an error and needs guidance:

I read the error, type a response explaining what to do differently, and send it. Claude adjusts its approach.

Step 4: Walk Away

After approving or redirecting, I switch to the next session (tap the session picker, tap api) to check on the other task. If it's still running, I walk away and wait for the next notification.

The loop is: notification → review → act → walk away. Each cycle takes 30 seconds to 2 minutes, depending on what Claude produced.

Parallel Task Strategy

Running multiple Claude instances in parallel is powerful but requires some discipline. Here's what I've learned:

Give Each Task a Clear, Complete Brief

Don't send vague instructions like "work on the frontend." Send specific ones:

Refactor the authentication module in src/auth/ to use JWT tokens
instead of session cookies. Update all route handlers that check
auth. Write tests. Run the existing test suite to make sure nothing
breaks.

The more specific your prompt, the longer Claude can work autonomously before needing input. Vague prompts mean more interruptions.

Stagger Your Starts

Don't start all three sessions at the exact same time. Start one, wait for it to begin working (you'll see the initial output in about 5 seconds), then start the next. This avoids all three hitting permission prompts simultaneously, which means three notifications arriving at once.

Check the Busy One Last

When reviewing, start with the session that's been running longest — it's most likely to be done or stuck. The most recently started session is probably still working.

Use Session Names That Make Sense

When you get a push notification that says "Claude Task Completed — webapp," you need to know what that means without thinking. Don't name sessions session1, session2, session3. Name them after projects or tasks.

Quick Actions I Use Constantly

The keyboard toolbar at the bottom of the chat view has special keys designed for Claude Code interaction:

The Y and N buttons exist specifically because Claude Code's permission prompts are the most common interaction. Being able to approve with a single tap — not typing "y" on a phone keyboard — makes the mobile workflow practical.

My .tmux.conf

Minimal. I don't do anything fancy:

# Big scrollback — Claude produces a LOT of output
set -g history-limit 50000
 
# Mouse scrolling (not used much from the phone, but helpful at the desk)
set -g mouse on
 
# Start window numbering at 1
set -g base-index 1

Tactic Remote sets the scrollback to 50,000 when creating sessions, so the .tmux.conf setting is a backstop for sessions you create manually.

What This Looks Like in Practice

A typical morning:

8:00 AM — Sit down at my Mac. Three projects need work. Create three sessions from the Mac companion app (or from the iPhone — either works).

8:05 AM — Send Claude a detailed task in each session. Walk to the kitchen.

8:20 AM — First notification: api session completed. Review on iPhone. Claude added rate limiting, tests pass. Send next task: "Now add the rate limit headers to the API docs."

8:35 AM — Second notification: webapp session needs approval. Open it. Claude wants to install a new dependency. Check it looks right. Tap Y. Walk to my desk.

8:50 AM — Third notification: mobile session completed. Review. Looks good. Start a new task.

9:00 AM — Sit down at my Mac. All three projects have made significant progress. Review the diffs in git, commit, push.

One hour, three projects, most of it done while I was making coffee and eating breakfast. The phone-based review loop reduced long idle waits for desk-only approvals.

Tips

Enable notifications immediately. The hooks are auto-configured by the Mac companion app, but you need to grant notification permissions on your iPhone when prompted. Do this on first launch — the entire workflow depends on it.

Keep Tactic Remote in your dock. You'll open it 20-30 times a day during active development sessions. Having it one tap away matters.

Trust the scrollback. When you reconnect to a session, all the output is there. You don't need to ask Claude "what did you do?" — scroll up and read the terminal output directly.

Don't micro-manage. The point of this workflow is to give Claude substantial tasks and walk away. If you're checking every 2 minutes, you're using it wrong. Give it a 15-minute task, wait for the notification, then review.

For the technical details of how the server, tmux, and notifications work under the hood, see Running Claude Code Remotely from Your Phone. For initial setup, see Getting Started.