Understanding Cowork

At its core, Cowork is a local automation environment powered by Claude. You define what should happen — organise downloads, rename invoice PDFs, compile weekly reports from folders, draft follow-up emails from CRM exports — and Cowork executes those steps against real files on disk, not hypothetical examples in a chat bubble.

The product sits between conversational AI and developer agents. You do not need to write Python or configure CI pipelines. You need a clear process, access to the folders that process touches, and willingness to test before you schedule anything mission-critical.

Think of each Cowork workflow as a standard operating procedure you would hand a sharp operations hire: where files live, naming rules, what to do when a file is missing, who to notify on failure. Cowork does not invent your process — it industrialises the one you already have.

Primary fit: knowledge workers with file-heavy rituals. If your week includes 'download three exports, combine them, send summary to leadership,' you are the audience. If your week is 'ship features in a monorepo,' you are not — use Claude Code instead.

Secondary fit: fractional operators who template the same deliverables across clients. Cowork shines when folder structures repeat and naming conventions are enforceable.

Poor fit: real-time customer chat, sub-second API latency, or workflows requiring arbitrary web browsing without guardrails. Cowork is batch and scheduled operations — your COO on a hard drive, not a replacement for your entire stack.

Claude.ai lives in the browser (or app) with session-based interaction. Uploads are manual. Triggers are you opening a tab. Cowork binds Claude to paths on disk — ~/Finance/invoices, ~/Reports/weekly — and can wake up without you.

Cowork adds three primitives Claude.ai lacks for operators: filesystem scope, schedules, and run history.

Use Claude.ai for exploration — 'help me design this workflow.' Use Cowork for execution — 'run this workflow every Monday at 7am.' Many power users design in Projects, then crystallise the stable version into Cowork.

A real COO does not guess your filing system. They ask for the org chart, approval matrix, and weekly rhythm — then execute. Cowork needs the same: explicit inputs, explicit outputs, and explicit stop conditions.

The COO model also sets expectations on judgment boundaries. Automate preparation; keep commitment human. Draft the board email in Cowork; you click send.

When something fails, a good COO leaves a paper trail. Configure notifications and review run history like you would a standup report from ops — not like debugging a mysterious chat.

Strong fits: deterministic file operations; classification and routing (sort invoices by vendor folder); generating drafts saved locally for human review; aggregating exports from tools that already write files.

Weak fits: clicking through legacy ERPs with no export; real-time Slack conversation; legal commitments; deleting source-of-truth data without backup; anything requiring credentials you cannot safely scope.

Gray zone — proceed with guardrails: email drafts (save to drafts folder, never auto-send); cloud sync folders (test conflict behaviour); large binary files (watch disk and model context limits). Document human-in-the-loop tiers in every workflow spec.

Claude Code assumes git, terminals, and code review culture. Cowork assumes folders, calendars, and business stakeholders who never open VS Code.

Choose Claude Code when output is a merged PR. Choose Cowork when output is a folder of board-ready PDFs. Some teams use both: Code ships the feature that writes exports; Cowork consumes those exports downstream.

Security posture differs: Code needs repo secrets management; Cowork needs directory allowlists and audit logs for compliance teams who do not speak git.

Today, plan around: desktop install (macOS/Windows), folder permissions, Skills, plugins, scheduled tasks, connectors, run history, subagents, Projects, Dispatch (preview), Claude in Chrome. Treat connector expansion as additive — build file-based fallbacks.

This playbook also teaches ops patterns. See Ch 7 §2.3 native vs pattern before hunting UI controls. Keep workflows modular: ingest → transform → notify.

Subscribe to Anthropic release notes; quarterly review which workflows can shed manual export steps as integrations mature. Maintain a capability register owned by ops, not only IT.

Install Claude Desktop (macOS or Windows) from Anthropic — Cowork runs in desktop, not web. Sign in with your paid Claude plan. Requires active internet. For schedules/Dispatch: keep ops machine awake — see Ch 7 §2.8.

First-run permissions: grant minimum viable folders. Create a sandbox with sample files mirroring production structure. Run a read-only workflow (list + summarise) before any write step.

Configure notifications to a channel you actually read. Enable run history retention aligned with compliance (30–90 days typical). Document setup in SETUP.md: version, allowlisted paths, owner, escalation contact.

Opening Cowork lands you on the dashboard. Expect a summary of enabled workflows, upcoming schedule triggers, and status chips (success, running, failed, paused). Treat red states like a pager — investigate before building more automation.

Primary navigation typically splits: Workflows, Skills, History, and Settings. Power users pin the dashboard until three consecutive weeks of clean scheduled runs — then they live in History for tuning.

Customise your morning ritual: open dashboard → scan failures → open History for any warning → only then start creative work. Two minutes prevents silent data drift.

The workflow builder is where SOPs become machines. Each block should have one job: watch folder, read files, call Claude with template, write output, send notification.

Use dry-run mode religiously. First run always targets sandbox copies. Second run uses production read-only. Third run enables writes with notifications on.

Version workflows in names: v1, v2 suffixes. When Claude prompt changes materially, clone workflow, test v-next, swap schedule pointer, retire old version after 2 clean weeks.

The Skills library stores procedures independent of schedules. Example Skill: NORMALISE_VENDOR_CSV — validates headers, maps aliases, outputs canonical schema.

Govern Skills like internal products: owner, changelog, consumers (which workflows call it). Breaking change in a Skill requires regression test on all dependent workflows.

Start with 3–5 Skills covering 80% of your file types before building dozens of workflows. Compose workflows from Skills + thin routing logic.

The schedule manager shows what fires when, in your local timezone. Align schedules with upstream data arrival — not aspirational times. If Stripe export lands 6:10am, schedule 6:30am not 5:00am.

Use stagger when many jobs run at midnight. Document dependencies: Workflow B requires Workflow A output file — enforce order via schedule offset or explicit file-exists check.

Pause schedules before holidays or vendor maintenance windows. A one-click pause beats emergency uninstall when finance month-end shifts.

Each execution logs: start time, duration, workflow version, files touched, Claude token usage snapshot, exit status, error stack. Run history is where you answer 'what changed in folder X overnight?'

Filter by failed runs first. Common failures: missing input file, permission denied, prompt schema mismatch, model timeout. Attach run ID to internal tickets for reproducibility.

Export history monthly for compliance if you automate finance or HR-adjacent files. Pair with retention policy documented with legal.

Configure failure alerts to Slack, email, or SMS for production workflows. Include workflow name, run ID, link to history, and first line of error.

Success notifications: use for high-stakes deliverables only. Daily hygiene jobs should log quietly unless summary digest is useful.

Weekly digest option: aggregate runs, success rate, token spend — CFO-friendly view of automation ROI without noise.

Settings hosts: folder allowlist, integration toggles, notification endpoints, default model, and optional team policy locks (IT-enforced).

Run Cowork on a dedicated ops machine or user account where possible. Sync only business folders via controlled cloud mount.

Document every permission change in CHANGELOG with approver. Revoke paths when workflows retire — orphan permissions accumulate silently.

Cowork authenticates with your Claude identity. Model pick per workflow step matters: use fast economical models for classification; reserve premium models for synthesis steps with ambiguity.

Monitor token usage per workflow in run history exports. If a daily job 10×'d after prompt change, you will see it in usage before finance does.

Align with IT on team plans, rate limits, and whether Cowork runs should use shared service account vs individual seats. Document cost allocation for multi-team rollouts.