Claude Code: How It Works and When to Use Chat, Cowork, and Code

---

I’ve been using Claude almost daily for a while now, first as an extension inside Kiro and VS Code, and later trying the full desktop app. I’ve noticed many people still see it as “an AI chat for coding”. And yes, that’s where it started, but it has become something considerably broader.

Before getting into the technical detail, I’ll answer two questions first: what Claude actually is, and the different ways you can use it. With that clear, the rest of the article makes much more sense.

1. What Claude is

Claude is the name Anthropic uses both for its language models and for the products it builds around them: they’re not two separate things, but two layers of the same thing.

Model names and power tiers change with every generation, so it’s not worth memorizing whichever is newest today. For what matters in this article, keep just this: whatever the current model is, you talk to it through different products (the claude.ai web chat, the editor plugins, the desktop app, the API…). All of them talk, under the hood, to the same model family; what changes is the interface and what each one is allowed to touch (just text, your files, your repository…).

2. The ways you can use Claude

This is where many of us get a bit lost, because there isn’t a single entry point. These are the main ones:

• Via web or mobile app, at claude.ai: free to start (with daily usage limits), no card required. This is what most people mean by “Claude Chat”. Conceptually equivalent to using ChatGPT from the browser.
• As an extension or plugin inside your editor: there’s an official Claude Code extension for VS Code and a plugin for JetBrains. And since Kiro is built on VS Code, the same extension can be installed there too, which is exactly what I’ve been using.
• From the terminal, installing the Claude Code CLI (npm install -g @anthropic-ai/claude-code).
• From the Claude desktop app: a standalone application (macOS, Windows and Linux) that brings together, in one place, the three working modes the rest of this article is about: Chat, Cowork and Code.
• Via API, for anyone who wants to integrate Claude into their own tools or automations, with a pay-per-token model.

That said, the rest of the article focuses on the three modes (Chat, Cowork and Code), which is the clearest way to understand what Claude can do for you. Whether you use them from the desktop app or access individual pieces of them from your editor or the web.

The desktop app: the three modes (Chat, Cowork, Code) switch from the top-left selector

3. CLI vs. editor extension

Are they the same thing? Almost, but not exactly. Under the hood they use the same engine (same account, same usage limits, same ability to read and edit files, run commands and run tests) and only the interface changes:

• Running claude in a terminal (yours, or your editor’s integrated one) gives you a text interface, command-line style.

The CLI in its own terminal window: same engine, no graphical panel

• The VS Code extension or the JetBrains plugin add a native graphical panel on top: visual diff review, file mentions, plan review before applying. The extension ships its own internal copy of the CLI; if you also want to use the claude command in the editor’s integrated terminal, you need to install the CLI separately.

The official Claude Code extension freshly installed in VS Code. Same engine as the CLI, with a graphical panel

In practice: if you live in the terminal, use the CLI; if you prefer seeing changes as a regular diff without leaving the editor, use the extension.

4. Chat mode: the conversation we all know

Chat mode is, plain and simple, what we know as “a ChatGPT but from Anthropic”: you write, Claude answers, and the conversation stays there. It doesn’t touch your files or execute anything on its own; if you want to do something with the answer, you copy it and apply it yourself.

It’s the right mode when what you need is to think about something, not to have something executed:

• “Explain the differences between these two architectures before I decide which one to use.”
• “Review this code snippet and tell me if you see any problems.”
• “Help me draft the reply to this client.”

Why Claude Chat instead of ChatGPT

Day to day they’re very similar: both are a chat with mobile apps, a free plan and a paid one from around $20/month, and increasingly equivalent features (Claude’s “Artifacts” and ChatGPT’s “Canvas” are the same idea; both generate images inside the conversation).

Being honest: there’s no objective answer to “which one is better”. The differences you’ll notice have more to do with writing and reasoning style, and with which ecosystem you already use, than with exclusive features. Try both on your real tasks and draw your own conclusions. Any list of “advantages” will be outdated in a few months, mine included.

5. Cowork mode: Claude working on your desktop

Cowork takes a leap beyond Chat: instead of answering question by question, you give Claude a folder and a goal, and Claude plans and executes whatever steps are needed until it hands you a finished result.

The difference with Chat is access: in Cowork, Claude can read, edit and create files in the folders you point it to, open applications and navigate the system. It doesn’t describe the steps, it executes them. It shows you the plan and the progress so you can step in if something isn’t going as expected.

Typical examples where Cowork shines:

• Sorting out a downloads folder full of invoices and screenshots, and turning them into an expenses spreadsheet.
• Taking several loose documents and generating a report or a presentation from them.
• Reading a pile of contracts or notes and returning a structured summary.

Notice that none of these examples mention “coding”: Cowork is designed for people who work with documents, spreadsheets and everyday applications, without needing to know what a repository is.

Cowork in the desktop app: one task actively running and another scheduled, without opening a code editor

Scheduled tasks: your computer needs to be on

Inside Cowork you can turn a one-off task into a recurring one, for example: “every Monday morning, review this shared folder and let me know if there’s anything new that needs my attention”. Very useful, but with a limitation you should understand before depending on it: the task runs on your own machine, so your computer has to be on and awake at the moment it’s due. If the machine is off or asleep, that run is simply skipped.

