Chat vs Cowork vs Code: how to pick the right Claude mode

Three tabs at the top of Claude Desktop: Chat, Cowork, Code. If you haven’t thought about which one you’re picking, you’re defaulting to Chat for everything. I did that for weeks. It works, but it’s like using a screwdriver to hammer nails. The nail goes in. Your thumb might not survive.

Here’s how I actually use all three after a few months of living in them. And by “living in them” I mean my screen time report would make a therapist nervous.

Table of contents

The short version

Chat is for thinking. Brainstorming, research, rubber ducking, asking questions. No file access, no autonomy. Just a conversation.

Cowork is for doing. You hand it a task and it goes off and executes. File access, document creation, connected services, scheduled automation. Runs in a VM so it can’t blow up your machine (mostly).

Code is for building. Terminal-based, git-aware, reads your codebase, writes code, runs tests, creates commits. This is where my whole brain lives.

Think, do, build.

Chat: my new Google

I’ll just say it. Chat has basically replaced Google for me.

Need to brainstorm a content strategy? Chat. Trying to figure out why a test is failing conceptually before I let Claude touch the code? Chat. Researching a topic I know nothing about? Chat. It handles all of that and I don’t have to wade through SEO-optimized listicles to find answers. Google should be worried. (Actually, Google should’ve been worried three years ago. But here we are.)

One honest take on voice mode: ChatGPT’s is better. I’ve tried Claude’s voice feature and it constantly cuts you off or messes up mid-sentence. ChatGPT just works. So if I’m dictating or thinking out loud, that’s where I go. I pull the output back into Claude afterward. Not ideal, but that’s where things stand.

The no-file-access constraint is actually useful. It forces the conversation to stay at the reasoning level. You’re thinking, not doing. That distinction matters more than you’d expect.

The trap is staying in Chat too long. If you’re copy-pasting file contents into Chat or describing your codebase instead of letting Claude read it, you’ve outgrown the mode. Time to graduate.

Cowork: the one that’s growing on me

Cowork launched in January 2026 and I underestimated it at first. “I already have Claude Code, why do I need this?” Famous last words. Anthropic keeps shipping features that make it stickier, and it’s working. I’m the fish that said he wouldn’t bite.

The basics: you give Cowork a task and it goes off and does it. It has access to your local files, it creates real documents (Excel, PDFs, Word docs, PowerPoints), and it connects to services like Google Workspace, Slack, and a growing list of others. It runs in an isolated VM, which means it’s sandboxed. Can’t accidentally destroy your system. Can’t run terminal commands or git. Safety net with tradeoffs.

You’ll need at least a Pro plan ($20/mo) to use it, and if you’re running complex tasks regularly, Max ($100/mo) is where the token budget stops being a constant headache.

Where it actually clicked

The moment Cowork stopped being a novelty was when I set up recurring data pulls. I have scheduled tasks that grab data from Google Search Console, Google Analytics, and Ahrefs on a weekly cadence, then Cowork compiles everything into a report I review every Monday. Setting that up once and having it just run? That’s the dream. It’s basically cron for knowledge workers, except your computer has to be awake.

Once that was working, I started handing it more of the busywork I’d been doing manually. Weekly status reports, to-do management, pulling data from five different sources and summarizing it in one place. Takes me about five minutes now to produce something that used to take thirty. I built /commands for some of this in Claude Code too, but Cowork owns the recurring stuff now.

The other thing I didn’t expect to care about: real document creation. Not text in a chat window, but actual .xlsx and .docx files I can send to people. That sounds small until the first time you skip the “copy from Claude, paste into Excel, fix the formatting” dance.

What’s new and why I’m using it more

Projects gives you persistent context across tasks (like having a CLAUDE.md but for Cowork). Ideas is part of a skills group that helps with prompt engineering to speed up tasks you do often. These are the kind of quality-of-life features that make you stay.

Dispatch is the other one I’m testing. Text Claude a task from your phone, it runs on your desktop, you come back to finished work. I’ll have more to say about that once I’ve put it through its paces.

The whole thing reminds me of the Claw bots I’ve seen people build (Discord bots that run commands and interact with services on your behalf). I’ve always been too scared to give something that much access. But Cowork feels less reckless than that.

And now you can give Cowork unlimited access to your computer. They just added Computer Use at the end of March, so Cowork can literally see your screen and click things. That opens up a whole new category of automation. I’m seriously considering buying a Mac Mini just to sandbox it and test how far I can push things without worrying about my main machine. Future post on that once I have more experience.

Where it still falls short

Token burn is real. A complex task eats 50-100x the tokens of a Chat message. All that background processing, screenshots, sub-agents. You will hit your rate limit and then sit there like a kid who ate all their Halloween candy by noon.

Opacity bothers me more than I expected. In Code, I see every command, every file read, every decision. Cowork gives me a high-level plan view and sometimes I have no idea why it made a particular choice until I look at the output. For someone who likes to watch the sausage get made, that’s hard.

And the sandbox, while a feature, is also a constraint. It can run your test suite and access dev tools, but it requires granting more access and it’s not as smooth as Code where that stuff just works. It’s like the difference between cooking in your own kitchen and cooking in someone else’s. Everything’s there, you just can’t find the spatula.

Code: where my brain lives

