Module 2: Installation and professional setup

Available Platforms for Claude Code

Overview

Claude Code isn't just a command in your terminal. Anthropic has built an ecosystem of 5 platforms where you can use Claude Code: the terminal (CLI), a VS Code extension, a JetBrains plugin, a standalone desktop application, and the web version at claude.ai/code. On top of that, you can reach it remotely from any device via Remote Control. Each platform offers a different experience with its own advantages and limits.

The terminal is the most complete platform for terminal-native work. The web runs tasks on Anthropic cloud VMs with nothing installed on your machine. The IDE extensions bring Claude into your editor. And the desktop app offers a standalone visual experience.

In this capsule you'll get to know each platform, understand when to use each one, and make an informed decision about which will be your main entry point. You don't need to use all of them — most professional developers use 1-2 platforms as their main flow.

The 5 platforms

┌─────────────────────────────────────────────────────────┐
│                  CLAUDE CODE                            │
│                                                         │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐      │
│  │Terminal  │ │ VS Code │ │JetBrains│ │ Desktop │      │
│  │  (CLI)   │ │Extension│ │ Plugin  │ │   App   │      │
│  │ ★★★★★   │ │ ★★★★☆  │ │ ★★★★☆  │ │ ★★★★☆  │      │
│  │ complete │ │in-editor│ │in-editor│ │visual+  │      │
│  └─────────┘ └─────────┘ └─────────┘ └─────────┘      │
│                                                         │
│  ┌─────────┐                                           │
│  │   Web   │  + Remote Control (access from any        │
│  │claude.ai│    device, available on all               │
│  │  /code  │    plans)                                 │
│  │ ★★★★☆  │                                           │
│  │  cloud  │  + Chrome extension (debugging web apps)  │
│  └─────────┘                                           │
│                                                         │
│  ★ = functionality level                                │
└─────────────────────────────────────────────────────────┘

Platform 1: Terminal (CLI)

The complete experience

The terminal is Claude Code's original and most complete platform. Every new feature lands on the CLI first. It's where Claude Code has full filesystem access, can run commands, and operates with the lowest latency.

How to get in

claude

That's it. If you followed installation capsule 02, you already have it.

Features that are exclusive to — or work best in — the terminal

Full filesystem access — reads and writes any file in your project
Command execution — runs tests, builds, and linters directly
Multi-turn conversations — long sessions with accumulated context
CLAUDE.md — loaded automatically at the start of every session
Skills and Hooks — the complete extensibility surface
Subagents — launches sub-tasks in parallel
/doctor — full setup diagnostics
/model — switch models in real time
/effort — tune the depth of reasoning
/compact — compress context without losing the key information
Headless mode — programmatic use with no interactive interface (claude -p)

Interface

╭──────────────────────────────────────────╮
│ Claude Code v2.x.x                       │
│                                          │
│ Project: /Users/you/my-project           │
│ Model: Opus 5                            │
│ /help for available commands             │
╰──────────────────────────────────────────╯

> Your message here...

Limitations

No graphical interface — everything is text
No inline previews of images or diagrams
Requires terminal familiarity
Diffs are shown as text, without the visual highlighting an IDE gives you

When to use it

Whenever you can. It's the most complete and fastest experience.
Especially for: long development sessions, refactoring, code review, codebase analysis, automation.
If you can only pick one platform, pick the terminal.

Platform 2: VS Code extension

Claude Code inside your editor

The VS Code extension puts Claude Code in a side panel of your editor. You can talk to Claude while you look at your code, your files, and your terminal — all in the same window.

How to install it

Open VS Code
Go to Extensions (Ctrl+Shift+X / Cmd+Shift+X)
Search for "Claude Code" (publisher: Anthropic)
Click "Install"
The extension shows up as an icon in the sidebar

Alternatively:

code --install-extension anthropic.claude-code

Features