So Cowork’s scheduled tasks fit well for things like “while I work, have Claude keep an eye on this in the background”, but they’re not the right tool if you need something to run no matter what, at a specific time, laptop open or not.

One of my real scheduled tasks: a weekly CloudWatch error review. Note the history: runs marked “Skipped” are days when the laptop was off

Routines: the same, but on Anthropic’s servers

For that second case there are Routines. Conceptually they’re similar to scheduled tasks: you define a prompt, a schedule and, optionally, connectors like Slack or GitHub. The key difference is that they run on Anthropic’s infrastructure, not on your computer. That means they fire even if your laptop is closed or off, and they can also be triggered by an API call or a GitHub event, not just a schedule.

The trade-off is that, running in the cloud, a Routine has no access to your local environment or tools that only exist on your network: it works with what you give it (a repository, some connectors) and nothing else. And since it runs fully autonomously, with nobody confirming each step, it’s best reserved for well-defined tasks with a clear expected outcome: a report, a pull request, a notification.

A real Routine: every morning at 9:00 it checks official websites for a grants announcement and keeps a state file. Whether my laptop is running or not

6. Code mode: for when the work is programming

Code mode is the most technical face: it works directly on a repository, understands the whole codebase, can edit several files at once, run commands, run tests and open pull requests. It is the same engine you use when you install the Claude Code extension in VS Code, JetBrains or Kiro, just integrated in the editor instead of the desktop app.

Tasks that fit here:

• “Investigate why this test fails and fix it.”
• “Add this endpoint following the same pattern as the existing ones.”
• “Review this branch’s changes before merging.”

Code mode working on one of my repositories: branch context, accumulated diff and the create-pull-request button

How it really differs from Cowork

Under the hood they share the same agent architecture: both plan, execute multiple steps and work with tools autonomously. The difference isn’t capability, it’s what context each one is designed for:

	Cowork	Code
Unit of work	A folder with files and applications	A code repository
Concepts it handles	Documents, spreadsheets, apps	Branches, commits, pull requests, tests
Typical user	Non-technical profiles: analysis, operations, legal, marketing…	Developers
Execution environment	Your own machine	Local, remote or over SSH, your choice

In practice: if your task revolves around a repository, use Code. If it revolves around files and applications with no code involved, use Cowork. And if the work mixes both, nothing stops you from using both: for example, generating a report in Cowork from exported data, and using Code to automate that same process inside a repository.

7. Using any mode as a chat (and usage limits)

Yes, technically you can ask a purely conceptual question while in Cowork or Code. Nothing stops you. But it’s worth understanding why it’s usually not worth it.

The three modes share the same usage quota from your subscription (a rolling 5-hour window plus a weekly limit). It’s not that Chat has its own quota and Cowork a different one: it’s a single budget for everything. The difference is that Cowork and Code are agents that plan, read files, run tools and sometimes retry steps, so the same question burns through that budget much faster in Cowork or Code than in Chat, even if Claude ends up not needing to touch any file to answer you. That’s why the practical approach is to save the more autonomous modes for when you actually need them, and use Chat for everything that’s just thinking or writing: your quota goes further and, as a bonus, you’re not giving access to your files or repository unnecessarily.

The best part is you don’t have to guess any of this: Settings > Usage shows the real-time breakdown. This is my account on a normal working day:

Current session consumption (the 5-hour rolling window) and weekly limits, in Settings > Usage

Three details on that screen worth looking at:

• Two different clocks: the “Current session” bar (the rolling 5-hour window) and the “Weekly limits” bars reset independently. You can exhaust a session and still have plenty of week left, or the other way around.
• Top-tier models get their own bar: in the screenshot, “All models” is at 46% but “Fable” (the Mythos tier) is already at 72%. The most powerful models burn through their own limit much faster. One more reason not to use the most expensive model for trivial questions.
• Usage credits: the toggle at the bottom lets you keep using Claude on a pay-as-you-go basis when you hit a limit, instead of waiting for the reset. Useful as an occasional relief valve; if you find yourself enabling it often, upgrading your plan probably pays off.

One nuance about plans: the free claude.ai plan only includes Chat, with fairly low limits. Cowork and Code require a paid plan (Pro or above); from there, all paid plans get the three modes with the same features, and the only thing that changes between Pro, Max and Team/Enterprise is how much shared budget you have before waiting for it to renew.

8. Which mode for each case

Summing up in one sentence per mode:

• Chat, when you need to think out loud, compare options or draft something specific, and the result stays in the conversation.
• Cowork, when you want to delegate a complete task over your files or applications and receive a finished deliverable, one-off or recurring.
• Code, when the work is about a repository: writing, reviewing or maintaining code.

And within recurring work: Cowork scheduled tasks if it needs to touch things on your machine and running while you work is enough; Routines if it must run no matter what happens to your laptop, or be triggered by API or GitHub events.

9. An AWS example: a daily error report from your logs

