Claude Code vs Cowork
I’ve been using Claude Code so much lately that I almost missed how Claude Cowork has been quietly adding new features. Yesterday I noticed it now has scheduling, and it’s getting better fast. I started wondering whether I should split my work between the two, or whether Cowork might be a better recommendation for friends who haven’t done programming. So I compared them from a developer’s perspective.
Claude Cowork and Claude Code
Cowork spins up a lightweight Linux VM on my Mac and runs code inside it. Only the folders I choose get mounted into that VM, so it can read and write those files. That’s the “sandbox.” It’s safe. Even if something goes wrong, my computer stays untouched.
But there are limits. External server access is restricted, so deployment tasks like git push or vercel deploy don’t work. You can run npm run build to produce build artifacts, but pushing them out to the world is on you. The local dev loop of spinning up a server and checking it in a browser doesn’t work either. No Docker, no databases. Files outside your selected folder are simply inaccessible.
Claude Code is different. It runs directly in my local terminal, so it can access the entire file system, do git push, spin up servers, run Docker. cd ~/other-project and you’re in another project. The freedom is incomparable to Cowork.
So why use Cowork at all? The big thing is zero setup. Gmail, Google Calendar, and Google Drive are connected via MCP out of the box, and document generation skills are built in. You can do all of this in Claude Code too, but you have to set up MCP yourself and write scripts. (Though honestly, you can just say “connect it” and it’ll set up MCP and write all the scripts for you.)
There’s also a difference in token consumption. Cowork carries heavy system context every turn. Safety rules, file handling rules, skill lists, MCP tool definitions (Gmail, Calendar, Drive, Chrome automation, etc.) — all of that goes into the context. Claude Code is relatively lightweight, mainly just CLAUDE.md and tool definitions. The same task costs more tokens in Cowork. Since it runs under the Pro/Max plan, it doesn’t cost extra money directly, but higher token usage means you hit rate limits sooner. Effectively, it is a cost.
Through the Lens of the OSI 7 Layer Model
If you study networking, you encounter the OSI 7 Layer model. It’s a framework that explains communication in seven layers, from physical electrical signals (Layer 1) up to the applications users interact with (Layer 7). The reason I first thought of this model was to explain to friends with no programming experience why they should work in the “terminal.” I wanted to show them what this scary black window — where it feels like typing anything could break something — can actually do, and that everything we’ve been using on computers has always been the Application Layer.
Layer 7 Application "Build me an extras cost calculator"
Layer 6 Presentation JSON, CSV, docx conversion
Layer 5 Session Terminal sessions, OAuth authentication
Layer 4 Transport npm install, pip install
Layer 3 Network git push, vercel deploy
─────────────────────────────────────────────
Layer 2 Data Link MAC addresses, frames
Layer 1 Physical Cables, electrical signals
In truth, Cowork does touch the lower layers internally. It runs bash inside a VM, executes Python, runs npm install, and manipulates the file system. Layers 5 through 7 are actually working. The difference is that Claude does it on behalf of the user. The user says “do it” at Layer 7 and receives the result. What happens in between is invisible, and there’s no need to know.
Claude Code is different. It starts at Layer 7, but the user goes down the layers themselves. They see data formats being converted at Layer 6, terminal sessions opening at Layer 5, packages being installed at Layer 4, and code being deployed at Layer 3. Layers 2 and 1 are hardware territory and generally untouched, but everything down to Layer 3 is within real reach.
Chat Cowork Claude Code
Layer 7 Application ✓ ✓ (user) ✓ (user)
Layer 6 Presentation ✓ (Claude) ✓ (user)
Layer 5 Session ✓ (Claude) ✓ (user)
Layer 4 Transport △ (Claude) ✓ (user)
Layer 3 Network ✗ ✓ (user)
The difference isn’t just “how far down you can reach.” It’s “who experiences each layer.” Cowork reaches down to Layer 5, but Claude does it for you. Claude Code reaches down to Layer 3, and you do it yourself.
Honestly, these layers aren’t that hard to understand. What git push does, what a terminal session is, what npm install actually installs — go through it once together and it clicks fast. It’s not difficult. It’s just unfamiliar. That’s why I dislike the term “non-developer.” They’re just people who haven’t experienced the lower layers yet, not people who can’t understand them.
Cowork is a tool where Claude handles the lower layers for you. Claude Code is a tool that lets you go down to the lower layers yourself.
What I’ve Been Doing Lately
I’ve been teaching Claude Code to non-developers lately. (I don’t really like the term “non-developer.” They just don’t do programming/IT as their profession — that doesn’t mean they’re not makers.) I’m helping them connect AI directly to their own work.
For a drama PD, I helped with calculating extras’ fees. They’d tried feeding the union’s standard rate table Excel into GPT, but it couldn’t understand the structure. It was a 24×24 matrix of start time (rows) × end time (columns) with break text mixed in, formulas chained together, and cases crossing midnight. I reverse-engineered each formula to figure out the calculation logic. 528 cells fully verified, zero discrepancy. Instead of referencing the table, I built the engine that generates the table. Now you just enter the start and end times, and it instantly outputs appearance fees, meal allowances, late-night transport, and regional subsidies.
For an e-learning company, I helped with public bid analysis. Scanned about 1,300 listings from the government procurement portal, filtered down to 83, scored them for fit, sorted them into tiers, and built an execution roadmap. Three agent teams ran in parallel doing market research, benchmarking, and case analysis simultaneously.
For a 26-year veteran at a securities firm, I did vibe-coding consulting. Ran the first session on automating tasks with AI, and taught them how to review and refine prompts.
Could these have been done with Cowork? Some of them, yes. Exporting a bid analysis report as docx, pulling calendar data and organizing it, doing research and formatting it as markdown. But the deliverable wasn’t the point.
What I’m doing these days is helping people become the kind of person who builds their own tools in their own domain. Not just giving a drama PD an extras calculator to use, but helping them become someone who can try building a shoot scheduler on their own next time. Helping the e-learning company run their own bid analysis next quarter. Helping the securities veteran become someone who can refine prompts on their own.
A Place for Both Tools
I still can’t clearly say “Cowork is better for this, Code is better for that.” Sometimes Code’s freedom feels far superior, and other times I wonder if I should be using Cowork more as it keeps adding new features. With that in mind, yesterday I set up a scheduled task in Cowork that analyzes this week’s calendar and last week’s inbox every Monday and generates HTML and markdown documents. Since my computer is essentially the server, it does need to be on when the schedule runs. But the fact that you can set up a scheduled task with such an easy UI — that felt like a real strength of Cowork. Anthropic really is… doing a great job.
