// Module C01 · Cowork for IT Pros

The first five things you delegate

Cowork is the part of Claude that actually does the work. The hard part isn't using it — it's knowing what to hand it first.

Claude Cowork is the agentic side of Claude Desktop — a task loop that delegates multi-step work, reads files in folders you mark, drives connectors (Slack, M365, Drive), runs plugins and skills, and executes scheduled tasks. It's available on every paid Claude plan (Pro, Max, Team, Enterprise) on macOS and Windows. You already have it.

The Anthropic and Skilljar courses show you the loop. They don't tell you what to delegate first, when to babysit the run vs. let it complete, or what to do when an artifact comes back wrong. That's the cold-start problem this module solves.

Below: the five-task starter pack, the watch-vs-trust matrix, a 30-second run-summary skim, and a triage tree for stuck runs. Each section ends with a side note on the Codex and Copilot Workspace equivalent so you don't have to standardize on Claude to use the playbook.

// Anthropic's launch keynote. Watch on YouTube →

// One-page reference card PrintDark
C01 — Delegate // the cold-start playbook · A4 · pin it next to your screen Print Dark
// Workflow 1 — Your first five tasks

The starter pack

// audience: anyone on day 1

Run these in order. Each one builds trust with one more capability — file access, web research, multi-tool composition, recurring schedule, structured artifact. After all five, you'll know what Cowork is good at on your machine, and you'll have a feel for the loop.

1

Organize a folder

The simplest task with a real artifact. Filesystem write, low-stakes target, zero ambiguity.

Sort my Downloads folder by file type. Move installers older than 30 days into ~/Archive/installers. Rename screenshots to YYYY-MM-DD-screenshot-NN.png. Show me what you'd do before you run it.

Why first: you watch the plan, you approve, you see the result. The whole loop in 90 seconds.

2

Synthesize a research thread

No filesystem mutation, just web research and a written deliverable. Useful, low-blast-radius.

Read the top 10 results for "RBAC migration patterns 2026" plus the Anthropic Cowork enterprise admin guide. Produce a 2-page brief grouped by theme: identity, spend, observability, gotchas. Cite each claim.

Why next: it forces Cowork to use multiple connectors (web, file write) and produce a structured artifact you can immediately judge.

3

Build a status doc from artifacts

Drop a folder with last week's meeting notes, a Jira CSV export, and recent Slack threads. Ask for a status doc.

Read every file in ~/work/this-week/. Produce a 1-page status update for my manager: what shipped, what slipped, what's blocked, what's next. Use bullet lists. No fluff.

Why this one: it's the highest-ROI Cowork task most IT Pros never delegate — status docs are a chore, the inputs already exist, and the agent can compose them in two minutes.

4

A scheduled morning digest

Your first taste of /schedule. Read-only on the input side; output is one short doc per run.

/schedule each weekday at 7:30am — Scan my email inbox for messages tagged #escalation or marked high-priority since yesterday at 5pm. Summarize each in two sentences with the sender and a recommended next action. Save to ~/morning-brief/{date}.md.

Why this one: the schedule turns a one-shot delegation into an always-on capability. You start your day with the brief already on disk — that's the moment the lightbulb goes on.

5

An Excel build that would take you 40 minutes

This is where Cowork visibly outperforms chat. Multi-tab spreadsheets with formulas don't paste cleanly — Cowork writes the file directly.

Take ~/Downloads/q1-expenses.csv and build q1-expense-report.xlsx with three tabs: (1) raw with one row per expense, (2) by category with VLOOKUPs back to raw and a sum, (3) summary with conditional formatting flagging any category over $5k. Save to ~/work/q1/.

Why last: by now you trust the loop. This shows you what Cowork is uniquely good at — producing real, opinionated artifacts with multiple internal references intact.

// Same idea elsewhere

Codex (cloud agents): task #1 (filesystem) and parts of #3 (codebase-rooted status docs) translate cleanly. Codex is sharper on repo-anchored work; weaker on "just files in a folder."

ChatGPT scheduled tasks: task #4 (the digest) is the canonical use case — the cadence model is the same. ChatGPT can't write to your local filesystem, so the brief lives in the chat, not ~/morning-brief/.

Copilot Workspace / GitHub Copilot: sits closer to GitHub-specific work (PR drafting, issue triage). For tasks #1, #2, #5 you'll want a different tool.

// Workflow 2 — Watch vs trust

The 2x2 that keeps you out of trouble

// audience: everyone, before run #2

Cowork has a mode toggle — "Ask before acting" vs "Act without asking." That's a starting setting, not the whole calibration. The actual decision per task lives on two axes: how reversible is the action, and how high are the stakes if it goes wrong?

Reversible
Irreversible
Low-stakes
Trust — let it run, skim the summary after.
Watch — approve each step. The cost of "act first, ask later" beats the recovery cost.
High-stakes
Watch — approve each step. Even reversible high-stakes deserves a human gate.
Don't run — ship it as a draft for human action, not as a delegation. This isn't the loop's job.

