AI · Claude Cowork · Cheat Sheet

Claude Cowork cheat sheet.

Multi-agent patterns, role separation, shared plans + tasks, and the guardrails that keep several Claudes shipping the same repo without stepping on each other.

Cowork is where solo-agent work stops scaling. This is the sheet I keep open when standing up a rig — the roles, the shared substrate, the handoff protocol, and the failure modes that break every naive multi-agent setup.

Core roles

5 entries

Cowork works when each agent has one job. Blend the roles and quality collapses.

  • Planner

    Reads, thinks, writes a plan. No edits. Uses plan mode + Explore subagents.

  • Builder

    Executes the approved plan. One task at a time, TaskUpdate as it goes.

  • Reviewer

    Reads the diff, runs tests, files corrections. Never edits directly.

  • Deployer

    Ships approved builds — Vercel, S3, migrations. Read-only against source.

  • Meta (human)

    You. Steer role handoffs, break ties, own the direction of travel.

Coordination substrate

5 entries

Shared state that every role reads and writes. Keep it small and structured.

  • TaskCreate

    One shared task list. All roles see the same board.

  • TaskUpdate

    Status transitions are the primary sync signal (pending → in_progress → completed).

  • Plan file

    Single source of truth for what's being built. Update, don't append.

  • CLAUDE.md

    The rules of the road — same for every role, checked into the repo.

  • Auto-memory

    Cross-session facts (user, feedback, project, reference). Loaded every start.

Handoff patterns

5 entries
  • Plan → Build

    Planner writes plan, human approves, Builder claims tasks in order.

  • Build → Review

    Builder marks a task in_progress-review; Reviewer picks it up.

  • Review → Build (reject)

    Reviewer files a follow-up task; Builder resumes.

  • Review → Deploy (accept)

    Reviewer flips to completed, Deployer takes the branch to prod.

  • Blocked

    Any role that can't proceed creates a task describing the blocker.

Parallelism

5 entries

Where cowork earns its 2.4× throughput. Only parallelise truly independent work.

  • Agent(..., run_in_background: true)

    Fire a subagent and get notified when it completes.

  • isolation: worktree

    Each parallel builder in its own git worktree — no branch collisions.

  • Multiple Agent calls / message

    Batch independent subagents in ONE assistant turn.

  • Single-writer per file

    Never two builders on the same file — assign by directory or feature.

  • Reviewer serial

    Reviewers are cheap; make them serial to keep a coherent diff view.

Context hygiene

5 entries

Cowork lives or dies on context discipline. Every role starts with less than you think.

  • Delegate reads

    Push exploration to Explore subagents; their raw results never enter main context.

  • Return summaries

    Subagents report in <200 words unless told otherwise.

  • /compact between phases

    Manually compact main context at role handoffs.

  • 5-min cache TTL

    Don't sleep past 5 minutes if you want the prompt cache warm.

  • One goal per session

    Use /goal to lock a Stop hook — protects against role drift.

Guardrails

5 entries

The rules that stop a cowork rig from painting itself into a corner.

  • Reviewer must fail loud

    If tests are red, task stays in_progress — never 'completed with caveats'.

  • No self-review

    Never let the same agent build AND review the same task.

  • Human at every deploy

    Deployer proposes; human confirms. Especially for prod, DB migrations, force-pushes.

  • Kill runaway loops

    Any role that hits the same failure 3× stops and files a blocker task.

  • Rate-limit cost

    Cap Opus turns per session; downshift to Sonnet for builder loops.

Where cowork wins

5 entries

Task shapes where the multi-agent overhead pays back.

  • Big refactors

    Planner scopes, N builders touch different modules in parallel, Reviewer serialises.

  • Fleet-wide changes

    One planner, one builder per repo — the ABC * pattern across 13+ sites.

  • Content pipelines

    Planner picks topic, Builder writes, Reviewer edits — Appadday cadence.

  • Test remediation

    Test-doctor subagent + fix-builder loop until suite is green.

  • Backfills

    Batch API + subagent map-reduce over a large dataset.

Where cowork loses

4 entries

If you see these shapes, drop back to a single Claude instance.

  • Tight coupling

    One-file changes where every subtask reads the same context — solo wins.

  • High-novelty design

    Early architecture work; too much thrash to hand off cleanly.

  • Debugging one bug

    Serial reasoning beats parallel — split only if you can bisect.

  • Sub-1-day tasks

    Coordination overhead > gain when the whole thing takes < a day.

Fleet-tested rigs

4 entries

Concrete cowork setups running in production on the ABC fleet.

  • AIBO cowork

    Persona-authoring rig: PersonaAgent + BriefAgent + VaultAgent + human review.

  • APPAI cockpit

    13 site-level agents + one orchestrator. Cross-repo PBI → build → push → deploy.

  • AIOS 115-fox

    115 specialised agents behind a router. Cowork emerges per-task, not per-session.

  • ABC squad

    18 agents in 5 stages: Discovery → Strategy → Design → Engineering → Distribution.

Talk to Mat See pricing

Cowork is a pattern, not a product. Everything here runs on stock Claude Code + subagents + shared tasks — no bespoke framework required.

Back to Claude Cowork