Claude Code vs Cowork for Marketing Teams: A Field Guide from the Director’s Seat

The question came up about forty minutes into a working session, in a conference room, with a company I have been helping all year. We were mapping out what they should standardize on. Someone leaned back from the table and asked the thing this whole guide turned out to be an answer to.

Can’t you just do what’s in Claude Code with Cowork?

My immediate answer was no. I didn’t say it.

I didn’t say it because an instant no is a bad habit wearing the costume of expertise, and because my no had a hole in it. I knew what both tools felt like in my hands. I had never sat down and worked out how much of what I do in the one could genuinely be done in the other. So I said I wanted to think about it properly and come back with something better than a reflex. Then I went and did that. I ran real jobs through both chairs, read the documentation I had been too busy to read, and counted what my own setup is actually made of.

This guide is what came back. I’ll put the conclusion up front, because it is a larger claim than the question invites. Claude Code may be the single most important competitive advantage a knowledge worker can have right now. Not an engineer, and not a person who wants to become one. Anyone whose work comes out as documents in folders. The whole claim lives in the second half of the sentence, though, and the second half is: if they can figure out how to use it. Most people never get that far, because the name tells them not to try.

What I saw in my head when the question came was a Sunday morning a few weeks earlier. Eight terminal windows open on the laptop at the kitchen table, three of them working. One rendering a batch of ads for a client. One drafting replies to Friday’s email. One reconstructing the week’s billable hours out of git commits and calendar events, because I stopped keeping a timesheet in June. A small script I wrote in July was reading the whole fleet’s status aloud so I could stand at the stove instead of squinting at a screen. One of my kids came down the stairs, looked at the laptop, saw that nobody was typing, and asked what I was doing.

That picture is the argument. I just couldn’t hand it across a conference table yet.

Not assisted by AI. Directed.

That room was not unusual. I have spent most of this year helping people and companies work out what to actually do with AI, and some version of the same question arrives in every one of them inside the first twenty minutes. Do we need the coding one, or is the one built for us enough? Underneath it sits an assumption that the two do roughly the same thing, and to a point that assumption holds up fine. Where it stops holding up is the subject of this guide. Not which tool wins. What each layer is for, why they belong together, and why the top one can change the shape of a professional life.

The thirty-second answer

The worst-named products in tech

Let’s clear the objection first, because it is the objection everyone has, and it is baked into the name.

When I say “Claude Code” to a marketing director, a program manager, a writer, the face does the same thing every time. A polite closing. The words land as “that one is for the engineers,” and the conversation moves to the tool that sounds like it was made for them. I understand it. I did it myself for the better part of a year.

Claude Code is not for code. The name is a historical accident. It launched as a tool for programmers and turned out to be a general-purpose agent that lives inside your files. Lenny Rachitsky’s advice is to forget the name and think “Claude Local”. Anthropic’s own growth marketer, who had never written a line of code, built the team’s ad-variation tools in it inside a week. His line: “You don’t need to know how to code. All you need to know is how to explain your challenge.” As of this summer the desktop app bundles it, so the terminal is optional. You can open it like any other app.

Cowork launched in January as, in Anthropic’s words, “Claude Code for the rest of your work.” It is the same agent with a friendlier room: a desktop window instead of a terminal, a sandbox instead of your raw filesystem, and connectors to Notion, Slack, Drive, and the rest already wired in. You give it a folder and a goal. It works, and a document comes back.

Then there is plain Claude, the chat window. Where most people still live.

Here is the way I hold the three in my head. Picture a film set.

• The audience sits in the theater and watches the finished cut. That is chat. You ask, you receive.
• The producer’s office briefs a crew in the morning and reviews the dailies at night. That is Cowork. You hand off, the work happens elsewhere, the result comes back.
• The director’s chair is on set, watching every frame as it is shot, calling the take. That is Claude Code. You see the work. You can stop it mid-shot.

Ethan Mollick put the split in one sentence in his summer guide: some tools emphasize the finished result, others expose the work itself. Everything in this guide follows from which of those you need for a given job.

The debate in every room: do we need the coding one?

