Tom Hundley
One engine, a dozen surfaces. Here's how to choose the right one, and how to move work between them.
When we first wrote this guide, Claude Code had four ways in: the terminal, the desktop app, the browser, and GitHub Actions. That framing is now too small. Claude Code runs in your terminal, inside VS Code and JetBrains, in a native desktop app, in a browser, on your phone, in CI, in Slack, and against a live Chrome tab. There's an SDK if you want to build your own front door.
The more useful question in 2026 isn't "which surface do I install?" It's "where does this particular piece of work belong, and how do I hand it off when my context changes?" This guide answers both.
Every surface connects to the same underlying engine. Your repository's CLAUDE.md, your settings, and your MCP servers work across all of them.
| Surface | Best for | Key advantage |
|---|---|---|
| Terminal CLI | Power users, scripting, CI | Full control, Unix composability |
| VS Code / Cursor | Editing with inline review | Inline diffs, @-mentions, plan review |
| JetBrains | IntelliJ, PyCharm, WebStorm users | Interactive diffs, selection context |
| Desktop app | Parallel sessions, visual review | Worktree isolation, diff comments, scheduling |
| Web and mobile | Long tasks, no local setup | Cloud infrastructure, works from a phone |
| GitHub Actions / GitLab CI | PR automation, issue triage | Scales past your machine |
| Slack | Turning bug reports into PRs | Work starts where it's reported |
| Chrome | Debugging live web apps | Claude sees the running page |
| Agent SDK | Custom agents and workflows | Full control of orchestration and permissions |
Most surfaces need a Claude subscription or an Anthropic Console account. The terminal CLI, VS Code, and JetBrains also support third-party providers.
The CLI is where Claude Code began and it remains the most flexible option. It runs locally, talks directly to the model, and asks permission before it changes anything.
Installation is a one-liner on macOS, Linux, and WSL:
curl -fsSL https://claude.ai/install.sh | bashWindows users can install via PowerShell (irm https://claude.ai/install.ps1 | iex) or WinGet (winget install Anthropic.ClaudeCode). There's a Homebrew cask too, with an important wrinkle: claude-code tracks the stable channel and runs roughly a week behind, while claude-code@latest ships new versions immediately. Native installs update themselves in the background. Homebrew and WinGet installs do not.
Because it's a command-line tool, you can pipe into it, script it, and drop it into existing workflows. Note the quotes around the prompt: without them your shell splits the prompt into separate arguments and the command fails.
# Review the files you changed against main
git diff main --name-only | claude -p "review these changed files for security issues"
# Watch a log and escalate anomalies
tail -200 app.log | claude -p "Slack me if you see any anomalies"The -p flag runs a single prompt non-interactively, which is what makes Claude Code usable from cron jobs and CI pipelines.
Drop a CLAUDE.md file in your repository root and Claude reads it at the start of every session. Branch naming conventions, build commands, architecture decisions, review checklists: anything Claude should know before it starts.
Claude also builds auto memory as it works, carrying learnings across sessions without you writing them down. That's new since our original guide and it meaningfully changes how much setup a fresh session needs.
Three extension points matter most, and two of them did not exist in the original version of this article.
Skills package a repeatable workflow your team can invoke by name, like /review-pr or /deploy-staging. This is the cleanest way to encode "how we do things here" so that every engineer gets the same behavior.
Hooks run shell commands before or after Claude Code actions. Auto-format after every file edit, run lint before a commit, notify a channel on completion. Hooks are enforcement: they run whether or not the model remembers to.
Subagents delegate work to parallel Claude instances, each with its own context window so the main session's memory stays clean. A lead agent coordinates, assigns subtasks, and merges results. For heavier orchestration, dynamic workflows coordinate many subagents at once, and background agents let you run several full sessions and watch them from one screen.
If you live in an editor, you no longer have to leave it.
The VS Code extension adds inline diffs, @-mentions, plan review, and conversation history in the editor. It installs from the Extensions view, and the same extension works in Cursor. After installing, open the Command Palette and choose Open in New Tab.
The JetBrains plugin covers IntelliJ IDEA, PyCharm, WebStorm, and the rest of the family, with interactive diff viewing and selection context sharing. One catch: the plugin requires the Claude Code CLI installed separately. The VS Code extension does not.
The desktop app runs Claude Code outside your IDE or terminal. It's not a limited version; it's a GUI over the same engine, and it includes Claude Code, so you don't install the CLI separately.
For Git repositories, each session gets its own isolated copy of your project using Git worktrees, so changes in one session don't affect another until you commit. That's what makes genuine parallel work possible: an auth refactor, an API endpoint, and a UI change can run at once without stepping on each other.
Worktrees live at <project-root>/.claude/worktrees/, configurable under Settings, Claude Code, Worktree location. (Our original guide reported this as a folder in your home directory. That was wrong, and worth correcting if you built tooling against it.)
Gitignored files that sessions still need, like .env, get copied in via a .worktreeinclude file in your project root. You can also set a branch prefix so Claude-created branches are organized automatically.
After Claude changes code, the diff view lets you review file by file before opening a pull request. Click a line number to comment on a specific change, then submit all comments at once with Cmd+Enter on macOS or Ctrl+Enter on Windows. A Review code button has Claude evaluate its own changes and leave comments in the same view.
Cloud sessions run on Anthropic-managed infrastructure and keep going after you close the app or shut down your machine. They handle multiple repositories in one session, each with its own branch selector, and you can monitor them from the web or the mobile app.
Dispatch is a persistent conversation that can spawn Code sessions on its own. Ask it to open a session directly, or let it decide that a task is development work and start one. Dispatch-spawned sessions carry a badge in the sidebar. It requires a Pro or Max plan and is not available on Team or Enterprise.
Claude Code on the web runs in a browser at claude.ai/code, and in the Claude app for iOS and Android. Use it to kick off long-running tasks and check back later, to work on repositories you don't have cloned, or to run several tasks in parallel.
Four surfaces exist to take you out of the loop entirely.
GitHub Actions and GitLab CI/CD automate code review and issue triage in your pipeline. GitHub Code Review gives you automatic review on every pull request. Slack lets you mention @Claude with a bug report and get a pull request back, which closes the gap between where bugs are reported and where they're fixed. Chrome lets Claude debug a live web application rather than reasoning about it from source.
This is the biggest change since our first version, and the one most people miss. Sessions aren't tied to a single surface.
| I want to... | Use |
|---|---|
| Continue a local session from my phone | Remote Control |
| Start on the web, finish in my terminal | claude --teleport |
| Start in the terminal, review diffs visually | /desktop |
| Start locally, continue on mobile | claude --cloud, then the mobile app |
| Push events from Telegram, Discord, iMessage, or a webhook into a session | Channels |
The handoffs that pull work into or out of claude.ai (--teleport and /desktop) require a claude.ai subscription. /desktop is available on macOS and x64 Windows.
Three mechanisms, and the difference between them matters.
Routines run in the cloud, so they keep running when your computer is off, and they can trigger on API calls or GitHub events. Create them from the web, the desktop app, or /schedule in the CLI. Use these for morning PR reviews or weekly dependency audits.
Desktop scheduled tasks run on your machine, with direct access to your local files and tools. Use these when the job needs something that only exists locally.
/loop repeats a prompt inside a single CLI session. It's for polling, not for scheduling.
This is the question we get most, and the answer changed substantially.
Claude Code's current lineup runs from Fable 5.1 (claude-fable-5-1), built for long autonomous sessions, through Opus 5 for complex reasoning, Sonnet 5 for daily coding, and Haiku 4.5 for fast, simple work. Earlier Opus 4.x and Sonnet 4.x models remain selectable.
Your default depends on your plan:
| Account | Default model |
|---|---|
| Max, Team Premium, Enterprise, Anthropic API | Opus 5 |
| Pro and Team Standard | Sonnet 5 |
Rather than memorizing IDs, use the aliases, which resolve to the newest version your provider offers:
claude --model opus # Latest Opus
claude --model sonnet # Latest Sonnet
claude --model best # Fable where available, otherwise Opus
claude --model opusplan # Opus to plan, Sonnet to executeopusplan deserves more attention than it gets. Planning benefits from the stronger model; execution usually doesn't, and it's where most of your tokens go.
Fable 5.1, Fable 5, Sonnet 5, Sonnet 4.6, and Opus 4.7 and later support a 1M token context window via a suffix: /model opus[1m]. The current models also support effort levels from low through max, which is a real cost lever on long sessions.
Newer models need a recent client. Opus 5 requires v2.1.219 or later, Sonnet 5 requires v2.1.197, and Fable 5.1 requires v2.1.257. If a model won't appear, run claude update before debugging anything else.
| Plan | Price | Claude Code |
|---|---|---|
| Free | $0 | Not included |
| Pro | $17/mo annual, $20/mo monthly | Included |
| Max | From $100/mo, 5x or 20x Pro usage | Included |
| Team | $20/seat Standard, $100/seat Premium | Included |
| Enterprise | Custom | Included |
One detail worth internalizing: Claude Code shares the same usage limits as the rest of your plan. Terminal work and ordinary chats draw from one pool, visible under Settings, Usage. If you exhaust it mid-task, you can switch to pay-as-you-go API credits through a Console account and keep working at standard API rates.
Does the work need my local files or tools?
├─ Yes, and I want full control ......... Terminal CLI
├─ Yes, and I want to stay in my editor .. VS Code / JetBrains
└─ Yes, and I want parallel sessions ..... Desktop
Can it run without me?
├─ It should run on a schedule ........... Routines (cloud) or Desktop tasks (local)
├─ It should run on every PR ............. GitHub Actions / Code Review
└─ It starts from a bug report ........... Slack
Am I away from my machine?
├─ Starting fresh ........................ Web or mobile
└─ Continuing something ................... Remote Control / --teleportMost developers use several surfaces a day, and the skill worth building is the handoff rather than the tool choice. Deep work in the terminal. A visual pass in Desktop when the diff gets large. A long task pushed to the cloud before you close the laptop. A review that happens without you, in CI.
CLAUDE.md, settings, and MCP servers follow you across every surface.--teleport, /desktop, Remote Control, and Channels mean the work follows you rather than the reverse.opusplan and effort levels are the two cheapest cost levers available, and most people never touch either.This article is part of our Vibe Coding series. For more on AI development workflows, see our piece on Cursor's multi-agent feature. Have questions? Get in touch.
This article is a live example of the AI-enabled content workflow we build for clients.
This is a refresh, not a new post. The original published in December 2025 and had gone stale in a field that moved fast. Rather than publish a new URL and split the audience, we rewrote in place.
| Stage | Who | What |
|---|---|---|
| Audit | Tom Hundley | Identified the page from search data as the site's highest-impression article, and confirmed it was nine months out of date |
| Research | Claude Opus 5 | Pulled current product documentation, model configuration, and pricing from primary sources |
| Drafting | Claude Opus 5 | Rewrote against verified facts, correcting several errors in the original |
| Fact-Check | Human + AI | Every product claim, model ID, price, and file path checked against official documentation |
| Editorial | Tom Hundley | Final review for accuracy, tone, and value |
What the refresh corrected: the worktree storage path, the model lineup and defaults, the plan and pricing table, two code examples whose quoting had been stripped by an import bug, and a surface map that was missing IDE extensions, Slack, Chrome, mobile, and every cross-surface handoff.
We're an AI enablement company. It would be strange if we didn't use AI to create content. But more importantly, we believe the future of professional content isn't AI versus human. It's AI amplifying human expertise.
Every article we publish demonstrates the same workflow we help clients implement: AI handles the heavy lifting of research and drafting, humans provide direction, judgment, and accountability. Including the unglamorous part, which is going back to fix what you already published.
Want to build this capability for your team? Let's talk about AI enablement →
Discover more content: