Run Claude Code Anywhere: Desktop, Web, Teleport & Remote Control

You start a refactor in the Desktop app at your desk. Lunch arrives; you walk away and steer the same conversation from your phone on the couch. Back at the keyboard, a merge gets hairy, so you pull the whole thing into your terminal — full history, same branch — and finish the conflict by hand. One session, four surfaces, zero copy-paste.

That is not a hypothetical. Claude Code is the same engine behind a CLI, an IDE panel, a Desktop app, a browser tab, and a phone screen, and Anthropic ships explicit commands to hand a live session between them. The trick is knowing which surface runs the code, which carries your local config, and which command bridges the two. Get those three facts straight and "run it anywhere" stops being a slogan.

The five surfaces at a glance

There are five places Claude Code runs, and they split on one axis that matters more than any other — where the code executes. [V]

• Terminal CLI — runs on your machine, uses your full local config, the reference implementation every other surface mirrors.
• IDE (VS Code extension or JetBrains plugin) — runs on your machine, the same engine wearing a graphical panel inside your editor.
• Desktop app — runs on your machine for Local/SSH sessions, or on Anthropic's cloud for Remote sessions; a GUI built for parallel work, not available on Linux.
• Claude Code on the web (claude.ai/code) — runs in an Anthropic-managed cloud VM, clones a GitHub repo, pushes a branch. Research preview.
• Phone (the Claude mobile app) — never runs Claude itself; it is a window into a session running on the cloud (web) or on your machine (Remote Control).

The Desktop app, the CLI, and the IDE all share configuration on the same machine — CLAUDE.md files, MCP servers, hooks, skills, and settings — so switching between them on your laptop is seamless by default. The web is the odd one out: it only sees what is committed to the repo. That single distinction drives almost every decision in this guide.

What actually transfers between surfaces

"Transfer" hides two very different things, and conflating them is where people get burned.

Configuration is whether a given surface can see your CLAUDE.md, hooks, MCP servers, and skills. On the same machine, every local surface shares the same config files — there is nothing to transfer because they read the same paths. The cloud is the cliff edge: a web VM gets a fresh clone of your repo and nothing from your machine. Your repo's CLAUDE.md, .mcp.json, .claude/settings.json hooks, and .claude/skills/ ride along because they are in the clone. Your user-level ~/.claude/CLAUDE.md, the MCP servers you added with claude mcp add (which write to local user config), and ~/.claude/skills/ do not — they live on your machine, not in the repo. The fix is the same every time: commit it to the repo's .claude/ directory. [V]

Session state is whether the live conversation — its history, its branch, its in-progress task — comes with you. This is what --teleport and Remote Control move, and it is a separate question from config entirely.

So a session moving from web to terminal carries its conversation history and branch (state), and the moment it lands locally it gains your full machine config (because you are now on a local surface). Those are two transfers happening at once, by two different mechanisms.

The Desktop app: a GUI that runs Local, Remote, or over SSH

The Desktop app is Claude Code with a graphical interface built for running multiple sessions side by side — a sidebar for parallel work, drag-and-drop panes for an integrated terminal and file editor, visual diff review, live app preview, GitHub PR monitoring with auto-merge, and scheduled tasks. No terminal required. The app includes Claude Code, so you do not need to install Node.js or the CLI separately to use the Code tab. [V]

It has three tabs at the top center: Chat (no file access, like claude.ai), Cowork (an autonomous background agent in a cloud VM), and Code (the interactive coding assistant with direct access to your local files, where you review and approve each change). The Code tab is the one this guide cares about.

The Code tab's defining feature is the environment selector — you choose where each session runs:

• Local — runs on your machine using your files directly. Pick a folder and go. (On Windows, Git must be installed for Local sessions; most Macs include it.) [V]
• Remote — runs on Anthropic's cloud infrastructure and continues even if you close the app, using the same infrastructure as Claude Code on the web. [V]
• SSH — connects to a remote machine over SSH (your own servers, cloud VMs, dev containers). The Desktop app installs Claude Code on the remote machine automatically the first time you connect. [V]

