Claude Chat, Cowork, and Code: What Each One Is

Anthropic has built three distinct products inside Claude, and by most accounts, the company has done a poor job of explaining what separates them. The interface looks similar enough that most users default to Chat for everything — including work that one of the other two would handle faster, better, and without requiring the user to do any of the assembly themselves.

A recent Futurepedia breakdown cuts through the confusion with a framework worth internalizing: Chat to think. Cowork to delegate. Code to build. That's the whole map. But the details matter, so let's walk it properly.

Chat: Where the Work Is the Conversation

Chat is the product everyone started with, and for a specific category of work, it's exactly right. Brainstorming, writing, research, thinking through a decision — anything where the back-and-forth itself produces value. The Futurepedia presenter's description of it as "a thinking partner" is accurate. You ask, it responds, you refine, it responds again. The conversation is the output.

The signal that you've outgrown Chat for a given task is easy to spot once you know what to look for. As the presenter puts it: "When you start taking chat's output and assembling it into something — copying it into docs or stitching pieces together or doing busy work around the answer — that's a signal you're in the wrong mode."

That assembly work, the copying, the reformatting, the stitching of Claude's responses into a deliverable, is a tax you're paying unnecessarily. It means you handed the job to the wrong tool.

Chat is also the only product available on a free plan, which settles that question for anyone who hasn't subscribed yet.

Cowork: The Tool That Finishes the Job

Cowork operates on a different contract than Chat. You give it a goal. It builds a checklist, works through the steps, and comes back when the job is done. It can take two minutes or forty. The difference from Chat is structural, not cosmetic.

The presenter identifies three concrete distinctions. First, the finish line: "Chat is done the moment it gives you an answer, whether or not the job is actually finished. Cowork doesn't stop until the goal is achieved." Chat is optimized to respond. Cowork is optimized to complete.

Second, Cowork gets a persistent workspace — a desk it keeps working at, rather than a calculator it picks up once and sets down. It can spread research across a session, save drafts, change approach, build incrementally. Chat works in a single turn and hands the result back to you.

Third, scheduled tasks. Set Cowork up once, and it runs on its own schedule without further prompting. The example in the video is vivid: by the time you sit down with your coffee Monday morning, Cowork has already read your email threads, pulled meeting transcripts, checked client news, and left a briefing document waiting for you. You set that up once. You didn't prompt anything this week.

The question of where Cowork runs matters practically. The desktop app version works directly with your local files — you point it at a folder and it can read, edit, create, and organize everything in it. The cloud version (available via mobile and web) runs without your computer needing to be on, which is useful when you're away from your desk, but it can't reach local files in that mode. The presenter's workaround is sensible: park your working files in Google Drive, connect the Drive integration, and Cowork can reach them from any surface regardless of whether your computer is running.

Desktop is the version that requires the least setup before you can start, which makes it the natural entry point. It also integrates with broader workflow tools that Anthropic has been expanding steadily. For a deeper look at what Cowork actually costs and what the desktop app does day-to-day, the Cowork breakdown covers the practical ground this piece doesn't.

One note on availability: Cowork and Code both require a paid plan. At the time the video was recorded, mobile and web access to those products was limited to the Max plan, with Pro access described as rolling out soon.

Code: Your On-Call Engineer

Code shares its underlying architecture with Cowork — same agentic engine, same ability to plan and keep working without you — but it's loaded with a code repository instead of just files and connected apps. What that means in practice: it writes software.

The presenter's framing is direct — you don't need to be a developer to use it. You describe what you want in plain English, and Code produces working software. Internal dashboards, Chrome extensions, data scrapers, web apps, automation tools.

Here's my honest read, based on watching this category of tool evolve: Code delivers real value to non-developers, within limits that are worth being clear-eyed about. For contained, single-purpose tools — a script that pulls data from one source and formats it a specific way, a simple internal dashboard, a browser extension with a defined function — it works. The description-to-working-software pipeline is genuinely functional at that scale. Where it runs into trouble is complexity and maintenance. A non-developer can use Code to build something; they may struggle when that something needs to be debugged six weeks later, or when a dependency breaks, or when the project grows beyond its original scope. The tool removes the barrier to building. It doesn't remove the barrier to owning what you've built. That's a meaningful distinction, and it's one the marketing around tools like this has historically glossed over.

The debate between delegation and coordination that's playing out between Anthropic and OpenAI in the agentic space is relevant context here — different philosophies about what the tool should be doing on your behalf, and how much oversight you should retain.

On desktop, Code builds its project into a folder you assign it. On mobile and web, you can either remote-control a session running on your desktop computer, or work in a cloud session tied to a GitHub repository. The presenter recommends starting on desktop if you're non-technical, and that's sound advice — fewer moving parts, no GitHub account required to begin.

The Actual Costs of Getting It Wrong

The task queues versus chat interfaces question has been circling the AI productivity conversation for a while, and Claude's product lineup is essentially Anthropic's answer to it: both, depending on what you're doing. That answer is only useful if you know which mode the work calls for.

The Futurepedia presenter's summary is worth quoting whole because it earns its precision: "Chat to think — open it when the work is a conversation: brainstorming, writing, research, decisions. Cowork to delegate — open it when you'd hand this to an assistant: a goal with multiple steps and a finished deliverable at the end. Code to build — open it when the answer to your problem is 'I wish a tool existed for this.'"

The cost of getting this wrong isn't catastrophic. You don't lose data. You just spend an hour doing manually what Cowork could have handled while you were asleep — or you type up a spec in Chat when what you needed was an engineer. Multiply that by every week you use Claude without understanding what you're actually working with, and the inefficiency adds up.

Anthropic built three tools. The question is whether you're using all three, or just the one you found first.

Bob Reynolds is Senior Technology Correspondent at BuzzRAG.