Articles & Playbooks

How to Set Up Claude Cowork: Files, Instructions, Plugins, and Connectors (2026).

Cowork isn’t won with clever prompts—it’s won with good defaults: a folder system, a questioning habit, and a “handoff protocol” that compounds.

We used to “try AI” the same way everyone does:

Open a chat box → paste a mess → hope for magic → get something almost right → spend longer fixing it than doing it ourselves.

Then we set up Cowork properly and something weird happened.

A teammate dropped a folder in, typed a single outcome, answered three questions, and left their desk to make coffee.

They came back to a finished deliverable saved in the right place—named correctly—matching the style of our old work.

Someone said the quiet part out loud:

“So… the trick is not prompting. It’s operating it like a system.”

Exactly.

This is that system.

Not the “feature tour” version. The works-in-real-life version—so Cowork actually finishes work while you step away (and doesn’t turn your files into modern art).

The Real Problem Cowork Solves

Most AI tools force you into a clumsy loop:

Your world (files/tools) → upload/copy/paste → AI world → output → download → back to your world.

Cowork collapses that loop by bringing Claude into your environment:

• It can read/write inside a folder on your computer
• It can generate real deliverables (docs, spreadsheets) and save them where you work
• It can ask structured questions when the task is ambiguous
• It can specialize via plugins
• It can pull live context from tools via connectors

That’s why Cowork feels less like “chat” and more like “delegation.”

Key takeaway: Cowork is not a chatbot. It’s a work surface.

The Missing Ingredient Most People Never Add: A Handoff Protocol

They don’t define how work gets handed off.

Cowork is an agentic workflow. If you don’t give it a protocol, it will behave like a talented intern with no onboarding: enthusiastic… and occasionally chaotic.

So we use a simple handoff protocol for almost everything:

1. Outcome — what “done” looks like
2. Inputs — what sources it should use (files/tools)
3. Constraints — tone, format, structure, do/don’t
4. Questions first — force clarity before execution
5. Deliverables — file types + naming + where to save
6. Review step — ask for a plan + confirm before edits/exports

We’ll show you exactly how to bake this into Cowork so it becomes automatic.

Key takeaway: Cowork doesn’t need better prompts. It needs better operating rules.

Setup in One Sentence

Install Cowork → point it at a folder → give it standing instructions → make it ask questions first → install one plugin → connect one tool → run a real task.

Now let’s do it properly.

Step 1: Install Cowork and Don’t Overthink It

• Download Claude Desktop: claude.com/download (macOS / Windows x64)
• Cowork requires a paid plan (Pro is typically the on-ramp; heavier workflows may push you toward higher tiers)

Once installed:

• Open Claude Desktop
• Switch to the Cowork mode/tab
• You’re in

Key takeaway: Installation isn’t the hard part. Defaults are.

Step 2: File System Access — The Feature That Makes Everything Else Matter

Cowork’s superpower is simple:

It can read and write inside a folder on your computer.

That means:

• no uploads
• no download/re-upload loop
• no “where did that file go?”
• no “paste the doc content here” nonsense

What changes in practice

Cowork can:

• match formatting from your previous reports
• reuse last month’s spreadsheet structure
• borrow phrasing from your approved language
• produce a deliverable and save it where your team expects it

This is what turns AI from “assistant that talks” into “collaborator that ships files.”

How we recommend structuring folders

Don’t point Cowork at your entire Downloads folder unless you enjoy chaos.

Use a clean structure:

/Cowork-Work/

• /00_Context/ (global context that applies across projects)
• /10_Projects/ (each project gets its own folder)
• /90_Output/ (finished deliverables land here)
• /99_Scratch/ (temporary junk is allowed here, guilt-free)

Key takeaway: A tidy folder is a better “prompt” than a clever sentence.

Step 3: The Context Files That Make Cowork Sound Like You

Instead of prompting harder, we give Cowork better source material.

Create a folder named: Claude Context (or 00_Context) and add three small files:

1. about-us.md
   • what we do, who we serve, what “great work” looks like
2. voice-and-style.md
   • tone, phrases we like, phrases we hate, examples of writing we’re proud of
3. working-rules.md
   • how we want Cowork to behave (questions first, formats, review steps)

These files compound. We tweak them weekly. Output quality keeps climbing without extra effort.

A starter template

working-rules.md

• Always ask clarifying questions before executing.
• Show a short plan before writing or editing files.
• Default outputs:
  • Docs → .docx
  • Spreadsheets → .xlsx with formulas (no screenshots of tables)
  • Summaries → .md
• Save deliverables to /90_Output/ with a clear filename: YYYY-MM-DD_topic_v1
• If uncertain, stop and ask. Don’t guess.

Key takeaway: Context files turn Cowork from generic AI into “our teammate.”

Step 4: AskUserQuestion — Your Built-In Anti-Hallucination System

Most models do this when the prompt is unclear:

Guess → produce polished output → you realize it answered the wrong question → repeat.

Cowork can do something better:

It can ask structured questions first.

Not vague “can you clarify?” questions. Actual scoping questions:

• multiple choice options
• forms
• “pick one of these formats”
• “which audience is this for?”
• “what should we optimize for?”

The one line we add to almost every task

“Do not start yet. Ask clarifying questions first. Begin only after we align.”

It’s boring. It works.

Example: turning a vague task into a real deliverable

Bad prompt:
“Make a report from these notes.”

Cowork questions (good):

