Run Claude Code Unattended: Auto Mode, /goal, Routines, and Claude in Chrome

Module objectives:

• Get a working Claude Code session with the right access in place
• Cut approval prompts to near-zero without disabling safety checks
• Define a finish line that Claude must reach before it stops
• Repeat a task automatically on a schedule

The features in this guide assume a current Claude Code install and a paid Claude plan. Three quick prerequisites before any of the slash commands below will work:

1. Install or update the Claude Code CLI. Newer features (auto mode, /goal, /schedule Routines) only exist in recent versions, so update before you begin:

npm install -g @anthropic-ai/claude-code@latest

1. Confirm a paid plan. Auto mode, Routines, Connectors, and Claude for Chrome are paid-plan features (Pro, Max, Team, or Enterprise). The free tier will not expose them.

1. Run commands inside a session. Start Claude Code in your project folder, then type the slash commands at its prompt — they are not shell commands:

claude

Check your version any time with claude --version. With that in place, the rest of this module turns a normal interactive session into one that keeps working on its own.

Out of the box, Claude Code pauses constantly to ask permission before it edits files or runs commands. For a long task you are not babysitting, that is the single biggest reason it stalls. The old answers were both bad: either approve every step by hand, or launch with --dangerously-skip-permissions and disable the guardrails entirely.

Auto mode is the middle setting, and it is the one Anthropic's own engineers recommend for unattended work. A classifier watches every action Claude proposes. Anything routine — reading files, editing code, running a build — is approved automatically. Anything the classifier judges to be irreversible, destructive, or aimed outside your environment (mass file deletion, pushing secrets, exfiltrating data) still stops and waits for you.

You switch modes with Shift+Tab, which cycles through the permission modes in order: default → accept edits → plan → auto. Watch the indicator at the bottom of the terminal until it reads "auto mode" — depending on your starting mode that is usually two or three presses, not a fixed "press twice."

Correction vs. the video: The walkthrough says "Shift+Tab twice." The number of presses depends on which mode you start in, because Shift+Tab cycles through four modes. Read the indicator instead of counting presses.

A normal prompt runs once and stops when Claude decides it is finished. That decision is often premature. The /goal command flips the logic: you state the condition that defines "done," and Claude keeps taking turns until that condition is satisfied.

/goal

After you enter the command, you type the done-condition in plain English — for example, "every test in the suite passes and the lint check is clean." Claude works turn after turn, and a small fast evaluator model (Haiku by default) checks the conversation after each turn to decide whether the goal has been met.

Correction vs. the video: The walkthrough describes a "second independent agent that audits the work." In reality the evaluator is a lightweight model that judges only what Claude has already surfaced in the conversation — it does not run its own tools or independent tests. So make your done-condition observable in the transcript (e.g. ask Claude to print test output), or the evaluator cannot confirm it.

/goal defines the finish line for one run. To repeat a task, you have two tools:

• /loop re-runs a prompt on a time interval inside your live session. It is good for short bursts while you are at the machine, but it dies the moment you close the terminal.
• Routines run in Anthropic's cloud on a schedule, even with your computer off. The command is /schedule — there is no /routines command despite the feature's name. Routines can also be triggered by the API or a GitHub webhook, with a minimum interval of one hour.

Correction vs. the video: The walkthrough calls this /routines. The actual command is /schedule, and the big advantage over /loop is that Routines execute in the cloud rather than depending on your terminal staying open.

The clean pattern: a Routine sets the cadence ("run every morning"), and a /goal inside it defines completion ("when my inbox is empty and every message is filed"). Combined with auto mode, the job fires, works to completion, and only interrupts you for genuinely risky actions.

---

Module objectives:

• Spend more reasoning effort only on tasks that need it
• Stop plans from being lost when context is compacted
• Understand what ultracode actually orchestrates

Quality on large tasks degrades for two reasons: context rot (long conversations bloat the window until Claude can no longer hold every detail) and too little reasoning budget for the size of the problem.

The /effort command sets how many tokens Claude spends thinking. The levels are low, medium, high, xhigh, and max (availability depends on the model). Higher effort costs significantly more tokens, so reserve xhigh and max for problems that genuinely require deep reasoning. For a closer look at when the top setting actually pays for itself, see our guide on Max Thinking Mode in Claude Code: When to Use It and What It Costs.

/effort high