The version in that conference room is the version I hear everywhere. A team has been using chat for a year. Someone has tried Cowork and liked it. The leadership question is whether to standardize there or push people toward Claude Code, and the honest answer from most of the room is that nobody can see the difference. They can get a brief written in either. They can get a deck out of Cowork faster. Claude Code has a black window and a name that sounds like it belongs to another department.

They are right about the first week. Most of what a marketing team does in a given week comes out of either tool at about the same quality, and if that were the whole story, the choice would not matter and this guide would be a paragraph.

What I have watched, in my own work and in the companies I have helped, is that the difference does not show up in a week. It shows up over months, and it is the difference between a team that uses an AI system and a team that has one. Here is what the Claude Code layer adds, argued from the rooms rather than the docs.

Knowledge work is already file work. A marketer’s output is documents in folders: briefs, frameworks, email series, ad copy, decks, the transcript of the call where the client said the thing that becomes the headline. Chat cannot see any of it. Cowork can see a folder you hand it. Claude Code lives in the folders, all of them, with the history of every change. The name says code. The product is a colleague who works inside your filing cabinet. That is not an engineer’s need. That is a writer’s need, and it was mine before I knew the tool existed.

Cowork lets you use a crew. Claude Code lets you hire one. This is the distinction that took me longest to see. In Cowork you are handed skills and connectors someone else packaged. Good ones. In Claude Code you write the skill, install the gate, and wire the loop. The difference is the difference between an employee who uses the company’s system and the person who designed it. Every knowledge worker I know has a repeatable deliverable and an opinion about what makes it good. That is the whole job description for building a crew. The engineering was never the hard part. The taste was, and the taste is already theirs.

Corrections compound, but only in one chair. Chat forgets you at the end of the conversation. Cowork remembers a project. Claude Code lets a correction become a file, and a file become a rule, and a rule become a script that refuses to pass a bad draft. A marketing lead at a client described her team’s current method to me as “form your own opinion based on a Word doc you probably skim at best.” The distance from that to a system that carries every correction the CEO has ever made is not a better prompt. It is the ability to install the correction somewhere it cannot be skipped. Only one chair has that.

You see the work, so you learn to direct. The friendliest thing about the producer’s office is that the work happens out of sight. That is also the trap. When I watch the crew open the old framework instead of the new one, I learn what context it needed. When I watch it drift in paragraph three, I learn where my brief was vague. Six months of watching is how I became someone who can write a call sheet a crew can shoot from cold. You cannot learn that from a finished document. The director’s chair is a school, and the tuition is paying attention.

The barrier is psychological, not technical. A marketing columnist who built a 36-skill system put it as “if you can write a brief, you can use Claude Code.” Teresa Torres, who teaches product people for a living, calls it a willingness to try three or four simple commands. Anthropic’s own growth marketer had never written a line of code and shipped his first two workflows within a week. A reviewer at XDA who does not code found Claude Code better than Cowork for batch administrative work, and said the payoff came from one configuration file. The terminal is now optional. What is left of the barrier is a black window and the belief that it belongs to someone else.

I gave a lunch-and-learn to a marketing agency last month and asked everyone to rate their own AI ability from one to five before I said a word. Every answer was a three. These were people who had wired an agent stack into Slack and built call-scoring rubrics. Still threes, because when the talk turned to creative work, the confidence fell through the floor. The tool they had not tried was the one with Code in the name. I wrote that hour up as its own guide. The short version is that the gap between feeling like a three and feeling like a five is not a tool problem. It is context, taste, and the willingness to build. Two of those three only exist in one chair.

None of this makes Cowork the lesser tool. It makes it the layer most people should live in most of the time, fed by a layer above it that someone on the team has to run. Not everyone has to be that someone. But the right someone is the person who knows what good looks like, because the crew they build carries that judgment to everyone else. The rest of this guide is what the top layer looks like from inside, and then how the layers fit.

The director’s seat is two jobs, and only one of them is on set

The metaphor is doing real work here, so let me define it properly, because most of the “you are now an orchestra conductor” essays float off into the symphony and never touch a file.

A director works in two modes.

On set. Synchronous. The camera is rolling and you are watching the monitor. You say “again,” you say “tighter,” you say “cut.” In Claude Code this is a live session: you give it a brief, you watch it read the files, run the script, draft the copy, and you interrupt when it drifts. The permission prompt is the moment the crew turns to you and asks. I wrote about this in the fleet piece: treat the permission prompt as the real work, because it is the moment the machine actually needs a human.