• Who is this report for? (client / internal / exec)
• Desired length? (1 page / 3 pages / 10 pages)
• Format? (memo / slide outline / doc)
• Tone? (formal / punchy / technical)
• Include recommendations or just summary?

Then it executes.

Key takeaway: Cowork’s best feature is the ability to stop and ask, not rush and guess.

Step 5: Instructions — How We Fake “Memory” Across Sessions

Cowork doesn’t magically remember everything forever.

So we give it standing orders that load automatically:

• Global instructions: always applied
• Folder instructions: applied when a specific project folder is selected

This is how we prevent re-explaining:

• voice rules
• formatting defaults
• “questions first” behavior
• saving conventions
• what to avoid

What we put in Global Instructions

• who we are + role
• how we want outputs structured (concise, no filler)
• default formats (.docx, .xlsx)
• working protocol (“questions first, plan first”)
• forbidden habits (“don’t invent stats; cite sources or say unknown”)

Key takeaway: Instructions are your “operating system.” Prompts are just commands.

Step 6: Plugins — Turning a Generalist into a Specialist

Plugins are what make Cowork feel like it suddenly “gets” your job.

Without plugins, Cowork is a strong generalist:

• writing, analysis, structuring, planning

With plugins, it becomes opinionated and output-aware:

• sales outputs look like sales outputs
• finance outputs look like finance outputs
• legal outputs look like legal outputs

How we use plugins in practice

We install one plugin that matches the work we do most often, then build repeatable workflows around its commands.

Examples:

• Marketing: content briefs, posts, campaign structures
• Sales: account research, outreach sequences, call prep
• Data: dataset exploration, anomaly checks, analysis suggestions
• Finance: models, reporting, structured commentary

Key takeaway: Plugins reduce the “blank page” effect by giving Cowork job-shaped instincts.

Step 7: Connectors — The End of Copy-Paste

Connectors let Cowork pull from your tools directly:

• Slack
• Drive
• Notion
• and dozens more

This matters because most “AI workflows” are secretly just copy-paste marathons.

Once connected, you can ask:

• “Summarize decisions from #project-alpha for the last two weeks.”
• “Find the newest doc about [project] in Drive and extract the key points.”
• “List all blockers tagged in Notion and propose next actions.”

Key takeaway: Connectors make Cowork situationally aware without you acting as the courier.

The Cowork Workflow We Use for 60% of Knowledge Work

Here’s our default loop (steal it):

1. Point Cowork at the project folder
2. Prompt with outcome + constraints
3. Force AskUserQuestion
4. Approve a short plan
5. Let it execute and save deliverables
6. Review + quick revision round

The “universal prompt” template

Copy/paste this and reuse it:

Task: We want to [OUTCOME].
Audience: [WHO IT’S FOR].
Constraints: Match voice-and-style.md. Use our standard structure. No invented facts.
Deliverable: Save a [DOCX/XLSX/MD] to /90_Output/ named YYYY-MM-DD_[topic]_v1.
Process: Do not start yet. Read all relevant files in this folder first. Ask clarifying questions. Then show a brief plan. Only execute after we approve.

Key takeaway: The template is not the magic—the process is.

Where Cowork Still Falls Short

Let’s keep it real.

1) No true cross-session memory

Workaround: context files + instructions + documenting decisions in the project folder.

2) If you close the app, tasks stop

Treat it like a running job. Don’t quit mid-execution.

3) Usage burns faster than chat

File-heavy, multi-step work costs more “budget.” Monitor usage and adjust habits:

• fewer “redo everything,” more “revise section 2 only”
• pre-load context via files rather than re-explaining in chat

4) Desktop-only experience

No true mobile Cowork. We keep the project folder synced (iCloud/Dropbox) so context stays consistent across machines.

5) Not for image generation

Use purpose-built image tools. Cowork is for docs, spreadsheets, research, structure, writing.

6) It’s a preview of agentic work

Treat it like a powerful machine:

• keep deletion protection on
• review plans before execution
• don’t let it freely modify sensitive folders without a checkpoint

Key takeaway: Cowork is incredible at “structured knowledge work,” but you still need guardrails.

The 30-Minute Setup Sprint

Block 30 minutes. Do this once. You’ll feel the compounding effect all month.

Minutes 0–5: Install + open Cowork

Desktop app, Cowork mode, done.

Minutes 5–12: Create your Context folder + 3 files

about-us.md, voice-and-style.md, working-rules.md.

Minutes 12–16: Set Global Instructions

Paste the best parts of those files. Save.

Minutes 16–22: Run one real task using the universal template

Answer the questions. Approve the plan. Let it execute.

Minutes 22–26: Install one plugin

Try one slash command. Compare the output quality.

Minutes 26–30: Connect one tool

Slack or Drive or Notion. Ask one live-data question.

Key takeaway: Cowork doesn’t reward dabbling. It rewards setup.

Why Cowork Is the Switch, Not the Hype

We’re not interested in vendor fandom.

We care about what makes work faster and better in 2026.

Cowork’s real unlock isn’t that Claude is smart.

It’s that Cowork helps you build a system:

• files that store context
• instructions that enforce standards
• plugins that specialize outputs
• connectors that pull live reality
• a question-first workflow that prevents rework

Chatbots trained people to write better prompts.

Cowork trains us to build better context.

One depreciates.

The other compounds.

If this guide helped, send it to the person who keeps asking:
“Should we try Claude?”

Yes. But more importantly: set it up like this—so it actually does the work while you step away.

— Cohorte Intelligence
February 27, 2026.