Side panel — Claude Code lives in the VS Code sidebar
Editor context — Claude can see which file you have open
Code selection — select code, right-click → "Ask Claude"
Visual diffs — changes are shown in VS Code's native diff viewer
Integrated terminal — Claude runs commands in the VS Code terminal
Inline edits — Claude can edit files directly, with a preview
File tree awareness — it knows your project structure through VS Code

Interface

┌──────────────────────────────────────────────┐
│ VS Code                                       │
│ ┌──────────┬──────────────────┬─────────────┐ │
│ │ Explorer │   Editor         │ Claude Code │ │
│ │          │                  │             │ │
│ │ src/     │  function foo()  │ > "Explain  │ │
│ │ tests/   │    return bar    │   this      │ │
│ │ ...      │                  │   function" │ │
│ │          │                  │             │ │
│ │          │                  │ Claude:     │ │
│ │          │                  │ "foo() does │ │
│ │          │                  │  ..."       │ │
│ └──────────┴──────────────────┴─────────────┘ │
└──────────────────────────────────────────────┘

Limitations compared to the terminal

Some advanced features may lag behind (they arrive later)
The side panel has less room than a full-screen terminal
The multi-turn experience can feel more cramped in a panel
Some slash commands may not be available right away

When to use it

When you want to see code and talk to Claude without switching windows
For explanation tasks: "What does this function do?"
For quick fixes: select code → "Fix this bug"
If VS Code is your main editor and you want to minimize context switching
A natural complement to the terminal for visual tasks

Platform 3: JetBrains plugin

Claude Code in IntelliJ, WebStorm, PyCharm...

The JetBrains plugin brings Claude Code to the JetBrains ecosystem: IntelliJ IDEA, WebStorm, PyCharm, GoLand, Rider, and other IDEs in the family.

How to install it

Open your JetBrains IDE
Go to Settings → Plugins → Marketplace
Search for "Claude Code"
Click "Install"
Restart the IDE
Claude Code shows up as a tool window

Alternatively, install it from the JetBrains Marketplace.

Features

Tool window — Claude Code in a panel inside the IDE
Editor context — access to the active file and your selection
Refactoring integration — Claude's changes are applied through JetBrains' refactoring system
Integrated terminal — run commands from the IDE
Navigation — Claude can reference classes and methods that JetBrains has indexed

Compatible IDEs

IDE	Typical use
IntelliJ IDEA	Java, Kotlin, Scala
WebStorm	JavaScript, TypeScript
PyCharm	Python
GoLand	Go
Rider	C#, .NET
PhpStorm	PHP
CLion	C, C++
RubyMine	Ruby

Limitations compared to the terminal

Feature lag — new functionality lands on the CLI first
Dependence on the JetBrains ecosystem (a paid license for most IDEs)
The panel has the same space constraints as VS Code
Some agentic workflows may not be optimized for the plugin's interface

When to use it

If JetBrains is your main IDE and you don't want to leave it
For Java/Kotlin projects where IntelliJ is the standard
When JetBrains' refactoring system adds value (rename, extract method, etc.)
A complement to the terminal, not a replacement

Platform 4: Desktop app

A standalone application

The Claude Code desktop app is an independent application (built on Electron) that gives you Claude Code in its own window, with no terminal or IDE open.

How to install it

Download it from claude.ai/download
Install the application (drag it to Applications on macOS, or run the installer on Windows/Linux)
Open it and authenticate with your Anthropic account

Features

A dedicated interface — its own window, no distractions
Filesystem access — it can navigate and edit files in your project
Command execution — embedded terminal
Diff viewer — visual review of changes with better rendering than the terminal
App preview — preview web applications right inside the app
Computer Use — Claude can open apps and control your screen on macOS (available on Pro and Max)
Dispatch — start Desktop sessions from the Claude mobile app, without sitting at your computer
Parallel sessions — run multiple sessions side by side
Scheduled tasks — schedule recurring tasks that run on your machine
System notifications — alerts when Claude finishes long tasks

Limitations compared to the terminal

Consumes more resources (RAM, CPU) than a terminal
Doesn't have the scripting flexibility the terminal offers
Doesn't integrate with your editor — it's a separate application

When to use it

