Author(s): Neyzis

Originally published on Towards AI.

How to Master Claude Cowork: 10 Techniques You Need to Know

When you upgrade to a paid plan, Claude gives you three distinct tabs. Chat is the standard in-app back-and-forth with no access to your machine. Code is the command-line agent for power users. Cowork is that same agent with a friendlier face: it loops until a task is done and spawns sub-agents to finish it. One simple flight search alone can fire roughly 17 sub-searches in parallel.

Most people run it at maybe 10% of its actual potential. They open a folder-less task, send one request, take whatever comes back, and never touch the features that make it truly powerful.

The fix isn’t a better model. It’s a better setup. Cowork is a local agent equipped with a virtual machine, connectors, schedules, skills, and a browser. Your setup dictates how much of that power you actually unlock.

Here are ten techniques, built from how Cowork actually works. Each one shows the real tab, menu path, or slash command you’d use, plus the honest limitations that come with it.

Part 1. Foundation

Get the prebuilt workflows, the file access, and the data right. Nothing downstream works until these foundations are solid.

01. Install plugins to get whole workflows behind one slash command

Most people only ever type plain requests. Plugins hand Cowork pre-built workflows that you trigger with a slash command, turning a multi-step job into a single keystroke.

The leverage here is packaging. A connector gives Cowork access to a tool; a plugin wraps a sequence of steps inside that tool into a ready-to-run command. An Apollo lead-database plugin, for example, adds /prospect. Typing it pulls qualified leads straight from Apollo without you spelling out the steps each time.

How to use it:

• Open Manage plugins, then browse the available plugins.
• Connect the ones with workflows you’d repeat.
• Trigger the workflow with its slash command (e.g., /prospect).

This only matters on a paid plan, where the three tabs and the customize panel show up. Open the desktop app, add a plugin once, and the workflow is a slash command away every time after. A plugin turns a procedure you’d retype into a command you just call.

02. Give it a folder so the chat starts operating on real files

A standard chat returns text that vanishes when you close the window. Hand Cowork a folder, and that dynamic inverts. It reads, writes, moves, and creates files directly inside it, and the results stay there. No more copy-pasting outputs into documents by hand.

The mechanism is persistence. A folder turns Claude into an assistant that works on your actual disk. A spreadsheet, a draft, or a reorganized set of files stays put to reference or update later. It’s almost a database you keep using.

How to use it:

• Pick the folder Cowork works in (e.g., a “planning” folder).
• Send your task.
• Files it creates save straight into that folder.

On one keyword-research run, it built and saved an Excel spreadsheet into the folder without being explicitly told to. Sessions later, it opened that same file and updated it, because the file lived on the machine, not in a disposable chat. A folder is the difference between an answer and an artifact you keep.

03. Wire up connectors so Cowork stops guessing

Plenty of people ask the model questions it has no way to answer. Attach connectors, and Cowork can pull live data and act inside real tools: Gmail, Slack, Figma, Google Calendar, and data APIs.

This is where it gets genuinely powerful. With connectors, it reviews your inbox, sends an email, or pulls data it otherwise couldn’t know. A prompt becomes a cross-tool workflow instead of a guess.

How to use it:

• Manage connectors shows what you’ve added.
• Browse connectors lists every prebuilt integration.
• Add the ones you need, then name them in the prompt.

One demo used the Data for SEO connector with a flat prompt: “use Data for SEO to do keyword research for NoCodeMBA.” The honest catch: that connector needs API credits, and you pay the API cost every time Claude uses it. The connector reaches the data; the queries you run are what you pay for. Connectors are where Cowork stops describing the world and starts reaching into it.

Part 2. Control

This is the guardrails-and-memory layer. The folder that gives Cowork power is the same folder it can wreck. Pick the model that fits, keep the blast radius small, hold your context, and stay the one steering.

04. Match the model to the task: Opus, Sonnet, Haiku

Cowork burns usage in a different league than chat. The loop is why. It runs many operations per task, so it eats credits far faster than a single chat reply, and Opus eats them the fastest. Run everything on the biggest model, and the plan throttles. Pick the model per task, and it doesn’t.

On a $100 plan, you have a lot of Opus 4.8 headroom. On the $20 plan, you can run dry mid-task. Matching the model to complexity is cost control, not vanity. A long, simple job on Haiku finishes for a fraction of what the same job costs on Opus, and you’d never see the difference in the output.