In the production office. Asynchronous. You wrote the call sheet the night before. The crew shot the scene while you were in a meeting. Now you are looking at dailies and deciding what goes in the cut. In Cowork this is the whole product: brief, walk away, review. In Claude Code it is background agents, scheduled routines, and the loops that run while I’m at the stove.

The mistake people make with the conductor metaphor is imagining the director as the person who knows how to operate the camera. Nobody asks a director to. What the director owns is the brief, the taste, and the cut. Those are the three things I have kept for myself, and everything else has been hired out.

The crew, by name

Here is what “hired out” means. Every skill in my setup is a role. A skill is a short markdown file that tells the agent what a job is, when it applies, what it may read, what it may touch, and what done looks like. There are forty-two of them in my studio. Twenty-two I wrote; twenty are design taste packs I installed, which I think of as freelancers with strong opinions. The ones I wrote, in plain language:

• Brand editor (one per client). Applies the full voice and design system to any copy. The strictest one carries twelve hard bans on AI-sounding constructions and runs a linter on every save.
• Program copywriter. Maps a messaging framework onto a copy template and verifies character counts with code, because a human counting characters is how errors get in.
• Ad production line. Three skills in a chain. The first reads the client’s request queue without me. The second runs a plan-build-grade loop against eight design rules learned from three stakeholders. The third deploys a review gallery.
• Motion studio. Turns still ads into storyboarded video. I wrote up the pipeline here.
• PR desk. Press release, social, partner emails for a new partnership announcement. “Same game plan for a new school.”
• Ghostwriter. Writes in a client executive’s voice from a profile built out of their real interviews. The skill never restates the voice; it points at the file.
• Email chief of staff. Reads my inbox, finds threads waiting on me, leaves drafts. It is not allowed to send. That line is in the skill in capital letters.
• Comment wrangler. Pulls every open comment on a client Google Doc into one brief, waits for my call, then applies the edits.
• Time reconstruction. Rebuilds the week’s hours from the trail the work already leaves. Full story here.
• Finance close, agency and household. Walks the monthly close one section at a time and rebuilds a dashboard.
• Taste librarian. Keeps a library of styles with my verbatim reactions, builds moodboards, and builds side-by-side labs when a decision is stuck.
• Security reviewer. Pre-ship audit for exposed keys. The skill’s last line is “Don’t let Joe be the cautionary tale.”
• Quality-gate reviewer. One agent plans, one builds, a third grades in a fresh context and sends feedback. It loops until pass or four rounds.
• Ops manager. Reads the register of recurring processes, audits memory against reality once a month, runs the daily stand-up.

Each of those replaced a person, a freelancer, or a step I used to do badly at eleven at night. None of them replaced the decision about whether the thing is good.

When the crew has to come to the director

Mollick’s most recent essay draws a line I’ve adopted as a standing rule. He contrasts the “dark factory,” where no humans work, with the “twilight factory,” where agents know when to pull a person in. His four moments are the ones I now write into every skill: the crew comes to the director for authorization, for expertise it lacks, for a perspective it can’t generate, and for decisions that are interesting. Everything else, it should handle. Routing and remembering are transport and clockwork. Keep yourself on the gates and get yourself off the wires.

A Tuesday with the crew

Abstract workflows are useless, so here is one deliverable, start to finish, from last week. A client asked for a batch of fourteen ad concepts for two certificate programs. Here is what happened, in order, and where I stepped in.

Before coffee. The intake skill runs on its own. It opens the client’s request board in the browser, because the connector can’t see that workspace, reads the card, resolves every link on it: a Loom transcript, the messaging framework in Slides, two Figma frames it captures by zooming, the last batch’s top performers. It writes all of that into a source pack and a status file that says what it found and what it couldn’t. I read the status file on my phone. Two frames missing. I capture them by hand. Ten minutes.

Mid-morning. I fire the batch skill. It launches the plan-build-grade loop. A planner writes the checklist from the source pack and the eight design rules the client’s stakeholders have given us over two months (“headline does the work, cut anything the eyebrow already says,” “no CTA-shaped text on the image,” “a stat is a headline plus urgency, nothing else”). A builder renders fourteen concepts. A grader in a fresh context checks every PNG against the checklist: exact dimensions, headline visible and verbatim, every line traceable to the framework. Three fail. The builder gets the feedback and re-renders. I’m in a client meeting for all of this.