If you prefer graphical interfaces over terminals
For visual review of diffs and changes
For dedicated planning sessions with Claude
When you want Computer Use to interact with desktop apps
For users who aren't comfortable in the terminal

Platform 5: Web (claude.ai/code)

Claude Code in the cloud

Claude Code on the web runs tasks on cloud VMs managed by Anthropic. It clones your GitHub repository, sets up a secure environment, and runs code, tests, and commands — all without installing anything on your machine. Currently in research preview.

How to get in

Go to claude.ai/code
Connect your GitHub account
Install Claude's GitHub App on your repositories
Send your task — Claude clones the repo and works in the cloud
Review the changes in the diff viewer and open a PR

You can also start web sessions from your terminal with claude --remote "your task".

Features

No local installation — your code runs on Anthropic's VMs
Clones your repo — full access to your repository's files
Runs commands — runs tests, builds, and linters in the cloud environment
Reads CLAUDE.md — it respects your project's instructions
Diff viewer — review changes visually before opening a PR
PR auto-fix — Claude watches CI failures and review comments, and pushes fixes automatically
Parallel tasks — launch multiple tasks that run simultaneously
Keeps going after you close — tasks keep running even if you close your laptop
Mobile access — available in the Claude app for iOS and Android
Session sharing — send a link to a colleague so they can watch your session

Limitations compared to the terminal

No access to your local filesystem — it works with a cloud clone of your repo, not your local files
GitHub only — it only works with repos on GitHub (including GitHub Enterprise Server for Team/Enterprise)
No local MCP servers — no access to your MCP servers or local tools
Environment setup — it may need a setup script for specific dependencies
Research preview — the platform is in preview and evolves fast

When to use it

Tasks that don't need constant supervision — bug fixes, well-defined implementations
Repos you don't have locally — work on code without cloning it to your machine
Parallel work — launch several tasks at once while you work on something else
From any device — start tasks from your phone or any browser
PR auto-fix — let Claude respond to CI failures and review comments automatically

Terminal vs web: a different execution model

Terminal (local):
→ Claude operates on YOUR machine, YOUR files, YOUR tools
→ Real-time interaction, you supervise every step
→ Access to MCP servers, local tools, and your whole environment

Web (cloud):
→ Claude operates on a cloud VM with a clone of your repo
→ Asynchronous: you launch the task and come back when it's done
→ Opens PRs directly, auto-fixes CI failures
→ Perfect for delegating and parallelizing

Remote access: Remote Control

Control your local session from any device

Remote Control isn't a separate platform — it's a way to reach a Claude Code session running on your machine from any browser or from the Claude mobile app. Your filesystem, MCP servers, tools, and local configuration all stay available, because Claude is still running on your machine.

Availability

Available on every plan: Pro, Max, Team, and Enterprise. On Team and Enterprise, an admin has to enable it first at claude.ai/admin-settings/claude-code.

How to use it

# Option 1: Dedicated Remote Control server
claude remote-control

# Option 2: Interactive session with Remote Control enabled
claude --remote-control

# Option 3: From inside an existing session
> /remote-control

Claude shows a URL and a QR code. Open the URL in any browser, or scan the QR code from the Claude app on your phone.

Features

Full access to your local environment — filesystem, MCP servers, tools, all available
Multi-device — send messages from the terminal, the browser, and your phone interchangeably
Automatic reconnection — if your laptop sleeps or the network drops, the session reconnects on its own
Monitoring — see what Claude is doing in your project
Action approval — approve or reject changes from any device

Remote Control vs web

Remote Control:
→ Claude runs on YOUR machine
→ Full access to your local environment (MCP, tools, filesystem)
→ You control an existing session from another device

Web (claude.ai/code):
→ Claude runs on Anthropic's cloud VMs
→ It works with a clone of your repo, not your local machine
→ Perfect for new tasks with no local setup

When to use it

Monitoring long tasks while you're away from your computer
Continuing a session from your phone or tablet
Approving/rejecting changes from another device
When you need access to your local environment but you're away from your desk