How to use it:

• Click the model selector at the bottom of the task.
• Opus 4.8 for the hardest reasoning.
• Sonnet 4.6 to conserve usage (still strong, just behind Opus).
• Haiku for simple, low-step jobs.

Reasoning power where it counts. Speed and savings where it doesn’t.

05. Grant several folders at once, or none, and scope each like it’s permanent

The common belief is that Cowork works in one folder at a time. It doesn’t. Check the box on three folders, and a single session can read and write across all three. Uncheck every box, and it still runs on your skills, connectors, and plugins alone — no folder required.

That reach is also the risk. Whatever you allow becomes modifiable, movable, and deletable, including every nested folder, and there is no undo on a file it moved or deleted. Grant your whole desktop, and the whole desktop is fair game.

How to use it safely:

• Tick every folder the task needs (multi-folder is one checkbox each), nothing wider.
• Or leave them all unchecked for a folder-free run on skills and connectors.
• Duplicate any file you’d hate to lose before a session that edits or deletes.
• Read each allow prompt — it asks twice before a permanent delete; don’t reflex-click.

The agent’s reach is exactly as wide as the boxes you tick. Tick the fewest that finish the job.

06. Give it standing context: a per-folder CLAUDE.md, global instructions, and memory

Sessions don’t remember each other. Open a fresh task and ask, “what did I just tell you to do,” and Cowork answers, “this is the start of our conversation.” Re-briefing it every time is the tax most people pay. Three layers of standing context kill that tax, from narrowest to widest.

Drop a CLAUDE.md file inside a folder, and Cowork reads it before doing anything in that folder. This is the highest-leverage move on the list. A client folder gets that client's rules, brand colors, and output format; a deck folder gets the slide structure and layout rules. The instructions live where the work lives.

Above that sit two account-wide layers:

• Per-folder CLAUDE.md: Save it in the folder; it loads automatically for any task in that folder.
• Global instructions (Settings > Coworker): Your role, tone, output format, and hard rules like “never delete without confirmation” — applied to every session.
• Memory (Settings > Capabilities > Search & reference chat): Cowork keeps an editable memory file, regenerated nightly, that you can correct with “remember this” or “forget that.”

Layer them, and a new task starts oriented instead of blank: the folder rules from CLAUDE.md, the standing preferences from global instructions, and the longer history from memory. A CLAUDE.md is the difference between an assistant who knows the project and a stranger you re-brief every morning.

Part 3. Scale

From one assistant to a coordinated operation. These are the layers that turn a single chat into many: a logged-in browser, live steering, reusable skills, parallelism, and schedules, all on a machine you direct hands-off.

07. Pair it with the browser. The biggest unlock, and the one to watch.

A real prompt: “Open my browser, go to YouTube, and tell me two of the recommended videos on my home screen. Then click into both, give me all the stats, views, likes, and the sentiment of the first 10–20 comments.”

It did this by acting as the logged-in user, inside a site it was already signed into. Instead of answers about websites, you get Cowork driving Chrome: opening tabs, navigating, clicking, reading pages, and extracting data. For most people, this is the real reason to use it. It acts on live pages instead of just talking about them.

The mechanism is also the risk. Because it controls a logged-in browser, it can act as you. It reads your full browser context, and it can sometimes go rogue. The same capability that books a flight can charge your card.

How to use it:

• Search “Claude for Chrome,” add the extension, and install it.
• Confirm Claude in Chrome is enabled in connectors (on by default).
• Pair it from Cowork, then prompt.

The browser is the most power you’ll hand it. Watch what it does while it does it.

08. Queue messages and steer the to-do list mid-run

Most people fire one request and wait, helpless, until it finishes. You can stack instructions and correct course before the agent reaches the step.

Two mechanics make this work:

• Queued messages: While a task runs, type and send another (e.g., “could you also include the top 10 keywords I should be targeting?”). It queues for next instead of blocking you.
• The right-side progress panel: Shows a live to-do list, the context, the reasoning, and the working folder. It also asks multiple-choice clarifying questions you can answer in flight.

How to use it:

• Type follow-ups mid-run; they queue in order.
• Watch the to-do list; click to see the reasoning.
• Answer its clarifying questions, or tell it to update a step before it gets there.

