Claude Desktop vs Cowork vs Code: A Beginner's Roadmap to Which One to Use

I've been meaning to write this down for months and kept not doing it. So here it is, mostly for anyone staring at Claude Desktop, Cowork, and Code trying to figure out where to even start, and which to use for what.

I kept bumping into the same thing. I moved my real building into Claude Code, and the other two slowly started to feel like a blackbox. Not worse answers. The work just stopped adding up to anything, and that wasted time I wish I could get back.

At the surface, it made no sense. Cowork and Code run on the same agentic engine (Anthropic says so outright), Desktop runs the same models, and all three reach your tools through the same MCP connectors. Same intelligence, same reach, three different outcomes. The thing that actually separates them is what survives when the session ends, and once I saw that, picking the right one got easy.

Every live session is a blackbox that degrades

There's one problem all three share, Claude Code included, and it's easy to miss until it costs you.

A session has a context window, a token budget. As you work, it fills. When it's full, the session compacts: it summarizes itself to make room. That summary is lossy, and every time it compacts, the state gets a little less reliable, until the thread is too degraded to trust and you start a new session.

One asymmetry is worth flagging up front. All three degrade the same way, but only Code shows you the gauge. It surfaces how full the context is, a live meter in the status line, a /context command, and a warning before it auto-compacts, so you can manage it on purpose instead of getting caught out. Desktop's chat gives you no such gauge; you notice by feel, usually when the answers start drifting. Cowork has a Context panel, but that's a place to add reference material, not a live read on how full the window is. Same problem, very different visibility into it.

So the live session is the blackbox. Nothing durable lives there. Which reframes the whole question. When this session degrades and you open a fresh one, what carries over? That is the entire game, and it's the one thing the three surfaces answer completely differently.

Meet the three surfaces

Claude Desktop

What it is. The chat app for your claude.ai account (Mac and Windows), distinct from the browser. It adds local reach the browser can't have: one-click local connectors. These are Desktop Extensions: packaged MCP servers that install in one click and can touch your machine. Concretely, a filesystem extension that reads a local folder, or one that pulls from your calendar or Apple Notes. That one-click install is a Desktop thing (Claude Code reaches the same MCP servers from the command line instead), and none of it works in the browser or on mobile, which is the local reach the browser can't have. Desktop now hosts both Cowork and a window into Claude Code.

Best for. Quick conversational work, thinking out loud, Artifacts (interactive outputs, a doc, a chart, a small app, rendered in a side panel you can edit, version, and share), anything on your phone, voice, and showing something to a non-technical person. It's the front door.

How you use it. You chat. For recurring context you make a Project: a workspace with its own history, custom instructions, and an uploaded knowledge base. You add connectors (Slack, Notion, Linear, GitHub) once and they sync across your surfaces.

What survives a session. Three things. Cross-conversation memory (it reached all plans, free included, on March 2, 2026) is a lossy summary of your history, refreshed about daily, account-bound, editable but capped. Projects keep their instructions and a knowledge base retrieved via RAG past the context limit. And skills you upload as zip files, per user. All real. All a record you retrieve, not a system that changes how Claude works.

Claude Cowork

What it is. The one people misread, me included. The "co" had me picturing other people working alongside me in a live session. Wrong read. It's an agentic assistant for non-technical knowledge work, running Code's engine inside the Desktop app without the terminal. It went generally available on April 9, 2026. You give it an outcome and it works your files and apps and hands back a finished deliverable.

Best for. The boring middle of knowledge work: extract, compile, reconcile, reformat across documents and tools. It writes real Office files to your actual disk, spreadsheets with working formulas, formatted decks, for people who never want to see a terminal. A genuine job Code is bad at.

How you use it. Open Desktop, the Cowork tab, describe the outcome, come back to finished work. It coordinates sub-agents for multi-step jobs. Live sessions are solo and desktop-tethered, so a session can't be shared with other people, and closing the app ends the run. On Team and Enterprise plans, Projects are shareable, so a team collaborates asynchronously through shared files, instructions, and memory, each working the project on their own time. You can also set scheduled, recurring tasks on a project (the same idea as Code's routines), and Dispatch (beta) lets you drive a running task from your phone, the same resume-from-anywhere idea as Code, except it runs on your own machine rather than Anthropic's cloud.