After lunch. The gallery is on a private URL. This is the gate. I look at fourteen ads the way I would look at dailies. Two are good. Nine are fine. Three are wrong in a way the grader could not see: the concept is technically compliant and emotionally dead. I kill the three and send one back with a note: “the second line is explaining the first line. Cut it.” That is a taste call. It is the one thing in this whole Tuesday that required me.

Late afternoon. The brief goes to the client’s Notion in their lean format, screenshots instead of links because their thumbnails cache. The memory file for that client gets one new line: what the stakeholder said about the ad that got killed, and the rule it becomes.

Total time from me: under an hour, spread across the day, all of it deciding. The crew did the reading, the rendering, the checking, and the filing. A year ago this was two days and a designer.

Notice what was on set and what was in the production office. Intake and the batch loop ran unattended. The gallery review was me at the monitor. That split, not the tool, is the thing to design.

What each chair actually gives you

Let me be straight about what this section is and is not. I did not stage a bake-off, put both tools on a stopwatch, and score the output. Plenty of people have run those, and the results mostly say what you would expect: on any one task the two land in the same neighborhood. The difference that matters was never the output anyway. It is what you can see while the work happens, and what you are able to change once it has.

So take the job every marketing team has, and look at what each chair hands back. The third email in a nurture series, drafted from the program’s messaging framework, in the brand voice.

What Cowork gives you. You point it at the folder holding the framework and the voice guide, you give it the brief, and you walk away. A document comes back. If the folder is good, the email is good, the way a competent freelancer’s first draft is good. What does not come back is the reasoning. Which files it opened. Whether it read the current framework or last quarter’s. What it decided to leave out. If it uses a phrase the CEO has vetoed, you find out when the CEO does. You can fix that draft. What you cannot do from there is install something that stops the next one.

What Claude Code gives you. This half I can describe from my own studio, because it is what happens here most weeks. I watch it open the framework. I see it read the voice skill. It drafts, and on save a hook runs the linter I wrote. On a client email last month that linter came back with three hard hits: an antithesis pivot the client hates, a banned word, and an opener that set a scene instead of making a point. The agent fixed all three before I ever saw the draft. I read it, said “she never says ‘unlock,’ kill it everywhere,” and the word went into the banned list. No email since has contained it.

That last sentence is the whole difference, and notice that it is not a claim about draft quality. It is that a correction stopped being something I have to remember and became a rule, in a file, that every job after it has to get past.

A correction, installed — in one chair the note is a reminder someone has to remember to read; in the other it becomes a rule the next draft cannot get past

Here is the one table in this guide. The rows are what a marketing team actually asks.

Two things in that table surprised me in the research. First, the Office skills that make Cowork’s decks and spreadsheets look finished are not shipped in Claude Code; you install the open-source versions yourself. Second, Anthropic’s own documentation now describes “Cowork sessions” as a mode Claude Code runs in, which means a skill you write in one loads in the other. The crew is portable. The chair is the choice.

So the decision for any single job is two questions.

1. Does the job need a rule enforced, a script run, or a pipeline? If yes, Claude Code. Someone has to build the gate, and gates live in files.
2. Do you need to see the work, or do you need the result? If the result is enough, and the stakes are low, Cowork. If you would want to stop it mid-take, Claude Code.

And the decision for a person is one question. Do you have a deliverable you make more than once and an opinion about what makes it good? If yes, you belong in the Claude Code layer for at least part of your week, whatever your title says. The job questions above will route your low-stakes work to Cowork anyway. Working in the top layer is what lets you build the thing that makes the Cowork layer good for everyone else.

A layered AI strategy

“Layered” gets said a lot and defined rarely, so here is what I mean, with the film set as the map. Four layers. Everyone touches the bottom one. Fewer people touch each layer above it. Work flows down; corrections flow up.

