Cursor Writes the Code. Claude Cowork Does the Rest.

The expensive habit is using one AI surface for everything.

I used to dump competitor notes, meeting transcripts, CSV exports, and “can you turn this into tickets?” into Cursor, then ask it to also implement the feature. The agent would spend a small fortune reading before it wrote a line of TypeScript. The code quality was not the problem. The workspace was.

Claude Cowork is the other half of that setup: a knowledge-work agent that runs in the Claude desktop app, reads and writes files you point it at, and can work across connected tools (Drive, Slack, Gmail, and the like). Cursor stays in the repo. Cowork stays in the rest of the work. That split is how I spend fewer tokens and get better artifacts.

Two workspaces, one model family

Chat, Cowork, and coding agents all run on Claude. The difference is what you are paying the context window to hold.

• Chat is for a question, a gut check, a short draft in your head.
• Claude Cowork is for a deliverable: a brief, a deck, a spreadsheet, a folder of files reconciled into one doc. You describe the outcome, it works through the steps, you review.
• Cursor is for software that lives in git: diffs, tests, types, PRs.

If the output is a thought, use chat. If the output is a file someone else will open, use Cowork. If the output is a commit, use Cursor.

Using Cursor as a research intern is like spinning up a JVM to format a CSV. It will do it. You will overpay.

Use case 1: research outside the repo, implement inside it

When I am deciding how PostDrop should handle a billing edge case, I do not start in the IDE.

I put the Stripe docs PDF, two competitor help pages I saved, and last month’s support notes in a folder. In Cowork I ask for a two-page decision brief: what we should do, what we should not do, and the exact files I think will change. I tell it to ask clarifying questions before it starts — time zone, which plan, what “failed payment” means.

That brief is the only thing I paste into Cursor.

Cursor then gets a new chat, @ on billing and the webhook handler, and a prompt like: “Implement the ‘retry once, then lock’ path from this brief. Do not reopen the research.” The model is no longer re-reading ten pages of marketing copy on every turn. Cowork already paid that cost once, in a workspace built for files and browsers. Cursor pays only for the code.

Use case 2: meetings and Slack are not source code

At a bank, the useful context for a change often lives in a thread, a Confluence page, or three slightly different versions of a requirements doc. Dumping that into Cursor means the agent indexes noise that will never be imported by javac.

Cowork is better at “read this Drive folder and last week’s notes, then write a one-page ticket: problem, acceptance criteria, out of scope.” I review that ticket the way I would review a junior’s write-up. Then Cursor implements against the ticket, not against a 40-message Slack export.

The token win is obvious: a distilled spec is maybe a few hundred tokens. The raw thread is thousands, and it comes back on every follow-up.

Use case 3: recurring reports should not touch the IDE

Anything I will do again is a Cowork candidate: a weekly changelog draft from merged PRs I exported, a simple spend / pacing sheet, a “what shipped last sprint” doc.

Anthropic’s own guidance is the same shape I use: multiple inputs, a file out, you already know what good looks like, and the middle is boring extract-and-reformat work. Schedule it if the cadence is real.

I used to ask Cursor to “summarize git log and write the newsletter.” That pulls git, markdown, and whatever else is in context into a coding agent. Cowork can sit on the export folder and produce the doc. Cursor never sees it.

Use case 4: incidents — logs in Cowork, the patch in Cursor

When a payment or posting flow misbehaves, the first hour is triage: which correlation id, which timestamp, which downstream timeout. That is a folder of logs and a timeline, not a refactor.

I keep a scratch folder for the incident. Cowork gets: “Build a one-page RCA timeline from these logs. Quote only the lines that prove the sequence. Do not propose a rewrite of the service.” I take the timeline into Cursor with the two classes that own that path.

If I skip that step, the coding agent will try to be a detective and a surgeon in the same thread. Detective work is wide. Surgery should be narrow. Wide plus narrow in one context window is how you burn a day’s tokens on a two-line fix.

Use case 5: docs, decks, and resumes stay out of the editor

Portfolio copy, a CIBC-style resume pass, a one-pager for PostDrop — none of that belongs in a session that also has next.config.ts open.

Cowork can read the current PDF and a notes file and produce a revised draft on disk. Cursor can later change the site to serve a new resume.pdf. Mixing those jobs means the model keeps paying for React components while it rewrites a bullet about Spring Security.

How the handoff actually looks

The pattern I reuse:

1. Cowork first when the inputs are messy (folders, mail, sheets, the web).
2. Ask it to confirm the ask and list assumptions before it runs. Five questions up front is cheaper than three failed deliverables.
3. Review the artifact the way you review a PR: wrong facts, missing constraints, too much scope.
4. New Cursor chat with only the files named in the artifact.
5. Do not paste the Cowork transcript. Paste the finished brief.

That last line matters. A Cowork session can be long. The output should be short. Short is what you can afford to resend.

What I still do in chat

I still use plain Claude chat to pressure-test a design (“is eventual consistency acceptable here?”) or to ask a dumb syntax question. I still use Cursor for anything that should compile.

I do not use Cowork to rename a TypeScript type. I do not use Cursor to rebuild a 12-slide QBR from a Drive folder.

The split is not ideology. It is a budget. Context is the budget. Put research, reconciliation, and writing where those files already live. Put diffs where the compiler lives. You will spend fewer tokens, and each tool will stop pretending it is the other.