Claude CoWork: Stop chatting. Start delivering.

Section 01

Chat vs CoWork vs Chrome

The load-bearing question for anyone using Claude across modes. Get this right once and the rest clicks.

Chat

Unit of work: A thought

Stateless. No file system, no execution.

Use when

Thinking partner. Drafting. Single-shot synthesis.

Cowork

Unit of work: A deliverable

Plans, executes, delivers finished work to your file system.

Use when

Multi-step outcomes. Anything with files involved.

Chrome ext.

Unit of work: An in-app assist

Reads the page you're on (Notion, Gmail, Lovable, etc.).

Use when

Help in context, where the data already lives.

The line that resolves it: Chat is for one prompt at a time. CoWork is for outcomes. If files are involved, or it's more than one step, you want CoWork.

Section 02

The 5 building blocks

CoWork has 20+ concepts. These five carry 80% of the value. Master them in order — each builds on the last.

Workspace folder

A real folder on your computer that Cowork can read, write, and run code in. Every file you generate during a session lives here. Start with one — call it `Cowork OS`.

CLAUDE.md

A plain-text instruction manual that loads at the start of every session. Tells Cowork who you are, how you work, what 'good' looks like. Keep it under 300 lines and let it point at deeper resource files.

memory.md

A human-readable notepad Cowork updates between sessions. Tracks active projects, decisions, and where you left off. Combine with: 'At the start of every session, read memory.md before responding.'

Connectors

Bridges to your apps — Drive, Gmail, Calendar, Slack, Notion, Linear, GitHub, Canva. Reads are highly reliable. Writes that touch other humans need a preview step. Use Zapier MCP for anything not natively supported.

Skills + scheduled tasks

A skill is one trigger word that runs a multi-step workflow. Pair it with a scheduled task (daily 7am, every Monday, etc.) and you've replaced n8n. The autonomy layer.

Section 03 · The main event

Guided exercises

Nine prompts across three levels. Each one is copy-paste ready, takes minutes, and produces a real artifact you keep. Do them in order.

Total time end-to-end: ~90 minutes spread across a week works better than one long sitting.

Level 1 · ~15 minutes

Set up your workspace, instructions, and persistent memory. After this, every session has context.

Pick your workspace and run /init

3 min · foundation

What you'll learn

Cowork is anchored to a real folder on disk. /init writes a starter CLAUDE.md by reading what's already there.

Try this

Create a folder anywhere on disk called `cowork-os`. In Cowork, set this as your workspace folder and click 'Always allow'. Then type:

/init

When Cowork asks what this workspace is for, answer in one paragraph: who you are, what kinds of work you do here, and one or two non-negotiables (e.g., 'never use em dashes', 'always cite sources').

Expected outcome

A starter CLAUDE.md in your workspace root, calibrated to you. Open it — you'll see plain English, not code. That's the file Cowork loads every session.

Wire up persistent memory

5 min · foundation

What you'll learn

Two lines in CLAUDE.md give Cowork the illusion of remembering you across sessions. The trick is being explicit about when it reads and writes.

Try this

Open CLAUDE.md and add this near the top:

## Memory
- At the start of every session, read memory.md before responding.
- When I say 'remember this', append the fact to memory.md under the right heading.
- Before we end a session, ask if I want anything saved to memory.md.

Then ask Cowork: 'Create memory.md with two sections — Active projects and Long-term context. Add an entry under Long-term context that I prefer concise, structured answers and bullet points over paragraphs.'

Expected outcome

A working memory loop. Start a fresh session tomorrow and ask 'what do you remember about how I like answers?' — it should pull from memory.md.

Watch out

Don't dump everything into memory.md. It loads every session. Keep it lean — facts, not transcripts.

Build your voice principles

7 min · foundation

What you'll learn

Set tone once at the root, every output inherits it. This is how a draft email and a cold-pitch reply both sound like you.

Try this

Drop 5 writing samples you're proud of into a `samples/` subfolder (sent emails, blog posts, anything). Then ask Cowork:

'Read every file in samples/. Build a voice-principles.md in the root that captures: 1) tone in 2-3 adjectives, 2) sentence rhythm and length, 3) words and phrases I use, 4) words and phrases I never use, 5) how I open and close. Use direct examples from the samples.'

Then add this line to your root CLAUDE.md: 'Read voice-principles.md before producing any written output for me.'

Expected outcome

A 50-150 line file that reads like a style guide written for you, by you (sort of). Future drafts inherit it automatically.

Level 2 · ~30 minutes

Connect Drive, Gmail, and Slack. Run reads first (highest trust), then carefully scoped writes.

Read-only synthesis: find the contradictions

8 min · connectors

What you'll learn

The highest-trust use of connectors is reading. No writes, no risk — just a level of recall across documents that humans can't match.

Try this

Connect Google Drive (Customize → Connectors). Then run:

'Read every doc in [pick a folder — your meeting notes, your team's policies, your last quarter of OKRs]. Build a one-page summary with: 1) the dominant themes, 2) any contradictions across docs, 3) anything that looks stale or out of date. Drop it in cowork-os/outputs/synthesis-[today].md.'

Expected outcome

A real artifact you couldn't have produced manually in under an hour. This is the moment most people realize Cowork ≠ chat.

Watch out

Pick a folder you actually know well for your first run. You need to be able to spot-check the synthesis to calibrate trust.

Inbox triage in your voice

10 min · connectors

What you'll learn

Combining Gmail + voice-principles.md is where the leverage shows up. Drafts come back ready to send, not ready to rewrite.

Try this

Connect Gmail. Then run:

'Pull my last 7 days of unread email. Cluster into: needs-reply, FYI, can-archive. For each item in needs-reply, draft a response in voice-principles.md style and save them as drafts in Gmail. Don't send anything.'

Review the drafts before hitting send.

Expected outcome

30-50 minutes of inbox work done in 4. Drafts sound like you because Cowork loaded voice-principles.md before drafting.

Watch out

Always 'don't send anything' on first runs. Writes-others-see is the lower-confidence layer. Drafts-then-approve, not autopilot.

Slack-to-FAQ gap analysis

12 min · connectors

What you'll learn

Pairing two connectors is where Cowork pulls ahead of every other tool. One reads questions, the other reads docs, the synthesis is gaps.

Try this

Connect Slack and Drive. Pick a recurring help channel — could be #benefits-help, #engineering-help, #ask-design, your call. Then run:

'Pull the last 30 days from #[channel]. Cluster questions by topic. For each topic, search Drive for an existing doc that answers it. Output a one-page report: top 5 topics, whether a doc exists, and where the gap is. Drop in outputs/faq-gaps-[today].md.'

Expected outcome

A backlog of doc-improvement work driven by what people actually ask, not what someone thinks they should be asking.

Level 3 · ~45 minutes

Skills, scheduled tasks, sub-agents. The autonomy layer — where CoWork stops being a tool and starts being a coworker.

Build your first skill: /session-audit

10 min · autonomy

What you'll learn

A skill is just a markdown file with a trigger and instructions. /session-audit is the skill almost everyone benefits from — it scans your conversation for principles you mentioned in passing and saves them.

Try this

Customize → Skills → Create skill. Name it 'session-audit'. Paste in:

---
name: session-audit
description: At the end of a session, scan the conversation for principles, preferences, and rules I mentioned in passing. Write them into memory.md and the right CLAUDE.md if obvious. Show me what you saved.
---

At the end of every session, type /session-audit. Or end with: 'before we wrap, audit this session.'

Expected outcome

Compounding context. Every session leaves Cowork smarter about how you work without you having to do the saving.

Live artifact + scheduled task: Week-at-a-Glance

20 min · autonomy

What you'll learn

An artifact shows the answer. A scheduled task keeps it fresh. Together, you have a dashboard that maintains itself.

Try this

Run this once to build the artifact:

'Read my Google Calendar for this week. Build an HTML dashboard called week-at-a-glance.html. Highlight any event with the word demo, presentation, or pitch in a different color. Show: time, attendees, prep status. Save it in outputs/.'

Then schedule it. Tell Cowork:

'Every weekday at 7am, regenerate week-at-a-glance.html for the next 7 days. Also: for any demo or presentation in the next 7 days, add a 15-minute prep block to my calendar 30 minutes before it.'

Expected outcome

A self-maintaining weekly dashboard. The first time you alt-tab to it on a Tuesday and it's already up to date, you'll get it.

Watch out

Calendar writes that affect other people (sending invites, moving meetings) need approval. Calendar writes to your own time (focus blocks, prep blocks) are safe to automate.

Sub-agents for a real deliverable

15 min · autonomy

What you'll learn

Sub-agents run in parallel. One complex deliverable splits into independent workstreams that finish in the time the slowest one takes.

Try this

Pick a real deliverable you owe someone this week. Then run:

'I need to prep [deliverable, e.g., the investor update / Q3 review / launch retro] by Friday. Spawn parallel sub-agents to: 1) pull the relevant data from Drive, 2) summarize the last month of progress from Linear/Notion, 3) draft the narrative in my voice, 4) generate a Canva-ready outline. Combine the outputs into a single doc in outputs/.'

Expected outcome

A first draft of something you'd normally block out 2 hours for, in the time it takes to make coffee. Edit, ship.

Section 04

Trust calibration

The single mental model that prevents every embarrassing CoWork story you've heard. Reads are reliable. Writes-others-see are not. Calibrate accordingly.

Reading text

Confidence: High

Examples: Drive, Slack, Gmail, Calendar reads

Posture: Trust the output

Drafting writes

Confidence: Medium

Examples: Emails, summaries, scorecards, doc updates

Posture: Review before sending

Calendar writes to your own time

Confidence: Medium

Examples: Prep blocks, focus time, time-blocking

Posture: Set up once, audit weekly

Writes that other humans see

Confidence: Lower

Examples: Calendar invites, sent emails, posted messages

Posture: Always preview. Don't autopilot.

CoWork drafts; you ship. Especially anything dated that someone else sees.

Section 05

Rule stacking — your CoWork OS

Once you've outgrown a single CLAUDE.md, you scale by stacking rules — same way US law works.

Tier 1

Root CLAUDE.md

Like the US Constitution

Voice. Default tone. Universal rules. Loads in every session. Keep under 300 lines.

Tier 2

Workstation CLAUDE.md

Like state law

An area of your work — Email HQ, Hiring, Personal Finances. Inherits root, adds context-specific overlays.

Tier 3

Project CLAUDE.md

Like a city ordinance

One specific deliverable or workstream. Inherits everything above, adds this-project rules and the rubric.

The new-hire analogy

Without context, CoWork is the brightest temp you've ever hired. Sharp. Motivated. Zero context. Every. Single. Monday. You spend the first 20 minutes re-onboarding before they ship anything. Your CoWork OS is the desk you build for them — with the onboarding packet already on it. Day one, ready to ship.

You don't have to build it all at once

Start with Level 1. Get the loop working. Add a connector when a real workflow needs it. The rules, the memory, the patterns compound every single session — you'll always be ahead of someone who starts even a day later.

Distilled from a 30-minute training I deliver on building with Claude CoWork.