Moving sessions between platforms

Your Claude Code sessions aren't tied to a single surface. You can start on one and continue on another:

`--remote` — from the terminal to the web

Start a cloud session from your terminal without leaving it:

claude --remote "Fix the authentication bug in src/auth/login.ts"

The task runs in the cloud. Use /tasks to monitor it, or open the session at claude.ai/code.

`--teleport` / `/teleport` — from the web to your terminal

If you started a session on the web (claude.ai/code) or from the mobile app, you can bring it into your local terminal:

# From the command line (interactive picker)
claude --teleport

# Or inside an interactive session
> /teleport

Claude checks that you're in the right repo, fetches the remote branch, and loads the session's full history.

`/desktop` — from the terminal to the desktop app

If you're in the terminal and want to review diffs visually:

# In your terminal session
> /desktop

Claude opens the desktop app with your current session for a visual review.

Chrome extension

Claude Code has a Chrome extension (beta) for debugging live web apps. It connects your Claude Code session to the browser so you can inspect, diagnose, and fix problems directly.

Dispatch — from your phone to the desktop app

From the Claude mobile app, send a task and Dispatch runs it in the desktop app on your computer. You don't need a terminal open.

The mental model

Terminal ──--remote──▶ Web (cloud)
Web/iOS ──--teleport──▶ Terminal ──/desktop──▶ Desktop App
Phone ──Dispatch──▶ Desktop App
Terminal ◀──Chrome ext──▶ Browser
Terminal ◀──Remote Control──▶ Phone/Browser

You don't have to pick ONE platform. Use the terminal for local work, the web for cloud and parallel tasks, --teleport to pull sessions onto your machine, and Remote Control to drive sessions from any device.

Platform comparison

Feature table by platform

Feature	Terminal	VS Code	JetBrains	Desktop	Web (cloud)
File access	✅ Local	✅ Local	✅ Local	✅ Local	✅ Cloud clone
Command execution	✅	✅	✅	✅	✅ (in the VM)
CLAUDE.md	✅	✅	✅	✅	✅
Skills and Hooks	✅	✅	⚠️ Partial	✅	⚠️ SessionStart
Subagents	✅	✅	⚠️ Partial	✅	✅
Opening PRs	✅ (via git)	✅ (via git)	✅ (via git)	✅ (via git)	✅ Native
Visual diffs	Text	✅ Visual	✅ Visual	✅ Visual	✅ Visual
Computer Use	❌	❌	❌	✅ (Pro/Max)	❌
Headless mode	✅	❌	❌	❌	❌
No installation	❌	❌	❌	❌	✅
Remote Control	✅	✅	❌	❌	N/A
Offline	❌	❌	❌	❌	❌

When to use each, in short

What do you need?

├─ Full functionality, maximum performance
│  → Terminal (CLI) ★
│
├─ See code + talk to Claude without switching windows
│  → VS Code Extension (if you use VS Code)
│  → JetBrains Plugin (if you use JetBrains)
│
├─ A graphical interface without an IDE
│  → Desktop App
│
├─ Asynchronous cloud tasks, remote repos, parallel work
│  → Web (claude.ai/code)
│
├─ Control your local session from another device
│  → Remote Control (all plans)
│
└─ Delegate tasks from your phone to your Desktop app
   → Dispatch

Setup recommendation

For most developers

Primary:    Terminal (CLI) — for real work
Secondary:  VS Code Extension — for exploring code visually
Occasional: Web — for cloud tasks, remote repos, or parallel work

For JetBrains users

Primary:    Terminal (CLI) — for full agentic work
Secondary:  JetBrains Plugin — for IDE integration
Occasional: Web — for cloud tasks or parallel work

For users who prefer a GUI

Primary:    Desktop App — a dedicated graphical interface
Secondary:  Terminal (CLI) — for tasks that need the full feature set
Occasional: Web — access from any device

For teams

Everyone:   Terminal (CLI) — a consistent experience across members
CI/CD:      Headless terminal — automation in pipelines
Optional:   IDE extension — individual preference

