Pro Setup: Status Line, Key Flags, Phone and Cloud Sessions

Summary

A pro setup removes friction so the tool gets out of your way. The right flags let you resume and continue work instantly and, when you genuinely need it, run without the permission prompt. A good status line keeps the numbers that matter - model, context fill, branch, cost - in constant view, so you see the performance cliff or a runaway bill coming. And cloud and phone sessions mean a long task keeps running while you step away, and you can start or check work from anywhere. This lesson wires all three up.

What you will learn

You will learn the everyday flags worth memorising and exactly what each does, how to configure a custom status line that surfaces the information you actually watch, and the options for running sessions remotely - moving work between local and cloud, and driving a session from your phone through a browser. By the end your setup will feel like a cockpit instead of a black box.

Prerequisites

A confident single-agent workflow and the installation lesson from Course 1, since this builds on a working Claude Code setup. The context lesson just before this one pairs especially well, because a status line is largely a tool for watching the context fill that you learned to manage there.

The problem

Out of the box you are flying blind and retyping yourself. You cannot see how full your context is, so the cliff surprises you. You cannot see the running cost, so the bill surprises you. You close your terminal and lose the thread of a session you wanted to continue. You confirm the same safe command for the hundredth time. And the moment you leave your desk, all work stops. None of this is hard to fix, and fixing it is the difference between fighting the tool and flowing with it.

The key flags

A few flags carry most of the daily value. Learn these four and the friction drops away. --resume lets you pick a past session from a list and continue exactly where it left off. -c (continue) jumps straight back into your most recent session in this directory, which is the one you reach for constantly. -p runs a prompt non-interactively and prints the result, perfect for scripting the agent into other tools. And --dangerously-skip-permissions bypasses the per-action confirmation prompts. That last one is named to scare you, correctly: it is genuinely useful for a trusted, sandboxed, repeatable workflow, and genuinely dangerous anywhere the agent could run something destructive on data you care about.

# Continue your most recent session in this folder
claude -c

# Pick a past session from a list and resume it
claude --resume

# Run one prompt non-interactively (great for scripts)
claude -p "Summarise what changed since the last commit"

# Skip permission prompts - only in a trusted, sandboxed setup
claude --dangerously-skip-permissions

Treat --dangerously-skip-permissions as a power tool with a guard removed. Use it for a contained, repeatable task you trust completely, ideally in a sandbox or a throwaway environment. Never use it on a session that can touch production, secrets or data you cannot afford to lose. The permission prompt is friction by design, and most of the time you want it.

A custom status line

A status line is a strip of live information Claude Code shows you continuously. You configure it with a small script that the harness calls and feeds session data as JSON, and you print whatever you want back. The point is to keep the numbers you actually watch in view at all times: which model you are on, how full the context window is (your early-warning for the cliff), your current Git branch, and the running cost. Once you can see context fill and cost without asking, you start managing both instinctively - you compact before the cliff and you notice a runaway bill in seconds instead of at the end of the month.

// .claude/settings.json - point at your status line script
{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh"
  }
}

#!/usr/bin/env bash
# ~/.claude/statusline.sh - reads session JSON on stdin, prints a status line
input=$(cat)
model=$(echo "$input" | jq -r ".model.display_name")
dir=$(echo "$input" | jq -r ".workspace.current_dir" | xargs basename)
branch=$(git -C "$(echo "$input" | jq -r ".workspace.current_dir")" branch --show-current 2>/dev/null)
echo "[$model] $dir @ ${branch:-no-git}"

This is a starting point - extend the script to show context size and cost from the session JSON once you are comfortable. Check the official status line docs for the exact JSON fields available, since they grow over time. The habit it builds, glancing at your context and cost the way a driver glances at the dashboard, is worth more than any single field.

Phone and cloud sessions

The last upgrade unties building from your desk. Cloud sessions run the agent on a remote machine rather than your laptop, which means a long task keeps going after you close the lid, and you can pick it up later from anywhere. Because a cloud session lives on a server with its own web interface, you can open it in a browser - including the browser on your phone - and read what the agent is doing, answer a question it has, or kick off a new task while you are away from your computer. The pattern that emerges is fluid: start a heavy task on your machine or in the cloud, step out, check on it from your phone, and the work never stalled because you walked away. Building becomes an always-on activity instead of something chained to one screen.

• Cloud session: the agent runs on a remote machine, so long tasks continue after you close your laptop.
• Browser access: open the session in any browser, including on your phone, to monitor or steer it.
• From your phone you can read progress, answer the agent's questions, and start new tasks without your computer.
• The flow: kick off work, step away, check and nudge from your phone, come back to a finished job.

Typical mistakes

The ones that bite: using --dangerously-skip-permissions on a session that can reach production or secrets, which is exactly how an agent does real damage; never setting up a status line and then being blindsided by the cliff or a surprise bill; forgetting -c exists and laboriously re-explaining context you could have resumed in one keystroke; and treating cloud and phone access as gimmicks rather than the thing that keeps long tasks moving while you live your life. Set the dashboard up, respect the dangerous flag, and use the remote options for real.

Business ROI

A pro setup compounds every other skill in this course by removing the friction that quietly taxes all of them. A status line that surfaces context and cost prevents the two most common ways agentic work goes wrong - the quality cliff and the runaway bill - before they cost you anything. The resume and continue flags reclaim minutes every single session, which add up fast. And cloud and phone access mean expensive long-running work happens in the background of your day instead of blocking your screen, so you get more done in the same hours. For a founder, this is the setup that turns the agent from a tool you sit in front of into a workforce you supervise from anywhere.

Checklist

You have completed Course 2 when each of these is true. Take a moment - you are now genuinely running a power-user setup.

• You know what --resume, -c, -p and --dangerously-skip-permissions each do, and when the dangerous one is and is not appropriate.
• You have a custom status line that at minimum shows your model and branch, with context and cost as the next step.
• You can run a session in the cloud and check on it from a browser.
• You understand how to start, monitor and steer work from your phone.

Resources

Bookmark the official Claude Code docs on CLI flags, the status line and cloud sessions for the current commands and JSON fields, which evolve. The jq tool used in the status line script is worth installing if you do not have it. Your settings.json is now the home for your status line, your hooks from lesson three and your permissions - keep it tidy and committed where it should be shared.

Your task

Do three things. Set up a basic custom status line that shows your model and branch. Use claude -c to resume your last session and notice the friction it removes. Then start a session in the cloud, open it in your phone's browser, and send it one instruction from there. You now run the setup serious builders use - and you have finished Course 2.

Next lesson

You are now a Claude Code power user: rules, skills, hooks, MCP, multi-agent work, context engineering and a pro setup. Course 3 moves to the modern app stack - architecture, authentication with Clerk, a reactive database with Convex, and payments with Stripe - to turn your projects into real products people pay for.