ultracode is the next step up, and it is a documented setting rather than just another effort level (see Anthropic's /effort and dynamic-workflows docs at code.claude.com/docs). Turning it on pins effort to xhigh and lets Claude author and run its own multi-agent workflows for the task.

/effort ultracode

Use it on jobs that are genuinely too large for one pass. For example, with ultracode on you can give a single instruction like "audit every API route in app/api for missing auth checks and write up each finding," and Claude will fan the work out across subagents instead of grinding through it serially in one window. Because it burns far more tokens than high, save it for that class of task.

When a job is too big for a single context window, ultracode lets Claude write a bespoke workflow: it spins out a team of subagents, each in its own fresh context, coordinated by your main session acting as the orchestrator. A deep-research job might fan out four agents to gather sources and a fifth to synthesize them; a review job might have one agent make claims and a second try to refute them. Because each subagent has a clean window, none of them suffers context rot and the original objective is never buried.

Correction vs. the video: The walkthrough says these follow "six commonly used workflow patterns that Anthropic documents." Anthropic's "Building effective agents" post actually documents five: prompt chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer. The Claude Code dynamic-workflows feature can script subagent orchestration but does not enumerate a fixed "six patterns" list.

Plan mode (reached with Shift+Tab) makes Claude draft an approach and stay read-only until you approve it. It is still solid advice for most non-trivial tasks. The catch the video raises is real in spirit: a plan that lives only in the conversation gets diluted once the context is compacted, and Claude loses track of where it is.

The fix is good practice, not a hidden feature: write the plan into a file inside your project (for example docs/plan.md) and tell Claude to update it as it goes. That gives Claude a durable checklist it can re-read after any compaction.

Correction vs. the video: There is no official "throwaway plans folder" that Claude saves to and then loses. That detail conflates plan mode with how dynamic-workflow scripts are stored. The takeaway — persist the plan in your repo — is sound regardless.

---

Module objectives:

• Dispatch and check on tasks from your phone
• Understand the session-lifetime limits of each method
• Choose between a cloud-native option and a VPS

Two built-in ways reach a running session from elsewhere:

• Remote Control (research preview) pairs your terminal with the Claude mobile app or claude.ai/code. Run the command and scan the QR code:

claude remote-control

The limitation is real: if the machine cannot reach the network for roughly ten minutes, the session times out and the process exits.

• Channels forwards messages between a running local session and Telegram, Discord, or iMessage — about five minutes to set up. It also only works while the local claude process keeps running; close the terminal and the work stops.

Both are great for checking in on or nudging a session, but neither keeps work alive on its own.

The video's fix is to rent a cheap VPS (around $15/month) and pair Channels with tmux (a terminal multiplexer that keeps a session alive after you disconnect). That still works, and it is worth it if you need a persistent always-on box you fully control.

Correction vs. the video: Treat the tmux + VPS route as a legacy workaround, not the default. Anthropic now ships cloud-native options that remove most of the need for it:

- Routines (/schedule) run in the cloud with your computer off — covered in Module 1.

- Claude Code on the web runs sessions in Anthropic's cloud.

- Headless mode (claude -p "your prompt") and the Agent SDK let you script unattended runs from any always-on server or CI job.

Reach for the VPS when you need a long-lived interactive environment with your own tools installed; reach for Routines or headless mode when you just need a job to run on a schedule.

---

Module objectives:

• Connect Claude to the apps you already use with zero code
• Let Claude operate a real browser on your behalf
• Know the current, accurate availability of each

In the Claude desktop app, open Customize → Connectors. You get a directory of pre-built integrations you authorize once with your normal login, then drive in plain English. Anything not in the directory can be wired up with a custom connector pointing at a remote MCP (Model Context Protocol) server, which is the open standard these integrations are built on.

Correction vs. the video: The walkthrough says "hundreds" of connectors. The curated directory listed over 50 integrations as of early 2026 — a large catalog, but not hundreds. Also note these are Claude.ai / desktop connectors, which are distinct from Claude Code's own MCP setup, even though both use MCP underneath.

Claude can now operate your browser directly: it reads the page, decides which buttons to click, types into fields, takes screenshots as it goes, manages tabs, and can even read the console. This is the answer for clunky internal or enterprise apps that have no API — you describe the goal and Claude works out the steps by looking at the screen, the way a person would.

A simple real example: "Open my community at school.com/scrapes, read every member post from the last 24 hours, and give me a priority list in three groups — needs me today, can wait, and wins to celebrate — one line each. Do not reply to anything." Claude visits the site, screenshots the posts, and returns a triaged digest with direct links, without sending a single message.

Correction vs. the video: The walkthrough calls this a "research preview, macOS first." As of 2026 Claude for Chrome is in beta on all paid plans (Pro, Max, Team, Enterprise) and is Chrome-only on desktop — there is no macOS-first restriction. It is still slower than a native API integration, so prefer a Connector or MCP server when one exists and save browser control for apps that have no other way in.

Each module builds on the last. Auto mode and /goal keep a task running to completion. /effort and ultracode hold quality on big jobs. Routines and headless mode get the work off your laptop. Connectors and Claude for Chrome extend Claude's reach into every app you touch. Combine them and you get close to the original promise: repetitive work running across your tools — your ops, outreach, and admin — while you are doing something else.

Start small. Turn on auto mode today, wrap one daily task in a /goal, then move that task to a Routine once you trust it. Add Connectors and browser control only when a real workflow needs them. Build the autonomy up one layer at a time, exactly the way these features are designed to stack.

For more of the lesser-known capabilities that round out an unattended setup, see our companion guide, Hidden Claude Code Features in 2026: Auto Dream, No-Flicker, Computer Use and More.