Setup and first real file task

You finished Part 1 with a sticky note that says “Cowork, not chat” and a vague hope that the product will just know what you mean. It will not. The first good Cowork run is boring on purpose: paid plan signed in, Desktop ready if files live on your machine, a folder that is not your entire life, one outcome sentence, and a review you actually do. That is this part.

This is Part 2 of the Claude Cowork tutorial. Part 1 sorted chat vs Code vs Cowork. Here we set up and complete one real file task. If the three-way chooser is still fuzzy, re-read Part 1 or the map-level Cowork post in the Claude product map. Everyday Claude habits live in Learn Claude from scratch. Software-shaped work still belongs in the Claude Code tutorial.

Menus move. Treat steps below as as of mid-2026. Official anchors: claude.com/product/cowork and Get started with Claude Cowork.

What you’ll learn

Checklist before first Cowork task (plan, app, network, policy)
How to start a session: shared message box, select Cowork, describe the outcome
Why a dedicated working folder beats “my whole Documents tree”
A first-task recipe you can copy (receipts and card export → expense workbook)
What to watch while Claude runs, and how to steer mid-task
A review loop that catches OCR and category mistakes
First jobs that teach the product without career-ending risk

Before you click anything

Cowork is agentic knowledge work: multi-step execution on files and tools you authorize, without a terminal. Same agentic family as Claude Code, different job. You still need a few preconditions or the first session turns into support archaeology.

Paid plan

Cowork is available on paid plans: Pro, Max, Team, Enterprise. Free chat alone is not the expected path. If you are on Team or Enterprise, an admin may need to leave Cowork enabled for your org. Confirm live pricing and admin settings rather than trusting a screenshot from last quarter.

Where you will work

Desktop (macOS or Windows): best when local folders matter. Install or update from the official Claude download path. Windows users should be on a current Claude for Windows build.
Web (claude.ai): fine for starting and steering, especially when files are already in the session or connected tools.
Mobile: useful for check-in and hand-off when beta is live on your plan and app version.

Support docs stress a useful split: sessions often run remotely on Anthropic’s infrastructure, but local files, browser use, and computer-use style paths reach your machine through the Desktop app. If your first task is a folder on your laptop, plan on Desktop open and connected for the parts that touch that folder.

Network and policy

You need an active internet connection for the session. If this is work data, know your company rules before you grant folders or connectors. Personal tax PDFs and client contracts do not belong in a learning sandbox. When policy is silent, ask before the first run that touches real customer information.

Start a Cowork session (any surface)

Chat and Cowork share one home. That is a feature and a trap. The trap is typing a task while still in Chat and wondering why nothing rewrote the folder.

Open Claude on web, Desktop, or mobile.
In the message box, select Cowork (not Chat).
Describe the task as an outcome, not a 40-step micro-script.
Review Claude’s approach, grant only the access the job needs, then let it run.
Watch progress, answer questions, or redirect. Open the same session from another surface if you need to leave the desk.

UI chrome may say “Cowork” next to Chat, or use a mode control that is still clearly task-oriented. If you cannot find it, confirm plan eligibility, update the app, and re-check the Help Center article for your surface. Beta rollouts for web and mobile have been plan-phased in the past.

Build a dedicated working folder

This is the part most demos skip and most messes start. Do not point Cowork at your home directory “to see what happens.” Do not grant the shared drive that finance treats as source of truth. Build a sandbox.

Why dedicated folders work

Blast radius stays small. Wrong renames stay inside the sandbox.
Review is easier. You know every file was fair game for this task.
You can delete the whole tree if the experiment goes sideways.
You train good habits before the real quarterly close folder arrives.

Folder recipe

On your machine (example paths; adjust for Windows):

mkdir -p ~/Claude-Cowork-Sandbox/2026-q2-expense-drill
cd ~/Claude-Cowork-Sandbox/2026-q2-expense-drill
mkdir inputs outputs notes

Copy copies of non-sensitive inputs into inputs/. Leave originals elsewhere. Put anything Claude should produce into outputs/ by instruction (or accept that Claude may write beside the inputs; either way, say where finished files should land). Keep a short notes/brief.txt if you want standing rules for this folder (categories, date format, currency).

Example brief you might paste into notes/brief.txt:

Expense drill rules for this folder only.
Currency: USD.
Date format: YYYY-MM-DD.
Categories allowed: travel, software, meals, other.
If a receipt photo is unreadable, set amount blank and confidence=low.
Write final workbook to outputs/q2-expense-summary.xlsx.
Do not delete files without asking.

If the product offers folder-level instructions on Desktop when you attach a local folder, use them for the same content. Global instructions (Settings → Cowork, as documented) are for standing preferences across sessions (tone, your role). Folder notes are for this job’s rules. Keep global instructions short so they do not fight every task.

What never goes in the first sandbox

Live payroll, HR, or health files
Production shared drives everyone treats as the system of record
Unredacted customer dumps “because the CSV was handy”
Your entire Downloads history since 2019
Anything you would not let a new contractor sort unsupervised

First-task recipe: receipts to expense workbook