What survives a session. More than I first assumed. A Cowork Project keeps a real, structured layer: Instructions, a MEMORY.md plus other project memory files, scheduled tasks, and Context sources (folders, Drive, links). That's a genuine persistent memory with real structure, well past a rolling summary. The catch is where it lives: it's managed inside the Claude app, account-bound, not in a git repo you own and version. A standalone run works in an isolated VM, so the durable part is the project layer you set up, not the session's scratch space.

Claude Code

What it is. The developer surface (terminal, VS Code and JetBrains extensions, a desktop app, web, even mobile). That framing undersells it. It's the only one with a real operating layer on your machine under the chat. On the top plans (Max, Team Premium, Enterprise pay-as-you-go, the API) the default model is Opus 4.8, while Pro and standard seats default to Sonnet 4.6, and unlike the others you control the model, with a fast mode and an effort dial for hard tasks.

Best for. Anything you'll build on: code and repos, multi-step systems, parallel agents, and work that should get smarter over time.

How you use it. You work in a repo. It reads two persistent layers every session: a CLAUDE.md you write (rules), and an auto-memory it writes to itself (learnings). You extend it with skills, hooks, plugins, MCP servers (the open protocol that lets Claude talk to your tools and data), and sub-agents. The rules, skills, and hooks are files on disk, checked into git, shared with your team, reloadable mid-session.

What survives a session. A versioned substrate: files that reload, that change what the agent does, that stack and travel with the repo.

They're converging. The real gap is what you own, and what composes.

It's tempting to say only Code remembers. That's not true anymore. Desktop has cross-conversation memory; Cowork projects keep instructions, scheduled tasks, and a real MEMORY.md. They've closed most of the gap, and they're still converging: Cowork now has routines and even mobile dispatch, just like Code. So the real question stopped being who remembers. It became what you own, and what composes.

Desktop and Cowork keep their memory managed for you, inside the app: account-bound and app-managed, and it stays a memory layer rather than a system that changes how Claude behaves. It's a persistent record Claude maintains, and on Cowork it's a genuine structured one (MEMORY.md, instructions, schedules).

Claude Code keeps its memory as plain files you own: your rules and skills versioned in the git repo, the auto-memory it writes living alongside on your own machine, diffable, yours, and composing with skills, hooks, and a self-learning loop that change what the agent actually does. Same MEMORY.md idea, but owned, versioned, and wired into behavior.

The loop that makes it a system

Here's why Code's is a system and not just a bigger record. It keeps a MEMORY.md the agent writes to itself, reloaded every session. Add a few hooks and it goes further: the system catches a mistake, routes the lesson to the right place, and feeds it back automatically. Every task makes the setup a little smarter without me being the one who remembers.

That's the actual engine of "compounds," and the thing a retrieved summary can't do. A retrieved summary gives back what you put in. The loop generates and keeps what it learns.

The sharpest example: skills

Skills exist on both. On claude.ai you upload a skill as a zip, just for you, and it doesn't follow you to Code. In Claude Code a skill is a file in a repo you distribute to your whole team through a plugin. Same word, opposite behavior. One is a personal attachment you retrieve. The other is shared infrastructure that compounds.

A real one from this week. I fixed a small browser-tool annoyance. By the time I finished, the fix was a committed change, the lesson was routed into the agent's memory file, and the reusable part became a skill that now loads in every repo I touch and that I can hand to anyone. I didn't do extra work for that. The substrate did it. The same hour in a Cowork project would have updated its memory too, but not as versioned, composable files I own and can hand to anyone.

Which one to use

Rule of thumb: pick by what should survive the session. A throwaway question, or a deliverable for someone else? Desktop or Cowork is right, maybe better. Something you'll build on? Do it where it can accrue, or accept you'll rebuild it next session.

The honest part

Even in Code, the memory and rules are context, not a guarantee. Anthropic is upfront that a CLAUDE.md is delivered as a suggestion, not enforced. The deterministic layer is hooks, which you add. And the compaction problem is real everywhere: any long session degrades, Code included. Code's session degrades just like the others. The difference shows up when you open the fresh one: Code hands you a versioned system you own, and the others hand you a managed memory you don't.

Different tools, different jobs. Desktop and Cowork are genuinely better for a quick answer, for mobile, for a finished spreadsheet someone needs. None of this is about one being smarter. Only one of them builds on itself.

If you're working across these and feeling that same evaporation, I'm happy to compare notes on how I've set mine up.