How to Kick Off a Coding Task During Your Commute

It's 8:40am. You're on the train, 45 minutes from the office. You know exactly what needs doing today — migrate the API client to the new auth flow, write the tests, update the types. Instead of waiting until you're at your desk, you open Grass on your phone, connect to the agent running on your home machine, describe the task, and hit send. By the time you arrive, Claude Code has already read the relevant files, drafted the migration, and is waiting on your approval to write the first batch of changes.

TL;DR

• Grass lets you start and direct a coding agent session from your phone — no laptop required
• Describe the task in natural language in the Grass chat interface; the agent starts working immediately
• Agent approval gates surface as permission modals on your phone while you're in transit
• The session persists on your machine; you pick it up on your laptop when you arrive
• Works over Tailscale for remote access, or locally if your phone and machine are on the same network

Why starting a task from mobile is harder than it sounds

The default workflow for starting a Claude Code session is: open a terminal, cd into the project, run claude with a prompt. That requires a keyboard. On a phone, even if you could SSH into your machine and type out a long prompt in a terminal, you'd be fighting autocorrect and a cramped keyboard for every character.

The other problem is continuity. If you start a task over SSH from your phone and your connection drops mid-commute — a tunnel, a network handoff, a dead zone — the session may terminate. You'd arrive at your desk to find the agent never got started, or stopped partway through.

Grass solves both problems. It gives you a mobile-native chat interface for describing tasks to the agent, and the session runs persistently on your machine regardless of whether your phone is connected.

How Grass handles task initiation from mobile

The Grass chat interface is the same interface you use to monitor a running session — but it also accepts new prompts. When you type a message and send it, Grass posts it to the active session as a user prompt. The agent treats it identically to a prompt you'd type in the terminal.

For starting a fresh session from your phone:

1. The Grass CLI needs to already be running on your machine — grass start should be running before you leave the house, or on a remote server that's always on.
2. Open the Grass app, connect to your server, select the repository.
3. Tap the + button to start a new session, or select an existing session to continue it.
4. Type your task description in the chat input and send. The agent starts immediately.

The agent's output streams to your phone in real time. If it hits an agent approval gate — a file write, a bash command — a permission modal appears on your phone. One tap to approve. The agent continues. You go back to looking out the window.

How to write a good task prompt from your phone

A task prompt typed on a phone doesn't need to be a detailed specification. Claude Code is good at inferring scope from a brief description if the codebase context is clear. A few patterns that work well from mobile:

Be specific about the starting point. Instead of "refactor the auth module," try "look at src/auth/client.ts and migrate it to use the new AuthV2 interface in src/auth/types.ts." Giving the agent a concrete file to start from reduces the time it spends exploring before acting.

State the output you expect. "Write the migration, update the tests in src/auth/__tests__/, and open a summary of what you changed." The agent knows what done looks like and won't keep running indefinitely.

Use a follow-up if the first prompt was too vague. You can send additional messages mid-session. If the agent starts going in the wrong direction, send a correction from your phone and it will adjust.

Step-by-step: starting a coding task from your phone

1. Before you leave: Run grass start in your project directory (or its parent). Confirm the QR code appears and the server is running. If you're using a remote machine, grass start --network tailscale generates a QR code using your Tailscale IP for access outside your home network.
2. Scan the QR code with the Grass app. iOS App Store (native) or Android PWA. The server connection is saved — next time you just tap it.
3. Select your repository and agent. Tap the server, pick the repo, choose Claude Code or OpenCode from the inline agent picker.
4. Start a new session. Tap the + button in the sessions list.
5. Type your task and send. Describe what you want the agent to do. Keep it specific — file paths, interface names, expected output.
6. Handle approval gates as they appear. Permission modals surface on your phone. Approve or deny with one tap.
7. Arrive at your desk and pick up in the terminal. The session is running. Use claude --continue to resume in the terminal if you want to take over, or keep directing from the Grass app.

What you need

• Grass CLI running before you leave — npm install -g @grass-ai/ide, then grass start in your project directory. Requires Node.js 18+.
• Grass mobile app — iOS App Store (native) or Android PWA
• Claude Code or OpenCode — installed and authenticated on your machine
• Network access — same WiFi as your machine, or Tailscale for remote access during transit
• Alternatively: a remote server — running Grass on a transient dev server like Daytona means your laptop doesn't need to stay on at all

Frequently asked questions

Can I start a completely new Claude Code session from my phone, or only continue existing ones?

You can start new sessions from the Grass app. Tap the + button in the sessions list for a repository, type your prompt, and the agent starts a fresh session. You're not limited to continuing sessions that were already running — Grass can initiate them from scratch.

What if my phone loses connection mid-commute while the agent is running?

The agent keeps running on your machine regardless of your phone's connection state. Grass uses SSE with sequence-numbered frames and Last-Event-ID replay, so when your phone reconnects it catches up on everything the agent did while you were in a dead zone. No output is lost, and no approval gates are missed — they'll surface as pending modals when you reconnect.

How do I make sure the agent doesn't do something I'd regret before I can review it?

Claude Code runs in default permission mode, which means it pauses and waits for your approval before writing files, running bash commands, or fetching URLs. These approval requests surface as modals in the Grass app. If you're in a tunnel and miss one, it just waits — the agent doesn't proceed without your sign-off. You can also send a message like "ask me before making any file changes" at the start of the session to set expectations explicitly.

Does this work if my laptop is closed or sleeping?

No — if your laptop is closed and sleeping, grass start isn't running and the agent isn't running. The solution is to either keep your laptop awake (lid open, sleep disabled) or run on a remote machine that's always on. A transient dev server like Daytona is purpose-built for this: the agent runs in the cloud, your laptop stays off, and Grass on your phone connects to the Daytona workspace via grass start --network remote-ip.

Can I use Grass to start tasks on a machine that's not at home — like a cloud server?

Yes. Run grass start --network tailscale on the remote machine to generate a QR code using its Tailscale IP. As long as both the server and your phone are on the same Tailscale network, the connection works from anywhere. For a machine with a public IP, grass start --network remote-ip fetches the public IP and encodes it in the QR code.

What's the difference between starting a task from Grass vs using a mobile SSH client?

A mobile SSH client gives you a raw terminal — you're typing commands in a small input box, fighting autocorrect, managing the SSH connection yourself. Grass gives you a chat interface designed for mobile: larger input, no SSH management, and agent output rendered as markdown with syntax highlighting rather than raw terminal text. Permission modals appear automatically rather than requiring you to watch the terminal for prompts. For agent-specific workflows, Grass is significantly less friction.

Related use cases

Monitor a long-running coding agent overnight — Once you've kicked off a task, this covers how to stay connected while the agent runs for hours: live output, permission modals, and session recovery after a disconnect.

Review your agent's code changes from your phone — When you arrive and the agent has finished, use the Grass diff viewer to check what it changed before continuing.

Connect Grass to Daytona — If you want the agent running even when your laptop is off, Daytona is the remote execution layer. This guide covers the full setup.