Pick a job where wrong output is annoying, not career-ending, and where “done” is a file you can open. Receipts plus a card export is the classic because it forces multi-step work: read images, read CSV, join imperfect data, write a real sheet.

Inputs to stage

10 to 40 receipt images or PDFs (copies) in inputs/receipts/
One card export CSV in inputs/card-export.csv with columns you understand (date, merchant, amount)
Optional: notes/brief.txt with categories and output path

If you do not have real receipts, make a tiny fake set: five JPG screenshots of invented coffee charges and a five-row CSV. Label it as practice data in the brief so you do not later treat invented numbers as finance truth.

Outcome prompt (copy and adapt)

Select Cowork, attach or grant the sandbox folder on Desktop, then send something like:

You have access only to this sandbox folder.

Goal: build a first-pass expense workbook for review.

Inputs:
- inputs/receipts/ (photos and PDFs)
- inputs/card-export.csv
- notes/brief.txt for category rules

Deliverable:
- outputs/q2-expense-summary.xlsx with two sheets:
  1) transactions: one row per receipt or card line you can support
     columns: date, merchant, amount_usd, category, source (receipt|card|both),
     confidence (high|medium|low), notes
  2) by_category: category, total_amount_usd, row_count

Rules:
- Prefer brief.txt categories.
- If a photo is unreadable, keep the row with confidence=low and explain in notes.
- Do not invent merchants that are not in the inputs.
- Do not permanently delete any files.
- When finished, list the output path and a short summary of assumptions.

Notice what the prompt does not do: it does not micromanage every OCR step. Outcome language lets the agent plan. Constraints protect you. That balance is the skill.

While it runs

Expect progress indicators, visible steps, and chances to steer. Support materials describe plan-then-act behavior: analyze request, break into subtasks, run work in an isolated remote environment, deliver outputs for preview and download. For local folder writes, Desktop must be able to reach the folder.

Permission modes (manual approval vs more automatic styles) control how often Claude pauses for connectors and sensitive actions. Names in the UI can shift (manual / auto / skip-style options have appeared in docs). For a first real task, prefer modes that ask before high-impact writes and deletes. Deletion protection should require explicit allow before permanent deletes. If a prompt asks you to allow something you do not understand, deny and restate the task smaller.

You can leave and check from another surface when remote sessions apply. If the task depends on local files, do not assume sleep mode and a closed Desktop app are free. Support troubleshooting still distinguishes cases where local reachability matters.

Review the deliverable

Open the workbook yourself. Do not bless the filename.

Row sample: Pick 5 to 10 rows. Match merchants and amounts to photos or CSV lines.
Totals: Sum a category by hand or in a fresh sheet. Compare to by_category.
Confidence flags: Open every low row. Fix or drop.
Scope: Confirm no files outside the sandbox changed.
Story: Would you send this to finance as-is? If not, note the gap (missing VAT column, wrong FX, etc.) for the next prompt.

A successful first task is not a perfect audit package. It is a workbook you understand well enough to fix in fifteen minutes, plus a clear list of what the agent got wrong. That list becomes your next instruction file.

Good first jobs (and bad ones)

Good first jobs

Job	Why it teaches	Done looks like
Rename and sort a sample Downloads pack	Folder mutation, clear rules	Consistent names + subfolders
Receipts → expense workbook (above)	Images + CSV + sheet	`.xlsx` with review columns
Meeting notes → action list + one-page brief	Synthesis without high stakes	Doc you can paste into email after edit
Four-slide weekly metrics skeleton from trusted CSVs	Structure first, story later	Deck stub with labeled charts placeholders
PDF pack of public policies → coverage matrix	Multi-doc read, table out	Sheet of topics vs files

Bad first jobs

Entire home directory or whole cloud drive as the sandbox
Live payroll, regulated client files, or production CRM bulk updates
Unattended scheduled tasks before you have reviewed a dry run (scheduling comes later in the series)
“Modernize our monorepo” (that is Claude Code territory)
Anything that needs a licensed human opinion with zero expert review

Worked evening: Maya’s first sandbox run

Maya has Pro, a MacBook, and a Friday afternoon. She creates ~/Claude-Cowork-Sandbox/receipt-drill, copies twelve receipt images and one bank CSV (personal coffee and software charges only), and writes a six-line brief. She opens Claude Desktop, selects Cowork, grants only that folder, pastes the outcome prompt, and stays on a permission mode that asks before deletes.

Claude plans: inventory receipts, parse CSV, draft workbook, write to outputs/. Mid-run it asks about a blurry total on one photo. Maya answers “leave amount blank, confidence low.” Ten minutes later she opens the sheet. Nine rows look right. Two merchants are OCR-mangled. Category totals match her hand sum within a dollar after she fixes the mangled rows. She does not email finance. She saves a corrected copy and writes three lines into the brief for next time: “Prefer legal merchant names from the CSV when the photo disagrees,” “Round to cents,” “Flag duplicates if same day, amount, and merchant.”

That is a successful first evening. Boring, reviewable, reusable. The failed version of the same evening is granting Documents, asking “clean up my expenses,” approving every prompt without reading, and discovering Monday that vacation photos were sorted into meals/.

