Chat, Cowork, or Code?

I’ve been spending a lot of time with Claude across all three of its modes: Chat, Cowork, and Code. I also talk to a lot of coworkers about AI usage, and one of the main questions I get is: which one should I use, and when. My answer keeps being “it depends, do you have 15 minutes” which isn’t always helpful, so I’m writing it down properly.

The three tools share the same underlying models, and they can all access MCP servers and integrations. The differences aren’t about raw capability, but about three axes that matter more than most people realize: how much context the tool already has about your work, how much it can do versus how much it can say, and how durable that context is across sessions.

Context depth and action depth

I think about these tools on a gradient. Chat is a blank slate: every new chat starts from zero (aside from some “memory” that builds over conversations), and you supply all the context in the prompt or hope that your old thread was retained. If you’re asking “what can I substitute for buttermilk in this recipe?” or “is X a reasonable approach for Y?”, Chat is perfect. The question is self-contained, the answer is disposable, and you don’t need Claude to remember anything about you or your work. I use Chat for these kinds of questions a handful of times a day, and almost never go back to read the conversations afterward.

Cowork occupies the middle ground. It can see your project files, create artifacts, persist notes across sessions, and build up context about what you’re working on. The key differentiator isn’t memory — it’s artifacts: documents, research notes, structured outputs that live as files you own. You can back them up, edit them outside of Claude, reorganize them, and keep them forever. Chat’s memory is shallow and automatic; Cowork’s context is deep and deliberate.

Code goes further. It can read your filesystem, search your codebase, execute commands, write and edit files, and operate in agentic loops where it plans, acts, observes, and adjusts. It’s not just aware of your context; it can change your context. For engineering work, this is where I spend most of my time, but I want to be precise about why: not because Code is “better,” but because the tasks I bring to it benefit from the action depth. Writing a blog post? Cowork is fine. Refactoring a module across 40 files and running the test suite to verify? That’s Code.

The tool outgrows the task (or the task outgrows the tool)

I have a health research project that illustrates this nicely. It started as a series of one-off questions in Chat: medication interactions, what a lab result means, whether a side effect is expected. Pure Chat territory. Self-contained questions, disposable answers.

Over a few months, the project accumulated mass. I had six research documents cross-referencing each other. I needed context from previous conversations to ask useful follow-up questions. Eventually I was writing Python scripts to analyze CPAP data and building an HTML dashboard to visualize sleep patterns. The project now lives in Code with its own directory, its own CLAUDE.md context file, and a journal of observations over time.

I didn’t make a wrong tool choice at the start. The task’s weight shifted under me, and the tool needed to shift with it. The thing to watch for is the transition point: when you’re fighting the tool instead of using it.

What persists

A third axis beyond context and action matters most for sustained work: what persists.

All three tools send your data to Anthropic’s servers for processing. There’s no difference in what Anthropic sees. The difference is in what happens afterward, and in what persists for you.

Chat conversations are retained for 30 days (or up to 5 years if you’ve opted into training data sharing¹). The 30-day clock resets from your last message, so active threads stick around. But Claude’s useful context degrades long before that: the context window compresses and compacts older messages as the conversation grows, so the nuance you built up early quietly erodes even while you’re still talking. Once you stop, 30 days of inactivity and it’s gone entirely. You’re left with nothing to carry forward.

Cowork and Code change this equation, not by hiding data from Anthropic, but by keeping the useful work product on your machine. Cowork’s local project folders and Code’s CLAUDE.md files, auto-memory, and project context all persist regardless of what Anthropic retains or forgets. When their 30 days are up, their copy is gone, but your accumulated context remains, ready to load into the next session. Code goes furthest here: its memory system builds up structured project knowledge over time that survives across sessions indefinitely.

Simon Willison has written extensively about the importance of understanding where your data goes when you use LLM tools². For my own usage, the takeaway is this: the real value of Cowork and Code isn’t data privacy. It’s context durability.

The instantiation cost counterweight

The most powerful tool isn’t always the right one. There’s a real cost to reaching for Code when Chat would do.

Code sessions have startup overhead: loading project context, initializing the session, navigating permission prompts. Cowork has project setup cost. Chat has neither. For a question like “what’s a good substitute for fish sauce in this dressing?”, firing up Code would be like driving to the grocery store to buy a single lime. The overhead dwarfs the task.

All three tools share the same Pro subscription at $20/month, with Max tiers at $100 and $200 for heavier usage. The cost differential isn’t dollars per tool; it’s how each tool consumes your usage budget within the tier. Code sessions are token-heavy. They load context, they make tool calls, they run agentic loops. Chat messages are lightweight. If you’re on a Pro plan and you’re hitting rate limits, reaching for Chat instead of Code on simple questions is the first lever to pull before upgrading to Max.

This matters even more on enterprise plans, where teams often share a token budget allocated to their organization. When your team has a fixed pool of tokens per month and six engineers are drawing from it, how each person chooses their tool directly affects whether the team hits its ceiling by week three. Anthropic’s own documentation puts the average Code user at ~$6/day in token usage, with 90% of users staying under $12. Multiply that across a team, add in a few people using Code for questions that Chat would handle in 30 seconds, and you can see how the budget math gets unfriendly fast.

The framework

I’ve landed on a mental model I don’t claim is universal, but it’s been useful enough to share:

Chat is for questions that are self-contained and disposable. The answer doesn’t need to persist and Claude doesn’t need to know anything about me to give it. Ingredient substitutions, gut checks on an approach, quick syntax reminders, brainstorming names for things. If I won’t care about the answer tomorrow, it’s a Chat question.

Cowork is for work that accumulates context over time. Research projects, document drafting, anything where the outputs need to be durable artifacts rather than conversation messages. The transition signal from Chat to Cowork is when I realize I need structured files I can organize, edit, and keep, not just a conversation thread with some memory attached. If the topic has enough mass that I’d want to back up the context, I’ve outgrown Chat.

Code is for work that benefits from action, not just advice. If the task involves reading files, searching a codebase, running commands, or making changes across multiple files, Code’s agentic capabilities save more time than they cost in tokens. The transition signal from Cowork to Code is when I find myself copying Claude’s output and pasting it into files manually. My boss has a phrase I’ve stolen: “the robot should be the robot.” If I’m acting as the intermediary between Claude’s suggestions and my filesystem, I’ve taken on a job that Code does natively.

This is the first post in what I’m planning as a series on how I use AI tools. For now, if you’re a Claude user spending $20/month and wondering whether you’re getting your money’s worth: pay attention to which tool you’re reaching for and why. The model is the same across all three. The leverage is in the context.

1. Anthropic changed their consumer data policy in August 2025 to allow opt-in training data sharing with 5-year retention. The rollout was, charitably, not their finest moment. If you haven’t checked your settings at claude.ai/settings/data-privacy-controls, it’s worth a visit. ↩

2. Simon Willison’s blog is probably the single best resource for thinking clearly about LLM tool usage, data privacy, and the practical realities of building on top of these models. He’s been writing about this longer and more carefully than almost anyone else. ↩