Examples that bite:

  • Filesystem moves — reversible if you have backups, irreversible if not. Default to watch the first time, trust after a clean run.
  • Email sends and Slack posts — irreversible. Always watch. There is no "unsend" that scales.
  • Document edits to a tracked file — reversible via git or app-level history. Trust if low-stakes.
  • Connector API calls with side effects — varies wildly. A Jira read is fine; a Jira create needs a watch on at least the first run.
  • Anything that touches finance, identity, or production data — high-stakes. Use Cowork to draft; have a human execute.
// Same idea elsewhere

ChatGPT Agent / Codex (Atlas mode): equivalent permissions toggle (auto vs ask). The matrix above transfers verbatim — reversibility and stakes don't care which agent runs them.

Copilot Workspace: permission-on-write by default. Less cognitive overhead, but you lose the ability to put high-trust tasks in flow — you'll click approve on every PR.

// Workflow 3 — Reading a run summary

The 30-second skim

// audience: post-task review

When a run completes, Cowork shows you a step list, the tool invocations, and the artifacts. Most people scroll to the artifact and call it done. That's the wrong move — the summary is the audit trail, and four lines tell you whether to trust the result.

Skim in this order:

1 · Plan Did the agent follow the plan it showed you, or improvise?
2 · Tools Which connectors and skills fired? Anything you didn't expect?
// Hot zone. If a connector fired you didn't anticipate, treat the artifact with suspicion until you understand why.
3 · Outputs What files were written, what edits were made, what messages were sent?
4 · Asked Wherever the agent stopped to confirm — re-read those moments. They mark the points it sensed risk.
// The "I asked once" moments are signal. If you blew past them in the moment, this is your chance to catch what the agent already noticed.

If steps 1-4 all check out, the artifact is trustworthy in the same way a well-reviewed PR is trustworthy — not because you re-did the work, but because the trail matches the outcome. If anything fires off — an unexpected connector, an unprompted edit, an asked-once moment that resolved into a different intent — start at the artifact and work backward instead of forward.

// Same idea elsewhere

Codex (cloud agents) and Copilot Workspace ship plan-and-diff review surfaces with the same shape — planned steps on the left, actual on the right, tool calls listed inline. Reading them in this 4-step order works the same way.

// Workflow 4 — Failure-mode triage

When a run goes sideways

// audience: anyone past run #5

Cowork runs fail. Not often, but often enough that knowing the triage tree saves twenty minutes per incident. Five common shapes:

  • Connector auth expired. The OAuth token died mid-loop — Slack, Drive, Gmail are the usual suspects. Open Settings → Connectors, re-auth the offending one, re-issue the same task. Don't re-prompt the agent — just reload the connector and re-run.
  • Permission prompt missed. Cowork is waiting on your approval but you missed the desktop notification. Bring the app forward; the prompt is sitting there. The run isn't dead, it's parked.
  • Wrong artifact shipped. The agent guessed at intent and produced something off-target. Don't wrestle the broken output into shape — reject it, sharpen the prompt with the missing constraint, re-run from clean. Editing-the-output is the trap that eats the next 30 minutes.
  • Stuck in a loop. Rare but real — the agent retries the same failing tool call. Stop the run from the task panel, check Settings → Logs, and consider filing the trace as feedback. The fastest recovery is usually a rephrased task that avoids whichever connector tripped the loop.
  • Cost spike. A long run can burn through quota fast, especially with web-research or document-generation tasks. If you're an admin, this is what group spend limits exist for — covered in C05 Govern.

The meta-rule: when a run misbehaves, the answer is almost never "ask the agent to fix what it did wrong." Stop, diagnose at the connector or prompt level, restart clean. Trying to course-correct mid-run usually compounds the problem.

// Same idea elsewhere

All five failure modes appear in Codex, ChatGPT Agent, and Copilot Workspace with cosmetic differences. The triage tree is platform-agnostic — the only platform-specific piece is where the connector list and run logs live in each app's settings.

// When NOT to delegate to Cowork

The honest read

// audience: everyone

Cowork is good at multi-step, multi-tool, artifact-shaped work. It's not good at:

  • Anything that fits in a single chat reply. Don't summon the task loop to ask "what's the difference between OAuth and SAML." Cowork is overkill for things Chat finishes in one round.
  • Production code work in a real repo. That's Claude Code's lane. Cowork's filesystem access is project-scoped to folders you explicitly mark; it isn't designed for repo-wide refactors, test runs, or branch management.
  • Tasks where every step needs human approval. If the answer is "watch every step" for the whole run, you're using the wrong shape. Use chat with manual confirmations — the task loop's value is the parts you trust to run uninterrupted.
  • One-off tasks that won't repeat. If you're never going to run this again, and chat handles it, chat handles it. Cowork's compounding value comes from scheduled runs and replayable workflows.

The right mental model: Chat is for thinking together. Code is for shipping code. Cowork is for delegating multi-step knowledge work that produces an artifact. Match the surface to the shape and you'll know what to reach for.

// THE BIGGER PICTURE

You run an AI-assisted workflow. We help you wire the rest.

This module is one of five in the Cowork for IT Pros track. If you want it built on your team's actual stack — with your connectors, your roles, your governance — our advisory engagements are scoped for exactly that.

← Back to Cowork track 1:1 coaching Team consulting