IDE, Desktop, Web & Chrome Integrations

The single most important idea in this lesson: there is only one Claude Code. The terminal CLI, the VS Code / JetBrains / Cursor extensions, the desktop app, web sessions at claude.ai/code, and Chrome automation are all surfaces over the same agentic engine. They differ in where the conversation is rendered and what extra affordances they give you (inline diffs, a visual session list, a scheduler, a browser), not in how Claude thinks.

The practical payoff is that your configuration is portable by default. The same CLAUDE.md hierarchy, the same .claude/settings.json rules and hooks, and the same MCP servers load and behave identically no matter which surface you launch from. You do not re-learn the tool per surface, and you do not maintain parallel configs. Learn the engine once; pick the surface that fits the moment.

            ┌──────────── ONE ENGINE ────────────┐
            │  agentic loop · tools · context     │
            └───────────────┬─────────────────────┘
   ┌──────────┬─────────────┼─────────────┬──────────────┐
Terminal   IDE ext.    Desktop app    Web (claude.ai)   Chrome
  CLI    (VS Code /   (visual diffs,  (--remote,        (browser
         JetBrains/   scheduler,      Remote Control)   automation)
         Cursor)      multi-session)
   └──────────┴─────────────┴─────────────┴──────────────┘
        shared: CLAUDE.md · settings.json · MCP servers

Because the surfaces share state, moving work between them is a first-class feature rather than a copy-paste chore — and the rest of this lesson is mostly about the small set of commands that do the moving.

The IDE integrations put Claude Code beside your editor so diffs render inline, your active selection becomes context, and edits land in files you can see. Three editor families are supported:

There are two ways to run with an IDE connected. You can launch Claude from the editor's integrated terminal, or run the CLI with the --ide flag:

claude --ide

--ide auto-connects to your IDE if exactly one valid IDE is detected. If zero or several are found, it does not guess — you connect manually instead. To check the state of the connection at any time, run the slash command:

/ide

/ide manages IDE integrations and shows status — which editor is attached, or that none is. When connected, Claude can read your current selection and open files, and proposed edits appear as reviewable diffs in the editor rather than as terminal text.

The engine is still the engine: your project CLAUDE.md, settings, hooks, and MCP servers all load exactly as they would in a bare terminal. The IDE adds presentation and context plumbing, not a different brain.

Claude Code ships a native desktop app for macOS and Windows. It was redesigned and released on April 14, 2026, and it is built for the work that a single terminal pane does poorly: reviewing changes visually and juggling several agents at once. Its headline capabilities:

• Visual diff review — inspect Claude's proposed changes as rendered diffs and approve or reject them, rather than scanning a wall of terminal output.
• Multi-session management — see all your running and recent sessions in one place and switch between them, instead of remembering which terminal tab holds which task.
• Scheduled tasks — set Claude Code work to run on a schedule, so routine jobs happen without you babysitting a prompt.

The desktop app is also a handoff destination. From inside any terminal session you can run:

/desktop

This continues the current session in the Claude Code Desktop app (alias /app). It carries the conversation over, so a task you started typing in the terminal can finish in the app's visual review UI. As with every surface, it requires macOS or Windows and a Claude subscription, and it loads the same CLAUDE.md, settings, and MCP servers.

Claude Code runs on the web at claude.ai/code — full agentic sessions in the browser, no local terminal required. There are two distinct ways the terminal and the web connect, and they point in opposite directions. Keep them straight:

1. Start a new web session from the terminal — --remote. This creates a fresh session that lives on the web:

claude --remote "Fix the login bug"

The work runs as a web session on claude.ai; your terminal is just the launcher. Use it to kick off cloud-hosted work and then walk away from the laptop.

2. Drive a local session from the web — Remote Control. This makes a session running on your machine controllable from claude.ai (or the app), so you can steer it from another device:

claude --remote-control "My Project"   # flag form, alias -rc

/remote-control                          # from inside a running session; alias /rc

/remote-control makes this session available for remote control from claude.ai. There is also claude remote-control [name], which runs a Remote Control server without starting a local interactive session at all.

A nice touch that shows the surfaces really are connected: when Remote Control is attached, even cosmetic state syncs — set the prompt bar color with /color blue locally and it updates on claude.ai/code too.

Remote Control lets the web reach into a local session. Teleport does the reverse: it pulls a web session down into your terminal, fetching both the branch and the conversation so you can continue locally with full tooling.

Use either the flag at launch or the slash command from inside a session:

claude --teleport

/teleport            # alias /tp

/teleport opens a picker, then fetches the branch and conversation for the chosen web session into the current terminal. It requires a claude.ai subscription. The typical loop: start something on the web (or on your phone) with --remote, let it run, then teleport it down to your dev machine when you want to take over with local builds, tests, and debuggers.

That completes the round-trip across surfaces:

  --remote  ─────────────▶  Web session (claude.ai/code)
 (terminal launches)              │
                                  │ --teleport / /teleport (/tp)
                                  ▼
                         Terminal (local tooling)
                                  │ /desktop (/app)
                                  ▼
                         Desktop app (visual review)

Notice that work flows freely in every direction — and because the engine and config are shared, nothing is lost in the move: same branch, same conversation, same CLAUDE.md, same MCP servers.

The Chrome integration lets Claude Code drive a real browser — navigating pages, clicking, filling forms, and taking screenshots — which makes it useful for web automation and for testing UI changes against a running app. Control it with a flag at launch or the slash command in-session:

claude --chrome        # enable Chrome integration
claude --no-chrome     # explicitly disable it

/chrome                # configure Claude in Chrome settings

The classic workflow: make a frontend change, then have Claude open the page in Chrome, interact with it, and screenshot the result to verify the change looks right — closing its own verification loop instead of waiting for you to eyeball it.

There is one real cost to respect. Browser screenshots are large and drain tokens fast. Each screenshot is stored in the session at full resolution, and they accumulate — a long automation run can balloon context, slow responses, and in extreme cases cause errors on resume. Treat screenshots as a budgeted resource: capture them only when you need visual confirmation, and /clear or /compact a screenshot-heavy session before it bloats.

All of the movement above only works cleanly because the surfaces sit on one foundation. Three things are shared and behave identically everywhere:

The consequence is a clean operating model: configure once, work anywhere. You are not maintaining a desktop config and a separate terminal config; you are not re-approving the same permissions per surface; you are not wondering whether a hook will fire on the web. Set it up where it belongs in the hierarchy, and every surface inherits it.

A small but important caveat: surface availability still depends on your platform, plan, and environment. /desktop shows only on macOS/Windows with a subscription; teleport and Remote Control need claude.ai auth. The engine and config are uniform; which doors are open depends on where you stand.