Since this is an AWS blog, let’s bring it down to earth with a real case: I want a daily report with the relevant errors from my CloudWatch logs from the previous day.

This is infrastructure work, so it fits Code mode (or its editor extension), leaning on an MCP server that gives Claude read access to CloudWatch. Anthropic and AWS maintain several official MCP servers for this, for example cloudwatch-mcp-server, which exposes tools to list log groups and query them.

The important points when setting it up:

• Use a technical user or role with minimal permissions, read-only over CloudWatch Logs (no administrator credentials). Configure it as an AWS profile (AWS_PROFILE) and pass it to the MCP server via environment variables.
• Give it general instructions, not an exact list of log groups. It’s tempting to write a hyper-specific prompt (“query log group X, filter by Y”), but that’s fragile: as soon as you add a new service, you’ll have to remember to update the prompt. Something like this works better: “Review the production log groups from the last 24 hours, identify the most relevant errors grouping them by cause, and generate a brief summary with the log group, the number of occurrences and one example of each error type.” Claude uses the MCP tools to discover which groups exist and decides how to query them.
• If you genuinely want to narrow the scope (for example, keeping it away from test environment logs), state that explicitly in the prompt or enforce it with the technical user’s IAM permissions.

My real implementation of this example: the CloudWatch error review executed via the AWS API MCP Server. 80 log groups analyzed and errors grouped by root cause

And here comes the Routine vs. scheduled task question: since you want the report generated every day no matter what happens with your laptop, the answer is a Routine, with a scheduled trigger (say, every morning at 7:00) that publishes the result to Slack or email.

If instead what you want is to trigger it yourself, whenever you decide, without depending on a schedule, the best option is a Routine with an API trigger: you get an endpoint for it, and whenever you want the report, you make an HTTP call to that endpoint (from a script, a button, or even by hand). Since it runs on Anthropic’s infrastructure, it doesn’t depend on your machine being on, and you don’t have to wait for a scheduled time.

To see one example of each mode applied to AWS, not just the Code one:

• Chat: you paste a CloudFormation error message or an IAM policy that doesn’t add up, and ask it to explain what’s going on and why. It doesn’t need to touch your account, just reason about the text you give it.
• Cowork: you have a folder with AWS Cost and Usage Report files downloaded month by month, and you ask it to review them and build a per-service spend summary in a spreadsheet. It works on local files, no AWS account connection needed.
• Code: the log report example above, or asking it to review a Terraform or CDK template before applying it, leaning on the AWS MCP servers for IaC.

10. Subscriptions

The numbers change fairly often, so treat these as an orientative snapshot and always confirm at claude.com/pricing:

• Free: Chat only on claude.ai, with a fairly low usage limit and no access to Cowork or Claude Code.
• Pro (around $20/month): unlocks Cowork and Claude Code (CLI, editor extensions and desktop app), with a usage budget shared across the three modes.
• Max (two tiers, 5x and 20x): same features as Pro, but with 5 or 20 times more usage budget for intensive sessions.
• Team and Enterprise: designed for organizations, with centralized billing, seat management and admin controls.
• API: pay per token consumed, meant for integrating Claude into your own tools or large-scale automations. It’s a completely separate billing system from the subscriptions.

To put my own case on the table: I’ve been paying for the Pro plan for five months (€18/month in Europe) at the time of publishing this, and it’s the plan I work with daily. The usage limits screenshot above is from that account. For intense but not industrial individual use (daily Code sessions, constant Chat), Pro holds up well; the weekly limit only starts to bite on days with very long sessions on the big model.

Routines consume from the same Claude Code usage budget of your plan, so if you plan to automate a lot with them, keep an eye on it.

11. Claude Code vs. ChatGPT (Codex) vs. Kiro

To close, the question you’re probably asking yourself: if you already know Kiro (which I covered in this article) and you use or have tried ChatGPT, why choose one or the other? There’s no absolute answer, without trying to crown “the best one”:

	Kiro	Claude Code	ChatGPT (Codex)
Built by	AWS	Anthropic	OpenAI
Designed for	Structured development: specs, steering, hooks	The whole spectrum: chat, non-technical tasks (Cowork) and code (Code)	Ground very similar to Claude Code: CLI, editor extension, cloud tasks
Strength	Very polished integration with AWS (CDK, Terraform, native services) and traceability of requirements	Covering a wide spectrum with a single product, with Routines to automate without depending on your machine	Convenient if you already live in the ChatGPT ecosystem daily

My recommendation: if you have access to all three, try them on a real task from your daily work and compare the result, instead of trusting comparisons (including this one). These tools move fast, and what’s an advantage today may not be one in a few months.

12. Conclusion

At the start of this article I mentioned that many people still see Claude as “an AI chat for coding”. By now I hope it’s clear why that idea falls short: the same Claude that helps you draft an email is the one that reviews your pull request or sorts out a folder full of invoices. What changes is the mode, not the tool.

If you only take one thing from this: the next time you open Claude, before writing the prompt, take a second to think about which mode you’re opening it in. That choice (more than the prompt itself) is what decides whether you feel Claude is genuinely helping you or you’re just having yet another conversation.