Additional integrations

Slack integration (for teams)

Claude Code can integrate with Slack for team use. It lets you send tasks to Claude from a Slack channel and get results right there.

Useful for teams that coordinate work over Slack
It doesn't replace the terminal for development — it's for coordination
Covered in detail in Module 07 (Integrations)

GitHub Actions / GitLab CI/CD

Claude Code can run in CI/CD pipelines:

# A basic example in GitHub Actions
- name: Code Review with Claude
  run: |
    curl -fsSL https://claude.ai/install.sh | bash
    claude -p "Review the changes in this PR" --output-format json
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Use Claude Code in headless mode (claude -p) or the official GitHub Action (anthropics/claude-code-action)
Requires an API key (not OAuth)
Ideal for: automatic code review, test generation, documentation
Covered in depth in Module 07

Channels (Telegram, Discord, iMessage)

Claude Code can receive events from chat apps via Channels. When something happens (a CI failure, a Discord message), the event is pushed to a Claude Code session that can react automatically.

Scheduled tasks

Schedule recurring tasks that Claude runs automatically: morning PR reviews, dependency audits, CI failure analysis. Available in the CLI (/loop), the desktop app, and the cloud (/schedule).

Common patterns

Pattern 1: Terminal + IDE extension

The most popular setup among professionals:

1. Terminal for:
   - Long development sessions
   - Multi-file refactoring
   - Full code review
   - Running tests and builds

2. VS Code/JetBrains extension for:
   - "What does this function do?"
   - Quick fixes in the current file
   - Exploring code with Claude's help

You switch between them by task, with no friction.

Pattern 2: Terminal as primary, Desktop for reviews

1. Terminal for:
   - All active development
   - Tasks that need the filesystem + commands

2. Desktop App for:
   - Long code reviews
   - Planning sessions with Claude
   - When you want a dedicated window

Pattern 3: Web for delegated tasks, terminal for interactive work

1. Web (claude.ai/code) for:
   - Well-defined tasks you can delegate: "Fix this flaky test"
   - Parallel work: launch 3 tasks at once with --remote
   - Repos you don't have cloned locally
   - PR auto-fix (CI failures, review comments)

2. Terminal for:
   - Interactive work where you supervise every step
   - Tasks that need your local environment (MCP, tools, configs)
   - Long debugging and exploration sessions

Pattern 4: Mobile for monitoring

1. Terminal for:
   - Launching a long task: "Refactor the whole auth module"

2. Mobile Remote Control for:
   - Monitoring progress from your phone
   - Approving/rejecting changes while you're at lunch
   - Getting a notification when it's done

Pitfalls and edge cases

Pitfall 1: Not understanding the difference between web and terminal

Web (claude.ai/code):
→ Clones your repo onto a cloud VM
→ It CAN read files, run commands, run tests
→ BUT it works with a clone, not your local files
→ Changes get pushed to a branch, not to your filesystem

Terminal:
→ Operates directly on YOUR local files
→ Access to your MCP servers, tools, and full environment
→ Changes are applied directly to your project

Use the terminal for iterative local work. Use the web for tasks you can delegate and review afterward through a PR.

Pitfall 2: Expecting full parity across platforms

The terminal is always ahead. If a feature exists in the terminal but not in the VS Code extension, that isn't a bug — it's feature lag. Features roll out to the other platforms gradually.

Pitfall 3: Installing every platform "just in case"

You don't need all of them. Pick 1-2 that fit your workflow. Having 5 platforms installed doesn't make you more productive — it just adds complexity and updates to maintain.

Pitfall 4: Remote Control as your main tool

Remote Control is for monitoring and quick actions, not for development. A phone screen isn't enough to review diffs, read long stretches of code, or make architectural decisions. Use it as a complement.

Pitfall 5: Not updating the IDE extension

The VS Code and JetBrains extensions have to be updated separately from the CLI. If you update the CLI but not the extension, they can drift out of sync.

# Update the CLI (with the native installation, it updates automatically)
claude update