Usage, modes, and not emptying the tank

Cowork consumes more usage than chat. That is normal for multi-step tool work. Habits that keep first week sane:

Use chat for tiny rewrites and questions.
Batch related file work into one Cowork session when the context is shared.
Watch Settings → Usage when the product starts refusing long runs.
Do not “retry harder” with a wider folder when the real fix is a clearer brief.
Know that more automatic permission modes can include extra safety checking that itself uses capacity (as described in support material for auto-style modes).

If you hit limits constantly on real work, that is a plan and scoping problem, not a personal failure. Max or Team capacity exists for a reason. Still start with sandbox discipline either way.

Troubleshooting first runs

Symptom	Likely cause	What to try
No Cowork option in the box	Free plan, admin off, outdated app, beta rollout	Confirm paid plan; update app; check admin Cowork toggle; re-read availability notes
Claude only chats, no file writes	Still in Chat mode	Select Cowork explicitly
Cannot see local folder	Web/mobile only; Desktop not open; folder not granted	Desktop open; grant the sandbox only; restated path
Task stops when laptop sleeps	Local reachability needed; or non-remote edge case	Keep Desktop awake for local file jobs; reopen session from another surface for remote progress checks
Output missing	Wrong path assumption; write failed; review summary	Ask Claude where it wrote; search sandbox; re-run with explicit `outputs/` path
Usage limit mid-task	Agent burn	Shrink scope; finish in chat if only text remains; check Usage
“Setting up Claude’s workspace”	Expected update spin-up per support	Wait; retry if stuck unusually long
Surprise renames everywhere	Over-broad folder grant	Stop; restore from backup/copies; next time sandbox only

Safety rails for day one

Copies in, originals out of the sandbox.
Least privilege: one folder, minimum connectors.
No permanent deletes without reading the prompt.
No production shared drives as the playground.
No “skip all approvals” mindset on day one.
No pasting secrets into the prompt “just this once.”
Read Anthropic’s safety article before you connect high-impact tools: Use Claude Cowork safely.

How this connects to the rest of the series

Part 2 gets you one clean loop. Later parts go deeper:

Folders, docs, and spreadsheets as everyday objects
Plugins and connectors for office work
Autonomy: when to watch vs walk away
Quality control and avoiding thin “workslop”
Team and enterprise notes

You do not need plugins on day one. You need a sandbox, an outcome sentence, and a review habit. Everything else stacks on that.

Practice this week

Create Claude-Cowork-Sandbox with one child folder for a single drill.
Stage copies only. Write a brief.txt with categories and an explicit output path.
On a paid plan, open Claude, select Cowork, grant only that folder.
Run the expense workbook recipe (or a rename/sort job if you lack receipts).
Review with the five-point loop. Write three instruction improvements into the brief.
Optionally re-run once with the improved brief. Stop after one improvement cycle so you do not burn the week on polish.

FAQ

Do I need Desktop if I only use web?

Not for every task. Official product FAQ notes you do not strictly need Desktop for Cowork in general, while Desktop adds what web and mobile cannot reach: folders and applications on your own computer. If that is where the work lives, start there.

Can I schedule this weekly on day one?

You can discover scheduling early, but do not schedule unreviewed standing tasks yet. Dry run, fix the brief, then automate. A later part of this series covers autonomy and recurrence with more care.

Chat memory did not show up in Cowork. Is it broken?

Support has documented that chat memory does not always carry into Cowork the way people expect; project-scoped memory patterns inside Cowork are the path when available. Put rules in the brief or folder instructions for now.

Should my first task use plugins?

No. Learn the base loop. Add one plugin later when a role needs packaged skills and connectors, with least privilege.

Quick recap

Paid plan required (Pro, Max, Team, Enterprise). Confirm live access.
Select Cowork in the shared message box. Chat will not act like a folder agent.
Remote sessions follow your account; local files and browser paths need Desktop when work lives on the machine.
Dedicated sandbox folder with copies, brief, and explicit outputs.
First recipe: receipts + card export → reviewed workbook with confidence flags.
Review samples and totals. Improve the brief once. Do not grant the whole disk.
Next: deeper work on folders, docs, and spreadsheets as everyday objects.

Previous: Part 1, Cowork vs chat vs Claude Code. Next: Part 3 of the Cowork tutorial (folders, docs, and spreadsheets) when published on the Claude Cowork tutorial series page.

Sources

Product details change. Re-check these the week you enable a feature.

Claude Cowork product page (capabilities, plans, FAQs on chat vs Code vs Cowork, Desktop vs web/mobile)
Claude Help Center: Get started with Claude Cowork (start steps, remote sessions, Desktop for local files, modes, usage, examples)
Claude Help Center: Use Claude Cowork safely
Claude Help Center: Use Claude Cowork on web, desktop, and mobile
Claude Help Center: Organize your tasks with projects in Claude Cowork
Claude Help Center: Schedule recurring tasks in Claude Cowork (know it exists; dry run before you rely on it)
Claude download (Desktop installs)
Analytics Made Simple: Learn Claude from scratch
Analytics Made Simple: Claude product map
Analytics Made Simple: Claude Code tutorial