This is home. If Claude Code were a room in my house it’d be the one with the good chair and three monitors.

At any given time I have four or five terminal tabs open, each one a different Claude Code session. What’s in each tab depends on the day, but something’s always running. The tabs rotate, the tool doesn’t close. My wife thinks I’m coding. I’m mostly just arguing with an AI about commit messages.

The thing people don’t expect is how much non-code work happens in here. I run /morning every day and Claude reads my weekly plan and to-do list, tells me what’s on deck, and helps me figure out what to prioritize. At the end of the day I run /end-of-day and it logs what got done. My entire planning system lives in markdown files that Claude reads and writes. I’ve troubleshot my UniFi network through it. I’ve planned my week and spec’d out projects without writing a single line of actual code. “Where my brain lives” isn’t a metaphor. It’s just what happened.

It also makes things up sometimes. The other day I asked it to build FAQ schema across a set of pages. It came back with valid JSON-LD, properly merged with the existing SoftwareApplication and BreadcrumbList schema, three Q&As per page. Looked great. Except the FAQ content didn’t exist anywhere on the actual pages. Claude just invented it. And Google requires FAQ schema to match content that’s visibly displayed on the page word-for-word. If I’d shipped that, it could’ve triggered a manual action. So yeah: check the work. Every time.

I’ve written a lot about Claude Code on this blog (the conversation history guide alone drives most of my traffic, which says something about how many people are trying to figure this tool out). My full workflow post covers the slash commands, background tasks, and cross-project system I run everything through. I won’t rehash all of it here. The highlights:

Direct file system access. No VM, no sandbox. Claude reads and writes your actual files. This is the fundamental difference.

Terminal integration. It runs your tests, your build, your linter. It sees the errors and fixes them. The feedback loop is tight.

Git-aware. Knows your branch, your changes, your staging area. Creates commits with real messages.

Token-efficient. Way more efficient than Cowork for the same work. No background screenshots, no VM overhead.

Great at plans. I use plan mode constantly. Think through the approach before writing a single line of code. Claude Code is better at this than anything else I’ve used.

Maximum control. You see every action. Interrupt mid-response with single Escape. Rewind to any point with double Escape. Control thinking depth with effort levels. Nothing is a black box.

The tradeoff is fewer guardrails. Code can run destructive commands. It writes to your actual files without a VM safety net. You need to pay attention, especially early on.

The transition problem (and why you should try it anyway)

I’m trying to use Cowork more because I want to test it properly. But it’s hard. My system in Claude Code already does a lot of what Cowork offers and I’ve been tweaking it for months.

Here’s the thing though: Cowork is basically a GUI for Claude Code. It can access files on your computer, run tasks, connect to services. Same power, friendlier interface. A lot of people don’t like reading from a terminal, and I don’t blame them. If that’s you, skip Code entirely and jump into Cowork. It’s been great and fun to play in.

One thing that makes Code hard to leave: the /btw command. You can have a side conversation while Claude is working on something. Run a code review, then /btw let's talk about the commit message for this PR without interrupting the main task. It’s a small feature that changes how you interact with it. Cowork doesn’t have anything like that yet. It doesn’t even queue your messages. If you send something while it’s processing, it just ignores it. That gap keeps me in Code for anything where I need to stay in the loop.

I work with a lot of non-technical people and they use Cowork constantly. But here’s where I get on my soapbox for a second: many of them have connected MCPs and granted permissions thinking nothing could go wrong. Don’t be stupid, people. Don’t blindly trust the AI with access to your email, your files, your calendar, your Slack. Understand what you’re connecting. Review what it’s doing. Back things up. Claude is powerful and mostly well-behaved, but “mostly” is doing a lot of heavy lifting in that sentence.¹

Cowork handles the non-code stuff (data pulls, document generation, scheduled tasks) in ways that Code wasn’t designed for. The answer isn’t replacing one with the other. It’s figuring out the boundary.

My decision tree

Simple version:

Am I thinking or doing?

• Thinking → Chat
• Doing → Cowork or Code

Does it involve code?

• Yes → Code
• No → Cowork

Do I need to see every step?

• Yes → Code
• Just give me the result → Cowork

Am I on my phone?

• Yes → Chat, Claude Code through the app, or Dispatch (which I’m still testing)

Right now I’m in Code 75% of the time, Cowork 15%, and Chat 10%. That Cowork number is climbing. Ask me again in a month.

Stop defaulting to Chat

People paste code into Chat and ask Claude to fix it. They describe their file structure instead of letting Claude read it. They copy Claude’s response and manually apply the changes. Every single one of those steps is unnecessary in Code.

Same thing with Cowork. If you’re asking Chat to draft a report and then manually formatting it into a spreadsheet, Cowork would’ve just given you the spreadsheet.

The modes aren’t different interfaces to the same thing. They’re different capabilities. Using the wrong one doesn’t just slow you down. It caps what’s possible.

Pick the right mode. Graduate when you need to. And if you figure out a fourth mode nobody’s told me about, let me know. I’ll write a post about that too.

If you’re getting started with Claude Code, my conversation history guide covers session management, and the effort parameter breakdown explains how to control thinking depth. For Cowork, I’m writing about Customize and Dispatch and Scheduled Tasks next.