Claude Chat vs Cowork vs Code: Which One Should You Actually Use?

Anthropic shipped three products with nearly the same name and almost no signage telling you which one to open. Chat, Cowork, Code. Same Claude underneath, three completely different jobs.

The confusion costs real time. We watch smart marketers paste a folder's worth of files into Chat one at a time, when Cowork could have just read the folder. We watch operators skip Claude Code entirely because they don't write software, when the thing blocking them is a 30-line script.

We run 40+ agents in production at WE•DO across content, reporting, meeting prep, and internal ops, and all three surfaces are in that stack every day. Here is the actual dividing line, what each one is built for, and the three-question test we use to route work.

Forget model names for a second. The only variable that matters is how much of the job you keep for yourself.

In Chat, you keep all of it. You drive every turn, and Claude hands back text. In Cowork, you keep the goal and the review, and Claude keeps the middle: it reads and writes files in folders you name, uses the tools you connect, and comes back with a finished deliverable. In Code, you keep the intent and the merge decision, and Claude keeps the repo.

That is the whole map. Everything below is detail on where each one earns its keep.

Chat is the one everyone already knows: web, desktop, mobile, a conversation you steer turn by turn. It starts instantly and it remembers you across conversations.

It's the right tool when you don't yet know what you want. Pressure-testing a positioning angle, arguing with a hypothesis, turning a messy set of notes into three headline options, working out why a funnel is leaking before you touch the analytics. The back-and-forth is the point: you get to interrupt, disagree, and redirect on every turn.

Chat stops being the right tool the moment you're doing manual labor to feed it. If you're uploading files one at a time, copying output into a document, then pasting the next file, you've outgrown the surface. That's not a prompting problem. That's a product-selection problem.

Cowork is the surface most marketing teams are sleeping on. It runs the same agentic loop as Claude Code, pointed at your files and apps instead of a codebase.

The difference from Chat is not intelligence, it's the shape of the interaction. Chat is a vending machine: prompt in, answer out. Cowork is a kitchen: you place an order, and it gathers ingredients, works a multi-step recipe, plates it, and brings it out. It doesn't stop when it has produced a response. It stops when the task is done, which might take two minutes or forty.

Three things make that possible. It gets a persistent workspace, so it can spread out research, save drafts, change approach, and build on its own output across the whole session. It gets real access to the folders and connectors you grant, so there's no upload or download step. And it can run on a schedule, unattended, with your laptop shut.

That last one is what turns Cowork from a faster assistant into an operator. Set up a Monday 6am task once, and the weekly readout is waiting before you've made coffee: numbers pulled, compared to last week, anything that moved more than 10% flagged.

One practical wrinkle worth knowing before you commit: local file access is a desktop-app thing. Web and mobile sessions run in a cloud sandbox, which is great for firing off a task from your phone, but they can't see your hard drive unless the desktop app is open on that machine.

It also asks before anything consequential: sending an email, posting a message, changing a file outside its working folder. You see each step in the sidebar and can interrupt at any point. That approval gate is the reason we're comfortable pointing it at client work at all, and it's the same principle we wrote about in how Claude Code handles client data.

Claude Code is built for software: reading a codebase, making multi-file edits, running commands and tests, opening the pull request. It lives in the terminal, in VS Code and JetBrains, in a desktop app, on the web, on mobile, in GitHub, and in Slack. Same engine behind all of them, and your project instructions travel with you.

Here's the part non-engineers get wrong. The dividing line isn't your job title, it's whether the work ends inside a repo. Plenty of marketing work does. Tracking implementations, schema markup, a bulk redirect map, a script that reshapes an export, anything touching a Next.js or Shopify theme. We use it for exactly that kind of thing, which we covered in how we use Claude Code.

And the reverse is just as true: if the work doesn't end in a repo, Code is the wrong surface even if you're technical. Building a deck from a folder of research is Cowork work. Reconciling a spreadsheet is Cowork work. Reaching for the terminal because it feels more powerful is how you end up debugging a Python script that a scheduled Cowork task would have handled.

When someone on our team isn't sure, they run three questions in order. The first yes is the answer.

1. Are you still deciding what you want? Open Chat. Thinking is Chat's job, and every minute of it is cheaper here.
2. Do you know the deliverable, and do you know where the inputs live? Open Cowork. A clear output plus a real folder is the exact shape it's built for.
3. Does the work end inside a codebase? Open Code. Repo, commands, tests, pull request.

Most misfires are question two failing quietly. People know the deliverable but haven't decided where the inputs live, so they default to Chat and pay for it in uploads.

Abstract advice is easy. Here's the actual routing on real recurring work.

Notice how much lands in the middle column. That's the pattern we see across every team we onboard: the Chat habit is strong, the Code fear is strong, and Cowork sits in the gap where most knowledge work actually lives.

1. Treating Cowork as Chat with file access. It's a delegation surface. If you're still steering every turn, you're paying agentic token rates for a conversation. Brief it properly and let it run.
2. Giving Cowork the whole drive. Point it at one folder. Scoped access produces better output and makes review possible, and it's also the honest answer when a client asks what it can see.
3. Avoiding Code because nobody here is an engineer. Half our Code usage is marketing infrastructure: tracking, schema, redirects, data cleanup. The repo is the test, not the title.
4. Not scheduling anything. A task you have to remember to start is a task that stops happening in week three. Unattended scheduling is the single highest-leverage feature of the three, and almost nobody turns it on.

Chat, Cowork, and Code aren't three tiers of the same product. They're three answers to one question: how much of this job are you keeping?

Keep all of it when you're thinking. Keep the goal and the review when you know the deliverable. Keep the merge decision when the work ends in a repo. Pick on that basis and the naming stops mattering.

Want the same routing logic applied to your team's actual recurring work? Start with 40 AI Agents Every Growth Team Should Have, then look at AI Operations when you're ready to build the system rather than the habit.