The many shapes of Claude: which one to use when

Anthropic ships Claude in more forms than most people realise. Same underlying models, very different wrappers — and the wrapper matters more than people admit. The terminal agent and the chat box are not the same product, even when they're calling the same Sonnet weights underneath.

Here's how I actually use each one, what they're good at, and where they break.

Claude.ai (the chat app)

The browser chat at claude.ai. The default surface. Most people start here and never leave.

Good for: thinking out loud, drafting, one-off code questions, document analysis (drop a PDF in), image reading, quick research with web search on. Projects let you pin a system prompt and a small knowledge base — useful for recurring contexts like "my company's brand voice" or "the spec for this side project".

Bad at: anything involving your actual filesystem. You'll spend ages copy-pasting code in and answers out. Artifacts are fine for isolated React components or a single HTML file, but they're a toy compared to running code locally. Context window fills up faster than you'd think once you've pasted three files.

When to use: writing, planning, rubber-ducking, reading long PDFs, one-shot scripts you'll paste somewhere else. If you catch yourself pasting your fourth file into the chat, stop and open Claude Code instead.

Claude Code (the terminal agent)

A CLI that runs in your repo, reads and writes files, runs commands, and uses tools. Install with npm i -g @anthropic-ai/claude-code and run claude in a project directory.

Good for: real work in a real codebase. Refactors across many files. "Find every place we call the old API and migrate them." Writing tests. Debugging by actually running the failing command and reading the output. Generating a PR end-to-end. It's an agent, not a chatbot — it loops on tool calls until the task is done.

Bad at: tasks where you don't want autonomy. It will sometimes confidently rewrite something you didn't ask it to. Use --permission-mode and read the diffs. Also expensive if you let it run wild — a long agentic session can burn through tokens in a way chat never does. Worth it when it works, painful when it doesn't.

How to use it well:

• Keep a CLAUDE.md at the repo root with conventions, commands, gotchas. It reads this automatically.
• Start narrow. "Add a test for X" before "refactor the whole module".
• Let it run your test suite. The feedback loop is the whole point.
• Use /clear between unrelated tasks. Context bleed makes it dumber.

When to use: anything that touches more than two files, anything where running the code matters, anything you'd otherwise babysit in chat with endless copy-paste.

Claude in your IDE (the extension)

The official VS Code / JetBrains extension, plus tight integrations in Cursor, Zed, and Windsurf. Inline edits, tab completion-style suggestions, sidebar chat with file context.

Good for: tight-loop edits while you're already in the editor. "Rename this prop everywhere in this file." "Write a JSDoc for this function." Selecting a block and asking for a refactor. Lower ceremony than firing up the CLI.

Bad at: multi-step agentic work. The IDE surface is built for human-in-the-loop edits, not autonomous tasks. You'll still want Claude Code for the bigger jobs.

When to use: while actively coding, for small surgical changes. If you find yourself describing a long plan to the sidebar, switch to Code.

Claude on the desktop app + MCP

The desktop app for Mac/Windows is mostly the chat experience plus one big thing: MCP servers. Give Claude tools — filesystem access, a Postgres connection, your Linear workspace, Figma, whatever has a server. Configure in ~/Library/Application Support/Claude/claude_desktop_config.json.

Good for: turning chat into a workspace that touches your actual tools. "Pull the last 10 issues from Linear and summarise the themes." "Query the staging DB for users who signed up last week." The MCP ecosystem is the most interesting thing happening in this space right now.

Bad at: discoverability. Setup is fiddly. Server quality varies wildly. Auth flows are inconsistent. It's powerful once configured but you will hit rough edges.

When to use: when chat needs to read or write to a system you care about, and you don't want to build a custom integration. Pair it with filesystem and git MCP servers and it starts to feel like a lightweight Claude Code that lives in chat.

Claude on the web with computer use / agent mode

The newer browser-controlling agent (sometimes called "computer use" via the API, or surfaced as agent skills in the app). Claude drives a virtual browser, clicks things, fills forms.

Good for: tasks that have no API. Scraping a stubborn site, filling repetitive forms, multi-step web workflows. Demo-friendly.

Bad at: reliability. It's slow, it gets confused by modals and cookie banners, and it can make mistakes that matter (don't let it loose on anything that spends money unsupervised). Genuinely useful for a narrow slice of work, oversold for everything else.

When to use: sparingly, for tasks where the alternative is doing it manually for 40 minutes. Don't build production systems on it yet.

The API (claude-3-5-sonnet, claude-sonnet-4, claude-opus-4, haiku)

The raw model behind everything else. You hit it from your own code.

Good for: building product. Anything where the user isn't you. Batch jobs. Evals. Custom agents with tools you define. Pick the model that fits the job:

• Haiku for high-volume, latency-sensitive, simple work (classification, extraction, routing). Cheap.
• Sonnet for the default. The workhorse. Most tasks land here.
• Opus for hard reasoning, gnarly code, planning. Slow and expensive — use it when Sonnet fails, not by default.

Bad at: being a finished product. You're building everything around it — retries, prompt management, tool loop, evals, observability. That's the job.

When to use: when you're shipping something to other people, not just using Claude yourself.

A rough decision tree

• Just thinking or writing? → Claude.ai
• Editing one file you're already looking at? → IDE extension
• Touching the repo for real? → Claude Code
• Need Claude to talk to Linear / Postgres / Figma while you chat? → Desktop + MCP
• No API exists and you must automate a browser? → Computer use, reluctantly
• Building something for users? → API, pick the model per task

The meta-point

The model is rarely the bottleneck anymore. The surface is. Sonnet in a chat box and Sonnet in an agent loop with filesystem access produce wildly different outcomes on the same task. Most people are underusing Claude not because they need a smarter model, but because they're using it through the wrong wrapper.

Pick the surface that matches the shape of the work. If you're copy-pasting more than three times, you're in the wrong one.

@misc{ctrlsze-the-many-shapes-of-claude-which-one-to-use-when-2026,
  author = {Sze},
  title  = {The many shapes of Claude: which one to use when},
  year   = {2026},
  month  = {May},
  url    = {https://ctrlsze.studio/blog/the-many-shapes-of-claude-which-one-to-use-when},
  note   = {CTRLSZE}
}