Layer one: the foundation. The context. Folders, a short operating file per world, a voice guide built from real writing, a brand guide, the transcripts, the memory of what has been decided. This layer is not a tool. It is files, and it is the thing every layer above reads. A team without it gets generic output from every tool it tries, and then blames the tool. I have written about this layer more than any other, in The Company Is the Context and the content-stack guide, so I will only say here that it is where most of the outcome is set before anyone types a word.

Layer two: the conversation. Chat. Questions, thinking out loud, a one-off draft, a summary of a call. The audience seat. Everyone uses it, and it is not going anywhere. What it cannot do is carry the foundation with it or leave anything behind.

Layer three: the counter. Cowork. The producer’s office. A person brings a job, points at a folder, and gets a deliverable back: the brief, the deck with working formulas, the first draft of the email series, the weekly report. It runs the skills and connectors it is handed. It schedules tasks in the cloud. It is where a marketing team should spend most of its AI hours, because it is fast, it is safe by default, and it does not require anyone to watch. Anthropic’s own marketing ops team runs weekly reporting and campaign builds here, and cut a two-day metrics review to two hours. That is the counter working as designed.

Layer four: the studio. Claude Code. The director’s chair. This is where the skills that the counter runs get written, where the gate that refuses a bad draft gets installed, where the loop that reads the request queue at six in the morning gets wired, where the batch of forty ads gets planned, rendered, graded, and filed while the director is in a meeting. It is also where corrections go to become permanent. When the CEO vetoes a phrase, the studio is where that veto turns into a line in a skill and a check in a script, and from then on every layer below inherits it. One or two people per team live here. Over time, more.

The layers are not a ladder you climb and leave behind. I use all four every day. What makes it a strategy rather than a pile of tools is the direction of flow. Skills, gates, and context flow down, from the studio to the counter to the conversation, so that the whole team works from the same foundation. Corrections, results, and learnings flow up, so that the studio can turn them into the next rule. Anthropic’s own marketing department is the clearest public example: an ops team living in Cowork, fed by one growth marketer who built their tools in Claude Code without ever having written code. Same engine, two layers, one person with taste at the top.

The failure mode is not picking the wrong tool. It is running only layer three and wondering why the output never gets better. The counter cannot improve itself. Somebody has to be in the studio.

Where it goes wrong

This section is longer than the praise, on purpose. Simon Willison’s rule for reviewing these tools is to spend more words on the risk than on the demo, and he is right.

The crew will read anything, including instructions hidden in the material. Two days after Cowork launched, a security firm put invisible text in a Word document that made the agent quietly send a file to a stranger. Anthropic’s own safety page says no defense is perfect. This applies to both chairs. A crew that reads your Drive will read a document a stranger shared into it. My rule: nothing that can send, publish, or pay runs unattended. The email skill drafts. It does not send. The deploy step waits for a human. Those are not features. They are the lines I drew after imagining the alternative.

Tokens are the budget, and the meter is hidden in one chair. Cowork burns usage faster than chat, and the meter is not on the wall. Claude Code shows you the context gauge; you can watch it fill. A creator I read trimmed a 22,000-word instructions file to 2,000 after realizing every session was paying for it. My sixteen-line global file exists for the same reason. Every line loads every time. Every line pays rent.

The crew will do exactly what you said. A user told an agent to “clean up” under auto-approve and lost eleven gigabytes. I once linked a deploy to the wrong folder and served an entire repository to the public for six days before I noticed. That mistake is now a memory file, and the memory file is now a rule, and the rule is why the deploy skill checks the folder before it runs. The pattern is the point: the fix for a mistake is never “be more careful.” It is a file.

Taste does not enforce itself. This is the one that cost me the most. A client flagged the same problem in our copy five times over two months: a cadence that sounded like a machine, especially the “not this, but that” pivot. Each time I said I’d fix it. Each time I put a note in memory. Each time it came back, because memory loads by relevance and on a given day it can be skipped. The fix that held was moving the rules into the always-loaded skill and writing a script that checks every save and refuses to pass a hard hit. A memory file can be skipped. A skill plus a script cannot. It took five corrections to learn that the director’s taste has to be a gate, not a reminder.

The bottleneck is the director. Here is my confession, since the guide asked for everyone else’s. The crew is fast. I am not. I skip the plan when I’m excited. I accept a draft that is fine because it is Tuesday and the gallery has fourteen tiles. I run eight sessions because I can, and then I answer permission prompts like a man swatting flies. The tool did not create these habits. It made them expensive. The hardest thing I’ve had to build is not a skill. It is the patience to let the planner finish before I say go.