# Update the VS Code extension
# → VS Code Extensions → search for Claude Code → Update

# Update the JetBrains plugin
# → Settings → Plugins → Updates

Complete worked example

Scenario: a typical development day across multiple platforms

9:00 AM — Start of the day
Terminal:
> claude
> "What's left on PR #42? Summarize the comments"
→ Claude reviews the touched files and the diff

9:30 AM — Implementation
Terminal:
> "Implement the changes the reviewer asked for on PR #42"
→ Claude edits files, runs the tests, confirms they pass

11:00 AM — Reviewing a colleague's code
VS Code Extension:
→ You open your colleague's PR in VS Code
→ You select a complex function
→ "Explain what this function does and whether you see problems"

12:30 PM — Lunch, but you launched a big refactoring
Terminal (before you leave):
> "Refactor the whole notifications module to use the new event bus"

Mobile Remote Control (from your phone):
→ You monitor the progress
→ Claude asks you: "Should I delete the old NotificationService?"
→ You approve from your phone

2:00 PM — Quick question
Web (claude.ai):
> "What's the difference between cursor-based and offset-based pagination?"
→ A fast answer, no project needed

3:00 PM — Back to work
Terminal:
> "Review what you did during the refactoring and show me a summary"
→ Claude summarizes the changes it made

Practice exercises

Exercise 1: Identify your ideal platform

Answer these questions:

What's your main editor? (VS Code, JetBrains, Vim, Emacs, something else)
Are you comfortable in the terminal?
Do you need access to Claude Code from your phone?
Does your team use Slack for coordination?

How to read your answers

VS Code + comfortable in the terminal → Terminal (primary) + VS Code Extension (secondary)
JetBrains + comfortable in the terminal → Terminal (primary) + JetBrains Plugin (secondary)
Any editor + uncomfortable in the terminal → Desktop App (primary) + IDE Extension (secondary)
You need remote access → Remote Control (available on all plans) + Terminal
Your team uses Slack → Slack integration + individual Terminal

Most professional developers end up at: Terminal + 1 IDE extension.

Exercise 2: Compare terminal vs IDE extension

Open Claude Code in the terminal and in your IDE extension (VS Code or JetBrains). Run the same task in both:

"Explain the file structure of the current directory"

Compare:

Response speed
Output format
How easy it is to navigate to the files it mentions

What to look for

Terminal:

Faster response (less overhead)
Plain-text, compact output
To reach a mentioned file, you need to cd or open it manually

IDE extension:

Can be slightly slower (more layers between you and Claude)
Better-formatted output (rendered Markdown)
You can click the files it mentions to open them directly
You see the explorer next to Claude's answer

The usual conclusion: terminal to execute, IDE to explore.

Exercise 3: Try the web flow

Go to claude.ai/code, connect a GitHub repo, and ask for a simple task:

"Add input validation to the login endpoint"

Watch how Claude clones the repo, analyzes the code, makes changes, and presents you a diff. Compare the experience with doing the same thing in your local terminal.

Analysis

Web (claude.ai/code):

Clones your repo and has access to every file
Runs commands and tests in the cloud VM
Changes are pushed to a branch — you can open a PR directly
You don't need the repo cloned locally
It's asynchronous: you can close the browser and come back later

Terminal:

Operates on your local files directly
Access to your full environment (MCP servers, tools, configs)
Real-time interaction, you supervise every step
Changes are applied straight to your filesystem

Conclusion: the web is better for tasks you can delegate. The terminal is better for interactive work where you need to control the process.

Exercise 4: Set up your secondary platform

Install and configure your secondary platform (the one you picked in exercise 1). Verify it works with a simple task.

Guide

VS Code extension:

Extensions → search for "Claude Code" → Install
Click the Claude Code icon in the sidebar
Authenticate if it asks
Type: "Hi, can you see the files in my project?"
If it answers by listing files, it works

JetBrains plugin:

Settings → Plugins → Marketplace → "Claude Code" → Install
Restart the IDE
Tool Windows → Claude Code
Authenticate if it asks
Same test: "Can you see the files?"