On one SEO run, it surfaced an updated to-do list and asked a multiple-choice question. The user answered, “I want keyword research for SEO for a website or blog,” and it adjusted before acting. Now you’re directing the work as it happens, not grading it after.

09. Encode a skill once, then reuse it everywhere

A skill is a markdown file, plus optional scripts or resources, that hands Claude a documented, repeatable process. Re-prompt from scratch, and you get a slightly different result every time. Wrap the workflow into a skill, and the output stays consistent.

The reason it beats re-prompting is reliability. You don’t even have to summon a skill by name — every message, Cowork scans your skill list and pulls in whichever ones fit the text, several at once. Ask for “hooks for the intro and 10 titles,” and it loads your hook skill and your title skill in the same run. The honest limit: a skill isn’t bulletproof. It can still make mistakes or veer.

How to build one:

• Tell the skill creator, “I want to create a skill,” and it asks questions, then writes the .md.
• Or tell Cowork to wrap what it just did into a skill.
• Then, “run the skill, test the skill, slowly refine it,” and save.

After that, just describe the task — it auto-loads the right skill, or force one with a slash command. The chaining is where it compounds. Run a browser task once (e.g., find direct or one-stop flights from Miami to Dubai in business class under $3,000, searching multiple date ranges), wrap it into a parameterized flight-search skill that asks for two cities and a date range, and an ad-hoc run becomes a reusable asset. Skills that ship inside plugins aren’t locked either — open one in the customize panel and edit the steps you don’t like. A skill turns a one-time result into a repeatable process.

10. Run it in parallel, on a schedule, from your phone

Most people babysit one task at a time. The orchestrator runs many at once, on a cron, triggered remotely — and the lever most people miss is that you can command the parallelism, not just hope for it.

The moves that multiply throughput:

• Command the sub-agents: Add “use parallel sub-agents, one per X” to the prompt. “Research these 7 card sets, one sub-agent per set” launches 7 at once instead of 7 in a row — each in its own context, all reporting back into one report.
• Parallel tasks: Start a second task while the first runs. The home page shows them side by side, as many as you want. While a blog post generated, a second task ran alongside it.
• Scheduled tasks: Type /schedule, then set a prompt, model, folder, and frequency. "Daily Cowork news at 9am," or a weekly "AI trends to YouTube ideas." You can run it now from the Scheduled tab to test it.
• Mobile dispatch: Enable Dispatch in settings, then fire a task from the Claude phone app that executes on your home computer.
• Force an audit trail: Start a file-editing session with “create a changelog.md and update it every time you create, modify, or delete a file” — you get a timestamped record of everything it touched.

The honest constraint: Cowork is local-only. Nothing saves to the cloud. Scheduled tasks and long runs only continue while your machine is awake and the desktop app is open. If the computer sleeps mid-task, Cowork stops it (on Windows, raise the sleep timer in power settings for a long job). Dispatch needs the computer running plus a Pro or Max plan. The workaround for persistence is to connect GitHub and commit your outputs the way you would code.

This is the layer where one assistant becomes a fleet you direct instead of a chat you wait on.

The Whole System on One Page

These 10 techniques map onto Cowork’s real layers. Each has a different job, a different cost, and a different risk.

• Foundation is plugins, folders, and connectors. The setup moves that decide whether anything works.
• Control is the model, folder scoping, standing context, and live steering. The guardrails and memory that keep you the authority over an agent that can’t undo its own actions.
• Scale is the browser, skills, commanded parallelism, schedules, and dispatch. The multipliers that turn one task into many, automated and hands-off, bounded by the fact that it all runs locally on a machine that has to stay on.

The Whole Thing in One Move

Cowork does the work. You do the directing. The model loops, spawns sub-agents, drives the browser, and writes the files. You scope the folders, drop the CLAUDE.md, decide which model runs, and command the parallelism.

A folder takes one click. A CLAUDE.md takes one file. A skill takes one "wrap that into a skill." Each is the move that turns a chat box you wait on back into an operator you control.

Pick the one technique your setup is missing most — probably a CLAUDE.md or a granted folder—and add it to your next task. Then the next. The people getting all of Cowork instead of 10% of it aren't running a different model. They just stopped treating an operator like a chat box.

Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor.

Published via Towards AI