Your first twenty minutes

If you have been living in the conversation and counter layers, here is how to add the studio. Start in Cowork for a week if the black window is the thing stopping you. Learn the shape of briefing a crew and reviewing what comes back. Then open the studio, because a week is enough to feel where the counter’s ceiling is. Three doors in. Pick one.

• The desktop app. It has a Chat tab, a Cowork tab, and a Code tab. Start in Cowork with a folder that holds one real thing: a brand guide, a past campaign, a set of interviews. Ask for a deliverable you’d actually use.
• The terminal. If you can type cd and a folder name, you can run Claude Code. It is one install and one word. Everything after that is English.
• The Code tab in the app. The middle path. The director’s monitor without the terminal.

One rule, from the person who built the tool: plan first, then let it run. Ask for the plan. Read it. Then say go. It is the read-through before the shoot, and skipping it is how every bad take starts.

Five things I did with it this month, so you have a scale:

1. Rewrote a nine-email nurture series for a client from an updated framework, with the linter catching what my eye had stopped seeing.
2. Ran three ad batches for three programs, each from a request card to a review gallery, mostly while I was in meetings.
3. Turned a forty-minute stakeholder call into a strategy document in the CEO’s required format, with owners and dates, in an afternoon.
4. Reconstructed four weeks of billable hours and signed off on them in ten minutes on a Friday.
5. Built this guide: three research agents ran in parallel while I read the transcripts.

What’s left for the human

Willison named the feeling in February. He called it “Deep Blue”: the ennui edging toward dread that a craftsman feels when the machine walks into the craft. I felt it. Twenty-one years of being the person who could write the sentence, and now a crew that writes sentences all day while I stand at the stove. Turning forty in the middle of it did not help.

Here is where I landed, and it took the whole year. What stopped mattering was the syntax. What did not stop mattering was the judgment about which sentence is true. The director does not operate the camera, and nobody questions the director’s value. Dan Shipper’s company automated everything it could and found more human work waiting, not less. My version: the crew made the loop fast enough that taste gets to run more laps. The scarce thing was never the doing. It was the deciding.

The other question from that same room came from the CEO, near the end. She wanted to know whether a system could ever produce copy that passed her sniff test without her in the loop. The honest answer was tiers. For volume copy, headlines and subject lines, the crew produces ten and a person picks two, today. For drafts, the crew writes and an editor passes, and we measure how much she changes. For positioning, for what a program is and who it is for, a human decides in a room, and the crew prepares the inputs. The system is not a self-driving marketing department. It is a very good crew with a director who still has to show up.

Which brings me back to the conference room, and to the question I didn’t answer on the spot. Here is the answer I owed that table. Mostly, yes, you can do it in Cowork, for any one job you can name today. And no, you cannot build what I have in it, because the building is the part that happens in the other chair. Both tools are good. Use both. But the one with Code in the name was never only for the engineers. It was for the person with a filing cabinet full of work and an opinion about what good looks like, the person who wants an AI system that gets better every month instead of one that stays exactly as good as the day it was installed. That person was me. It is probably you. I’m working. What I’m doing is deciding. It looks like nothing, and it is the whole job.

Notes on the process

This guide was made the way it describes. Three research agents ran in parallel: one built the objective comparison from Anthropic’s documentation and a dozen third-party reviews, one hunted down nineteen published pieces to model and three to avoid, one read my own setup and counted the crew. I read all three, wrote the outline by hand, and drafted from it in a live session, on set. The linter I built for a client ran on every save. It flagged one hard hit, a banned word I had quoted on purpose, and twenty-six soft ones, most of them sentences that start the same way three times in a row because I like the rhythm. The kitchen-table scene, the confession, and the closing are mine. The table and the citations are the crew’s, checked by me. One more thing, since this guide keeps insisting on showing the work. The comparison section describes Cowork from its documentation and my own use of it, not from a staged head-to-head, and it says so in the section itself. The Claude Code half is from the live system. I would rather tell you that than imply a bake-off I never ran.

One essay, every Sunday morning, on family, AI, and creativity. Written by the human in the loop.

— Joe