Desktop app:

Download it from claude.ai/download
Install and open it
Authenticate
Open a project
Same test

If the test passes, your secondary platform is ready.

Summary

5 platforms: Terminal, VS Code, JetBrains, Desktop, Web — plus remote access via Remote Control
The terminal is the most complete experience for local work — every feature, full access to your environment
Web (claude.ai/code) is a complete cloud environment — it clones your repo, runs code, opens PRs, auto-fixes
IDE extensions (VS Code, JetBrains) are the best complement — visual integration without leaving the editor
The desktop app offers a diff viewer, Computer Use, Dispatch, and parallel sessions
Remote Control lets you drive local sessions from any device (all plans)
Sessions move between platforms — --remote (terminal→web), --teleport (web→terminal), /desktop (terminal→desktop)
You don't need every platform — pick 1-2 that fit your workflow
The recommendation for most people: Terminal (primary) + your IDE's extension (secondary)

Next capsule: 04 - Plans, pricing, and models — what Claude Code costs, what each plan includes, and how to optimize your investment.

Additional resources

Platforms and Integrations — The official platform comparison and when to use each one
Claude Code on the Web — The cloud environment, setup, auto-fix, and limits
Remote Control — Controlling local sessions from any device
VS Code Extension — Installation and usage guide for VS Code
JetBrains Plugin — Installation and usage guide for JetBrains IDEs
Desktop App — The desktop app, Dispatch, Computer Use, and scheduled tasks
Chrome Extension — Debugging live web apps
Channels — Pushing events from Telegram, Discord, and others into Claude Code sessions
GitHub Actions — PR automation and code review in CI/CD

← PreviousInstalling and Authenticating Claude Code Next →Plans, Pricing, and Models

Available Platforms for Claude Code

Available Platforms for Claude Code

Overview

The 5 platforms

Platform 1: Terminal (CLI)

The complete experience

How to get in

Features that are exclusive to — or work best in — the terminal

Interface

Limitations

When to use it

Platform 2: VS Code extension

Claude Code inside your editor

How to install it

Features

Interface

Limitations compared to the terminal

When to use it

Platform 3: JetBrains plugin

Claude Code in IntelliJ, WebStorm, PyCharm...

How to install it

Features

Compatible IDEs

Limitations compared to the terminal

When to use it

Platform 4: Desktop app

A standalone application

How to install it

Features

Limitations compared to the terminal

When to use it

Platform 5: Web (claude.ai/code)

Claude Code in the cloud

How to get in

Features

Limitations compared to the terminal

When to use it

Terminal vs web: a different execution model

Remote access: Remote Control

Control your local session from any device

Availability

How to use it

Features

Remote Control vs web

When to use it

Moving sessions between platforms

--remote — from the terminal to the web

--teleport / /teleport — from the web to your terminal

/desktop — from the terminal to the desktop app

Chrome extension

Dispatch — from your phone to the desktop app

The mental model

Platform comparison

Feature table by platform

When to use each, in short

Setup recommendation

For most developers

For JetBrains users

For users who prefer a GUI

For teams

Additional integrations

Slack integration (for teams)

GitHub Actions / GitLab CI/CD

Channels (Telegram, Discord, iMessage)

Scheduled tasks

Common patterns

Pattern 1: Terminal + IDE extension

Pattern 2: Terminal as primary, Desktop for reviews

Pattern 3: Web for delegated tasks, terminal for interactive work

Pattern 4: Mobile for monitoring

Pitfalls and edge cases

Pitfall 1: Not understanding the difference between web and terminal

Pitfall 2: Expecting full parity across platforms

Pitfall 3: Installing every platform "just in case"

Pitfall 4: Remote Control as your main tool

Pitfall 5: Not updating the IDE extension

Complete worked example

Scenario: a typical development day across multiple platforms

Practice exercises

Exercise 1: Identify your ideal platform

`--remote` — from the terminal to the web

`--teleport` / `/teleport` — from the web to your terminal

`/desktop` — from the terminal to the desktop app