Two surfaces run the same agentic engine, and only one of them can reach the folder your brief is already sitting in. That gap is the whole decision, and it is not the one the internet is arguing about. In September, Anthropic quietly deleted half of the confusion around it by merging Cowork and chat into a single product, then left the expensive half exactly where it was. If your team is still choosing between Chat and Cowork before typing, you are resolving a question the vendor closed on September 16, 2026. So which surface should carry the deck you owe on Thursday? Get it wrong and you do not lose five minutes, you lose the afternoon, because the surface you picked could not reach the files. The rule that replaces all of it takes one question to apply, and it is the one you have not been asking.
The intelligence is identical on both sides, and only the surface under it differs: what the work has to touch, where the output has to land, and what has to be able to run it again next week. Those three questions produce four answers for a marketing team, and the fourth is where I watch capable people pick wrong. Nearly every page ranking for this comparison still describes three doors, because it was published before the merge that closed one of them.
The short answer. Campaign copy, competitive research, asset production and reporting all start in Cowork. Claude Code is the right door only when the work has to touch a repository or a terminal, run on a schedule without you, or come out identical every time. The rest of this page is the reasoning, the access comparison, and the rule for switching once a task has already started.
The Routing Table: Four Marketing Jobs and the Surface to Open
Job title is the wrong axis and it always was. "Are you technical?" tells you nothing about whether a campaign brief belongs in a folder-reading agent or a coding agent. The shape of the task does, and a marketing team has four recurring shapes.
The marketing job in front of you | Open first | Why that wins, and when Code is the better door |
|---|---|---|
Campaign copy (a landing page, ad variants, an email sequence) | Cowork | Your inputs are files (brief, brand voice, last quarter's copy) and your output is a file. Cowork reads the folder and saves the finished draft beside it. Code wins only when the copy has to be generated by a script on every product release. |
Competitive and market research | Cowork | It browses with your own logged-in session, so gated pricing pages and internal dashboards are reachable, and it runs several threads at once. Code wins when the same pull has to repeat on a schedule with nobody driving it. |
Asset production (a deck, a one-pager, a spreadsheet) | Cowork | Slides, Docs and spreadsheet output arrive as finished files you can forward. Code can build the same file, and you pay the terminal and setup cost to get it. |
Reporting (the Monday readout, channel numbers) | Cowork | Anthropic's own product page demonstrates a weekly marketing readout built exactly this way, and Cowork keeps running in the cloud when you close the laptop. Code wins when the report has to run in CI, on infrastructure, with no laptop open at all. |
Read the table as a starting point, not a cage. Every row has a Code answer, and in three of the four rows that answer is "not yet, and probably never for this job." The exception is reporting, the row where a marketing team most often ends up needing Code, because a report that depends on you being awake is not a report you can trust at 8am on a Monday. Notice also what the table does not ask. A content marketer with no command line experience can own that row perfectly well if the readout lives in a folder and runs on a schedule, which is the entire argument in the marketing workflows both surfaces feed.
Claude Chat vs Cowork: What Changed on September 16, 2026
For two years the question was "Chat or Cowork", and that question is now answered, by the vendor, in writing. The announcement post is titled "Claude Cowork and chat are now one Claude", and its own explanation of why is the most useful sentence on the page: "People used both, and told us the frustrating part was deciding where a task belonged. What they'd started in one also didn't carry into the other. So we stopped making you choose."
Anthropic agreed with the frustration and solved it for the conversational surfaces only. Claude Code was not merged into anything: the help centre is explicit that "the model picker and the 'Code' tab are where they were." The rollout itself is staged rather than instant, Pro and Max first over a few weeks, and "even accounts on the same plan will see the changes at different times" before Team and Free follow. It is also one-way per account: once an account has the merged experience, "you can't switch back to separate 'Chat' and 'Cowork' options."
That matters for how you read any guide, including this one. On a Free or Team plan, or on Pro and Max before the rollout reaches you, the old two-button world is still on your screen, and the old advice about Cowork projects and separate chat threads still describes what you see. On a merged account, the distinction is gone, and Cowork projects as a separate mental model goes with it.
So the useful way to hold the three surfaces is no longer "which of these two do I open". It is two doors plus a merge, and only one of those doors is one you still have to choose deliberately. The three-way framing you may have seen as chat vs code vs cowork was correct in August 2026 and is now one door short: the first two share a surface.
What the work needs to reach | Claude (chat and Cowork, merged) | Claude Code |
|---|---|---|
Your local folders | Yes, read and write, with no upload or download step | Yes, as a working directory |
A browser carrying your logins | Yes, Claude in Chrome, including forms behind a login | No |
Desktop applications | Yes, through computer use | No |
A terminal and shell commands | No | Yes |
Git commits and pull requests | No | Yes |
Runs while your laptop is closed | Yes, for tasks that do not need local files | Yes, on CI or a schedule |
Output you can reproduce from a script | No | Yes, through |
Recurring work you schedule yourself | Yes | Yes, through |
Several guides claim plain chat has "no file access and no autonomy". That is only true of local files. Free Claude already searches the web, creates files, runs code, connects your apps and builds artifacts, and Pro adds Research, Projects and Design. The honest version is narrower: chat reaches no local filesystem and cannot run unattended. For the wider picture, see the wider assistant comparison.
Where Claude Code Still Wins for a Marketing Team
The honest half of this comparison is longer than most marketing guides admit, and it starts with what Code will not do. It will not open without setup: a shell one-liner, or Homebrew, or winget. It assumes you are comfortable with a repository as a working unit. Those two facts are the real barrier for a marketing team, and they are mechanical rather than intellectual.
Past the barrier, Code holds four capabilities nothing else in the family shares. Anything scripted belongs here, and the vendor's own examples make the shape obvious: tail -200 app.log | claude -p "Slack me if you see any anomalies" and git diff main --name-only | claude -p "review these changed files for security issues". Anything that has to run in CI belongs here too, through GitHub Actions, GitLab CI or the Agent SDK, which is how a readout keeps arriving while you are on holiday. So does anything that must be reproducible, where the same input gives the same output because the input is a script rather than a prompt you rewrote on Tuesday.
The fourth is multi-file and long-running work. Claude Code's own product page describes its job as "a bug fix, test, or multi-day migration", which is a strong signal about the shape it was built for.
It also has the widest surface list of the family: terminal, desktop app, VS Code, JetBrains, web, iOS and Android, GitHub and Slack. You can steer it from Slack if that is where your team lives. I like this about Code, and it is also exactly why nobody on my team opens it on a Tuesday afternoon. For marketing work, be precise about what the setup buys you. The vendor's comparison put it plainly: "Claude Code is built for software engineering: writing, debugging, and shipping code." Code can produce a marketing report and drop it in a folder, because it can run anything. What it cannot do is arrive without a terminal and a git-shaped mental model, which is why every row of the routing table above answers Cowork first. What Code does for a marketer, without the surface argument, is a separate read: what Claude Code does for a marketing team.
Where Cowork Wins Instead
Cowork's advantage is the surface it runs on, because the engine under it is the same one. Anthropic states it outright: "Cowork runs on the same agentic engine as Claude Code", applied to your files and apps instead of a codebase. Same loop, same planning, different thing underneath it.
What that surface gets you:
- Local folders with no upload step. "Give it a folder and the output is saved next to the inputs." For a content team, that removes the copy-paste stage of every task you run.
- A browser with your logins. Claude in Chrome reaches "vendor portals, internal dashboards, forms behind a login". Competitive research stops being screenshots pasted into a doc.
- Desktop applications, through computer use. For the tool that has no API and never will, this is the only automated path.
- Finished files, not chats. Documents, spreadsheets and decks are the deliverable. The vendor's own example points Claude at a folder of call notes and gets back "a memo on where every open deal stands", with each objection quoted from the note it came from.
- A permission model you can live with. Several tasks run at once, Manual is the default so Claude asks before acting, automated safety checks run under Auto, and deleting anything needs your approval.
- Cloud continuation, with one limit worth knowing. "More involved tasks keep running in the cloud even if you close your laptop", but "tasks that use files or apps on your computer need Claude Desktop open." If your task touches a local folder, your laptop is part of the pipeline.
Cowork is also honest about what it does not do yet. Adding from GitHub is not supported, conversation branching is not available, and Incognito chats cannot create files or run code. None of those blocks a marketing job, and all of them matter if you were planning to run Cowork as a lighter Code. For how it behaves across a normal week, start with how Cowork behaves in day-to-day work.
When to Switch Mid-Task, and How to Move Without Losing Your Context
The question usually gets answered as "when to use each", which helps you choose at the start and helps you nothing once you are forty minutes in and the task has changed shape underneath you. Here is the trigger I would give a team, and it is not difficulty.
Switch when the surface under the task changes, not when the task gets hard. A task becomes a Code task the moment it has to touch a repository or a terminal, has to run on a schedule without you, or has to be reproducible from a script. It becomes a Cowork task the moment the input is scattered across local folders and logged-in pages, or the output is a document a human will review and edit.
That rule has the useful property of being checkable in one question: what does this work have to read, and what has to be able to run it again next week? It also settles most claude cowork vs code arguments before they start, because the two sides are usually describing two different tasks.
- Cowork to Code, when the same readout has to run every Monday without you, when the volume of files passes what you want to point an agent at, or when the output has to be identical every time.
- Code to Cowork, when the artifact is a deck or a memo a colleague will edit, when the sources sit behind logins and in random folders rather than in a repo, and when a non-technical teammate has to take the task over.
Moving a task is where teams lose the afternoon, and the fix is a convention rather than a feature: keep the brief as a file, not as a conversation. The vendor's own account of the problem is that "what they'd started in one also didn't carry into the other", and the merge solved that for conversations inside Claude. It does not follow you into Code, which is a separate install with a repository as its working unit.
So the move that actually works looks like this:
- Write the brief, the constraints and the definition of done into a file inside the folder the task lives in. In Cowork, that folder is already the workspace. In Code, that file is your brief, and
CLAUDE.mdis where the standing instructions go. - Keep the inputs where both surfaces can see them. Both families read the same connectors over the Model Context Protocol, and skills carry across, so a Cowork task that has been using your analytics connector is not starting from zero in Code.
- Re-state the outcome, not the history. A prompt that says "as we discussed" has already failed; a prompt that names the input file and the output file does not need history.
- Move the artifact, not the transcript. The finished document goes into the shared folder, and the transcript is something you read once.
The one thing worth checking before you switch is model choice, because it affects cost and quality on both sides and the surface does not change it. choosing between Claude models is the piece to read once, not per task.
What This Means for a Team Rather Than One Person
An individual can hold this routing in their head. A team cannot, and the failure mode is predictable: two people run the same competitive pull on two surfaces in the same week, in two different formats, and the readout has two versions nobody can reconcile. Three conventions fix most of it.
- One folder per client or per campaign, named the same way everywhere. Cowork's whole advantage is that the output saves next to the inputs. That only helps if the inputs are not scattered across four personal folders.
- One named owner per surface. Not per tool, per surface: someone owns what lands in the working folder, and someone owns what runs on a schedule. Otherwise the scheduled job is nobody's until it breaks.
- Artifacts live in the workspace, not in a chat thread. This is the same lesson the vendor learned the expensive way before the merge. Work that only exists inside a conversation cannot be handed over, reviewed, or moved to the other door.
Which brings up the plan question, because a mixed team ends up paying for two different answers to one problem if nobody decides which door owns the recurring work. Both surfaces are included from Pro upward, and that matters more than the price itself: the plan ladder is a separate decision from surface choice, and it is covered in which plan each surface needs. The single pricing fact this page needs to carry is one sentence: Pro runs $17 a month billed annually ($200 up front) or $20 month to month, and the Max band starts at $100, reaching $200 on the 20x tier.
What a marketing team should take from all of this is that the surface is not the asset. The deliverable is. A campaign does not become better because the brief was written in the right door, and it does not become faster when two people use two different doors for the same job. That reasoning sits behind how we built our own workspace, where you describe the deliverable once and the tooling behind it stops being a decision you make every morning. The vendor merged the conversational half of this problem in September. The half that still costs a marketing team hours is the one above.
The Bottom Line
One recommendation per role, so nobody has to re-decide this next week:
- Content and campaign marketers: Cowork, always, unless the copy is machine-generated on a release cycle. Your inputs are files and your output is a file.
- SEO and PPC specialists: Cowork for the research and the readout, with Code reserved for the one report you want to run unattended.
- Agency account leads: Cowork for anything client-facing, and enforce the one-folder-per-client convention the moment a second person joins the account.
- Whoever scripts your reporting: Code, or you will rebuild the same scheduled job by hand every month and call it a process.
The routing rule in one line: open the door the output needs, and switch when the surface under the task changes rather than when the work gets hard. The merge in September made the conversational half of this decision disappear. It did not touch the half that costs a marketing team its afternoon, and that half is the one this page answers.
And the thing to hold on to past the surface question: your campaign does not care which door the work came through. It cares whether the brief, the assets and the reporting landed somewhere a second person can pick them up. Choose the surface by the deliverable, keep the deliverable in one place, and let the tooling stay a detail.
Frequently Asked Questions
Is Claude Cowork vs Claude Code still a real choice after the September merge?
Yes, and it is now the only one left. The merge combined chat and Cowork into a single surface, so the conversational half of the triangle no longer requires a decision. Claude Code was not merged into anything: the help centre confirms the Code tab and the model picker are exactly where they were.
Claude Code vs Claude Cowork: which one is better for research?
Cowork, for almost every research job a marketing team has. It drives a browser with your own logged-in session, so gated vendor pages and internal dashboards are reachable, and it runs several threads at once while saving output next to the inputs. Code becomes the better answer only when the same pull has to repeat on a schedule without a person driving it, because then reproducibility matters more than reach.
Can Cowork write code?
It can run code, and that is a different thing. Anthropic's capability statement for the merged experience includes running code as one of the steps Claude works through on its own, and the same agentic engine sits under both surfaces. What Cowork does not give you is a repository-shaped workflow: no git commits, no pull requests, no shell piping. For a marketing team that usually means Cowork runs a script and Code maintains one. If you were picturing Cowork projects as a lighter version of a codebase, that is the assumption to drop.
Do I need Claude Code if I do not program?
No, and the three marketing jobs that route to Cowork by default do not need it either. Code's unshared value is mechanical: a terminal, git, scripted one-liners, CI and reproducibility. If none of those appear in your week, adding Code buys you setup cost and a mental model you will not maintain. The one exception is the reporting row, and even there the honest first answer is Cowork on a schedule.
Can I use both surfaces on one plan?
Yes. Both are included from Pro upward, and Anthropic's own plan pages list Claude Code as included on the Pro and Max tiers. Cowork runs in the desktop app on Pro, Max and Team, with Enterprise opting in through organization settings. So the constraint on your team is not licensing, it is convention: who owns what lands in the shared folder.
Is Cowork a replacement for Code?
No. They run on the same agentic engine and are applied to different surfaces, which is why the vendor describes Code as built for software engineering and Cowork as built for non-coding knowledge work. Cowork cannot commit to a repository or run in CI, and Code cannot browse with your logins or reach files and apps on your machine. Treat them as two doors into the same building, not as an upgrade path.
Stop Deciding Which Door, Start Shipping the Deliverable
Allable gives your marketing team the routing table without the setup cost. Describe the deliverable once, and the research, the copy, the assets and the reporting run from one workspace instead of two subscriptions and a convention nobody follows. No terminal, no repository, no Plan to renegotiate when the work changes shape.
