Choosing the Right Surface: CLI, Desktop, IDE, Web, and Mobile
Now that you've verified your Claude Code installation and confirmed its authenticity, the next question is deceptively simple: where do you actually run it? Claude Code isn't one tool with one interface. It's the same engine exposed through six different surfaces, each optimized for a different way of working. After this lesson, you'll be able to look at a workflow and immediately know which surface fits.
The Six Surfaces at a Glance
Think of Claude Code's surfaces on a spectrum from "most control" to "most convenience." The CLI sits at the control end. Mobile sits at the convenience end. Everything in between trades some capability for tighter integration with a specific environment.
Here's the full picture:
CLI: The Full-Featured Surface
The CLI is where Claude Code's full power lives. It's the only surface that supports third-party providers (OpenRouter, local Ollama models, etc.), the Agent SDK for building multi-agent workflows programmatically, and computer use on macOS for Pro and Max subscribers.
If you're scripting Claude Code into a CI pipeline locally, automating repository maintenance, or building custom agent tooling, the CLI is your only option. For HealthTracker, this is where you'll run long refactor sessions, generate test suites, and eventually wire up multi-agent pipelines.
The Agent SDK is worth exploring once you're comfortable with basic Claude Code workflows. It lets you build multi-agent systems where Claude instances coordinate with each other programmatically, which opens up some genuinely powerful automation patterns beyond single-session work.
One thing that trips people up early: the CLI's flexibility can feel overwhelming at first. Start simple. Get comfortable running basic sessions before you reach for provider configuration or multi-agent tooling.
Desktop: Visual Review Without the Terminal
Desktop wraps the same engine in a graphical interface. The standout feature is the diff viewer. You can see exactly what Claude changed before accepting it, which matters more than you'd expect when a single session touches dozens of files.
Desktop also supports Dispatch, which lets you delegate a task from your mobile app and have it spin up a Desktop session on your machine. If you'd rather not live in a terminal but want full local execution, Desktop is the right starting point.
IDE Extensions: No Context Switching
VS Code and JetBrains extensions embed Claude Code directly into your editor. Inline diffs appear right in your file buffer. File context comes from your current editor state. You can reference open files without leaving your workflow.
The trade-off is real. IDE surfaces don't expose the full CLI feature set: no Agent SDK, no third-party provider configuration at the surface level. But if you spend most of your day inside VS Code or IntelliJ, the productivity gain from eliminating context switches outweighs those gaps. I've seen this be the deciding factor for teams that work in large monorepos, where hopping to a terminal and back breaks concentration fast.
Web: Cloud Execution That Outlasts Your Laptop
The web surface runs on Anthropic's infrastructure. You kick off a task, close your laptop, and it keeps going. That's genuinely useful for anything slow: a large codebase analysis, a bulk refactor across hundreds of files, or a scheduled maintenance job.
The catch? You're running in Anthropic's environment, not yours. No local filesystem access, no custom tooling, no private MCP servers. Web sessions are best for work that only needs the codebase itself.
Cloud sessions created through the web surface are completely isolated from your local .claude directory. Any project memory files, custom permissions, or MCP server connections you've set up locally won't be available in a cloud session.
So if your task depends on a local database connection or a custom MCP server, web isn't the right call. Keep it for self-contained work.
Mobile: Remote Command and Control
Mobile is the thinnest client of the group. Through the Claude app on iOS or Android, you can start cloud sessions, monitor running tasks, and use Remote Control to drive a local CLI or VS Code session from your phone. You can also use Dispatch to send a task from your phone to a Desktop session running on your machine.
Mobile isn't where you do deep work. It's where you check on that large refactor you started before leaving the office.
Shared Configuration Across Local Surfaces
Here's something worth knowing early: configuration, project memory, and MCP servers are shared across all local surfaces. Settings you configure in the CLI apply when you open the same project in VS Code or Desktop.
This matters for HealthTracker. As you layer in project memory files (.claude/memory.md), custom tool permissions, and MCP server connections like a local database or Linear integration, those configurations travel with the project directory. Configure once, and every local surface inherits it.
Web and mobile are separate. Cloud sessions don't have access to your local .claude directory.
Remote Work Options
When you're away from your terminal, Claude Code gives you four distinct mechanisms. Picking the wrong one creates real friction.
Dispatch is the simplest. Message a task from the Claude mobile app and it triggers a Desktop session on your machine. Minimal setup, works great for delegating work while traveling.
Remote Control lets you actively steer a running session from claude.ai/code or the mobile app. Your machine does the execution. You drive from wherever you are.
Channels are event-driven. You set up a channel plugin (Telegram, Discord, or a custom webhook), and external events push tasks into a running CLI session. This is the mechanism you'd use if you wanted a CI failure notification to automatically trigger a Claude Code investigation session.
Scheduled tasks run prompts on a recurring schedule, either in the CLI, Desktop, or cloud. Daily changelog summarization, weekly dependency audits, nightly test gap analysis. This is where automation starts to feel genuinely autonomous.
Connecting External Tools
Beyond the six surfaces, Claude Code integrates with external services through several main connectors. GitHub Actions and GitLab CI/CD let you run Claude inside your CI pipeline: automated PR reviews, issue triage, scheduled maintenance. The Chrome extension gives Claude control of your browser with your logged-in sessions, which is useful for testing web UIs without building a headless test harness. The Slack integration lets your team mention @Claude in a channel to trigger code review or PR creation.
For everything else, MCP servers fill the gap. Linear, Notion, Google Drive, internal APIs: if there's a connector, you can attach it.
Worth looking into: The specific external integrations listed (GitHub Actions, GitLab CI/CD, Chrome extension, Slack, and particular MCP connectors) may have changed or expanded since this was written. Check the official Claude Code documentation for the current list of supported integrations.
Picking Your Surface: The Practical Decision
Start with the CLI if you're comfortable in a terminal and want maximum flexibility. Switch to Desktop if you want the same power with visual diffs and no terminal. Use an IDE extension if you live inside VS Code or JetBrains and context switching costs you focus. Reach for the web when a task needs to outlast your machine. Pull out mobile when you need to check in or delegate from anywhere.
You can mix. Plenty of workflows involve using VS Code for active development, kicking off a long refactor via the web, and monitoring it from mobile while at lunch. The surfaces complement each other.
Learn by Doing
Take 3-5 minutes to map your own workflow to a surface. Think about the last substantial coding task you worked on and answer these questions:
- Did you need to access local files or custom tools? (If yes, rule out Web.)
- Did you prefer staying inside your editor? (If yes, IDE extension is likely your fit.)
- Did the task run longer than your typical work session? (If yes, Web is worth considering.)
- Did you need scripting or automation capabilities? (If yes, CLI is your best option.)
Based on your answers, write down which surface would have been the best fit for that task and one reason why. If multiple surfaces could have worked, note which combination you'd use and at what point you'd switch between them.
Summary
- Claude Code runs on six surfaces: CLI, Desktop, VS Code, JetBrains, Web, and Mobile.
- The CLI offers the most complete feature set, including Agent SDK and third-party provider support.
- Desktop and IDE extensions trade some CLI-only features for visual review and editor integration.
- The web surface runs on Anthropic's cloud and persists after you disconnect; it doesn't have access to local configuration.
- Mobile is a control surface for cloud sessions and local sessions via Remote Control or Dispatch.
- Configuration, project memory, and MCP servers are shared across all local surfaces (CLI, Desktop, IDE).
- Remote work mechanisms include Dispatch (mobile-to-Desktop delegation), Remote Control (active steering), Channels (event-driven triggers), and Scheduled tasks (recurring automation).
- External integrations include GitHub Actions, GitLab CI/CD, Chrome extension, Slack, and MCP server connectors.