Because Desktop runs the same engine as the CLI and shares configuration with it, you can run both simultaneously on the same project. The two read the same CLAUDE.md, MCP servers, hooks, skills, and settings. [V]

Scheduled tasks: Claude on a clock

The Desktop app can put Claude on a schedule — run it automatically on a recurring basis: a daily code review every morning, a weekly dependency audit, or a briefing that pulls from your connected tools. [V] Scheduling exists in three flavors across surfaces — Desktop scheduled tasks, the CLI's scheduled tasks, and cloud Routines (/schedule) — so a recurring job can run wherever it fits. The Desktop version is the most discoverable: pick a frequency in the UI and Claude shows up on time without you launching anything.

This is the quiet superpower of the GUI surfaces. A terminal session dies when you close the terminal; a scheduled task and a Remote/cloud session keep working while you sleep.

Claude Code on the web: a cloud VM you drive from a browser or phone

claude.ai/code runs Claude Code on Anthropic-managed cloud infrastructure instead of your machine — it is in research preview for Pro, Max, and Team users (and Enterprise users with the right seats). You submit a task from the browser or the Claude mobile app, and Claude does the rest. [V]

Two hard requirements define this surface:

1. You need a GitHub repository. Claude clones it into an isolated VM, makes changes, runs tests, and pushes a branch for you to review. To start a brand-new project you create an empty repo on GitHub first. [V]
2. You connect GitHub once, either by installing the Claude GitHub App during browser onboarding, or by running /web-setup in your terminal to sync your local gh CLI token to your Claude account. (The GitHub App is what enables Auto-fix, which receives PR webhooks.) [V]

The lifecycle is clone → configure network → work → push the branch. The session does not close when the branch is pushed: PR creation, inline review comments, and further edits all happen in the same conversation. And because sessions persist across devices, a task you start on your laptop is ready to review from your phone later — the same session, with a computer icon and a green status dot when it is online. [V]

What it is good at: parallel independent tasks (each its own session and branch, no worktree juggling), repos you do not have checked out locally, well-defined tasks that do not need constant steering, and code exploration. What it is not for: work that needs your local config, tools, or environment — for that, run locally or use Remote Control. [V]

Teleport: pull a cloud session down into your terminal

Here is the bridge that makes the whole thing feel like one session. A task running in the cloud is great until you hit something a browser is bad at — a tricky merge, a flaky local-only dependency, a debugger you want in your own terminal. --teleport pulls that cloud session onto your machine and lets you keep going locally.

From the command line, claude --teleport opens an interactive picker of your cloud sessions, or claude --teleport <session-id> resumes a specific one directly. Inside an existing CLI session, /teleport (alias /tp) opens the same picker without restarting. From /tasks, press t to teleport into a background session. [V]

When you teleport, Claude verifies you are in the correct repository, fetches and checks out the branch from the cloud session, and loads the full conversation history into your terminal. The branch and the entire conversation come with you. [V]

And here is the part people miss: the moment that session lands locally, it is running on a local surface — so it now reads your CLAUDE.md and your MCP servers and your full machine config, none of which the cloud VM had. Teleport transfers session state; arriving on your machine grants local config. You get both at once.

Remote Control: drive a local session from your phone

Teleport moves a cloud session to your machine. Remote Control is the mirror image: it keeps a session running locally the whole time and lets you drive it from claude.ai/code or the Claude mobile app. Nothing moves to the cloud — your filesystem, MCP servers, tools, and project config all stay available, and @ still autocompletes paths from your local project. The web and mobile interfaces are just a window into that local session. [V]

You start it with claude remote-control (server mode). The process stays running in your terminal waiting for connections, prints a session URL, and you press spacebar to show a QR code for instant phone access. Give it a readable name with --name "My Project" so you can find it in the session list at claude.ai/code. [V]

# Server mode — waits for remote connections, shows a URL + QR
claude remote-control --name "Payments refactor"
 
# Or enable it on a normal interactive session you can also type into locally
claude --remote-control "Payments refactor"
 
# Or, already mid-session, hand the live conversation to your phone
/remote-control Payments refactor

The conversation stays in sync across all connected devices — terminal, browser, and phone, interchangeably — and survives interruptions: if your laptop sleeps or the network drops, the session reconnects automatically when your machine comes back. When a long task finishes or Claude needs a decision, it can send a push notification to your phone (you can also ask "notify me when the tests finish" in the prompt). [V]

Two boundaries to respect. Remote Control runs as a local process: if you close the terminal or quit the claude process, the session ends. And it makes outbound HTTPS only — it never opens an inbound port on your machine, registering with the Anthropic API and polling for work, so the security posture is the same as any other Claude Code session. [V]

The two IDE surfaces are not the same — the bundled-CLI gotcha

Both major IDE integrations give you Cmd+Esc (Mac) / Ctrl+Esc (Windows/Linux) to summon Claude from the editor, a native diff viewer, automatic selection context, and the mcp__ide__getDiagnostics tool that hands Claude the errors and warnings from your language server. [V] But under the hood they install Claude Code in opposite ways, and that one difference causes most "it works in the panel but not in my terminal" confusion.

The VS Code extension bundles its own private copy of the CLI for the chat panel. That is why the panel works the instant you install the extension — no separate setup. But installing the extension does not put claude on your shell PATH. To run claude in VS Code's integrated terminal (for CLI-only features, claude mcp add, claude --resume), you need the standalone CLI install as well. Two pieces, installed separately. [V]

The JetBrains plugin bundles nothing. It runs the claude command in your IDE's integrated terminal and connects to it, so you must install both the CLI and the plugin — the plugin shows a "Cannot launch Claude Code" notification when claude is not on your PATH. The plugin supports IntelliJ IDEA, PyCharm, Android Studio, WebStorm, PhpStorm, and GoLand, among others. [V]

The practical upshot: in VS Code the panel is self-sufficient but the terminal needs the standalone CLI; in JetBrains there is no panel-vs-terminal split because the plugin is the terminal CLI with IDE wiring on top. If you connect Claude from an external terminal to either IDE, run /ide inside Claude Code to link them. [V]

Senior scenario: Desktop draft → teleport into the terminal for a nasty merge

You are shipping a database migration on a Friday. You kick it off in the Desktop app, Code tab, Remote environment — Anthropic's cloud, so it keeps running while you grab coffee and step into a meeting. From your phone you watch the diff grow and leave an inline comment on migrations/0042_add_index.sql: "keep this idempotent." Claude pushes a branch.

Back at your desk, you want to merge that branch into main — but main has moved, and there is a gnarly conflict in a file your local dev environment validates with a tool that does not exist in the cloud VM. The browser is the wrong place to resolve this. So you teleport.

You make sure your working tree is clean, confirm you are in the right repo checkout, and pull the session down:

git status            # clean tree — teleport requires it (or it'll offer to stash)
claude --teleport     # pick the cloud session from the interactive list

Claude fetches and checks out the cloud branch, loads the entire conversation history — including your phone comment about idempotency — and now you are on a local surface: your CLAUDE.md, your MCP servers, your local validation tool, all present. You resolve the conflict by hand in your editor with the full context of why the migration looks the way it does, run the local validator, and ship.

That is the payoff of thinking in surfaces. The cloud handled the unattended grind. Your phone handled the glance-and-steer. The terminal handled the thing terminals are best at. One session — it just changed clothes three times. [P]

The one habit that makes all of this work

Decide where the code should run, then pick the surface that runs it there — and commit anything the cloud needs to the repo. Hands-on work with your real tools? Stay local: CLI, IDE, or Desktop-Local, all sharing one config. Unattended grind, or a repo you have not cloned, or many tasks at once? Push it to the cloud: Desktop-Remote or the web, where only committed config survives. Need to glance and nudge from the couch? Remote Control turns your phone into a window onto the local session. Hit a wall the browser is bad at? --teleport drops the whole thing — branch and history — into your terminal, where it instantly inherits your machine.

The surfaces are not five different tools. They are five doors into the same Claude Code, and the bridges between them (--remote, --teleport, remote-control, /ide) are first-class commands, not afterthoughts. Learn the doors, and "run it anywhere" is just Tuesday.