How to Use Claude Cowork: Full Course for Beginners

Ask an AI chatbot a question and you get an answer back. You still have to go and do the work yourself. Claude Cowork changes that. Learning how to use Claude Cowork means handing it the whole task, not just the question, and getting finished work back.

Cowork is Anthropic's agentic AI for knowledge work. It runs on your desktop, reads your files, connects to the tools you already use, and completes multi-step tasks while you get on with something else. This guide takes you from installing Cowork to delegating real business work: setup, your first task, connectors, skills, and the context habits that separate mediocre results from useful ones. No coding background required.

We've spent two years teaching teams to put tools like this to work, and Cowork is the first desktop agent we've seen that earns a place in a normal, non-technical workflow. If you want the plain-English explainer first, our guide to what Claude Cowork is covers the basics. Otherwise, here's how to start using it properly.

What Claude Cowork is, and how it differs from Claude Chat and Claude Code

If you've used ChatGPT or regular Claude chat, you've used a chatbot: you ask, it answers, the next step is on you. Cowork is an agent, which means it can take action. That single difference changes how you work, from chatting with AI to delegating to it. You describe the outcome you want, and Cowork plans the steps, uses the files and tools you give it, asks for approval where it matters, and produces the finished output.

It helps to see where Cowork sits among Anthropic's three tools. Claude Chat is your thinking partner, good for brainstorming and research. Claude Cowork is your work partner, taking action across your documents and tools. Claude Code is your build partner, aimed at developers writing and debugging software. The Claude Cowork vs Claude Code question comes up constantly. Both are agents built on the same architecture. The difference is who they're for: Cowork runs inside the Claude desktop app for business operators, while Code lives in the command line for engineers.

What makes Cowork capable rather than just conversational is the agent loop. When you hand it a task, it makes a plan, takes an action, then checks its own work and decides what to do next before moving on. That self-checking is the thing chatbots don't do, and it's why Cowork can finish a real job instead of producing a first draft and stopping. It's also why we think Cowork is a bigger deal than most people realise.

How to set up Claude Cowork

Setup takes a couple of minutes and involves no terminal or code.

First, you need a paid plan. Cowork is not on the free tier, and neither is Claude Code. For individuals it starts on the Pro plan, which is $20 per month in the US with a discount if you pay annually. Team and Enterprise plans both include access too. If you've wondered whether Claude Cowork is free, the honest answer is no, but set against what it replaces in manual hours, the Pro plan pays for itself quickly.

Next, download the app. Cowork lives in the Claude desktop app, not the web version, so go to claude.com/download and install it for your operating system. Claude Cowork runs on both macOS and Windows, so most teams are covered whatever they're on.

Finally, confirm access. Open the desktop app and you'll land in the familiar chat interface. If your plan includes Cowork, you'll see a Cowork tab; click it and you should reach a "new task" screen. On a Team or Enterprise plan where the tab is missing, an admin needs to switch it on under Organization settings, Products, then Cowork.

Delegating your first task

The fastest way to understand Cowork is to give it something real. A good first task is one that's tedious, file-based, and easy to check.

Take a common one: it's tax time, and you have 60-odd invoices from last year sitting in a folder. Your accountant wants them as a single CSV with every detail extracted, plus the PDFs sorted into subfolders by month. By hand, that's an afternoon gone.

In Cowork, the first step is giving it access to the folder. When you mount a folder as your working folder, you give Cowork permission to read, write, edit, and delete files inside it, and nothing outside it. By default it can't wander into your Downloads or Desktop. One word of caution: if the files are hard to replace, duplicate the folder first, because a badly worded prompt could let Claude delete something.

A strong prompt for a fresh folder has three parts. Tell it what's inside ("these are all my 2025 invoices"), give it the task ("read each one and extract these data points"), and say what to produce ("create a CSV called invoices-2025.csv, then move each PDF into subfolders by year and month"). Cowork spins up its own sandbox, lays out a plan you can interrupt, and in this case writes its own Python script to parse the files. A few minutes later it hands back the CSV and the sorted folders, and it'll even flag oddities, like invoice file names that didn't match their actual dates.

This is the pattern worth internalising. You're not watching it work; you're delegating a defined outcome and checking the result, exactly as you would with a capable colleague.

Connecting your tools with connectors

Most of your work doesn't live in files alone. It lives in Gmail, Slack, Notion, your CRM, and the other tools you're in all day. Cowork reaches them in three ways: connectors, writing code to hit an API, and browser automation. Connectors are the main route and the one to start with.

To add one, go to Customize, then Connectors, then browse the hundreds of built-in options. Connecting uses OAuth, so you log in and grant Claude access only to what your own account can already see. Connecting your Gmail, for instance, exposes only your inbox, not a colleague's.

The part that protects you is permissions. Each connector exposes specific tools, split between read-only actions (search a thread, list labels) and write or delete actions (create a draft, delete a label). For each one you choose Always allow, Needs approval, or Blocked. A sensible default is read-only on Always allow and anything that writes, sends, or deletes on Needs approval. Keep destructive or outbound actions, like sending an email, behind approval every time.

When a tool has no built-in connector, you're not stuck. Search for the tool's name plus "MCP server"; many already publish one. If it exists, add it under Connectors as a custom connector by pasting the remote MCP server URL, then authorise it through OAuth exactly as you would a built-in one. The open standard behind this, the Model Context Protocol, is what lets Cowork talk to tools Anthropic hasn't packaged itself.

Skills: the biggest unlock in Cowork

If you take one thing from this guide, make it skills. Claude Cowork skills are the feature that turns Cowork from impressive to transformative for a team.

A skill is a reusable set of instructions that tells the agent exactly how to perform a specific task. Think of it as a filing cabinet. Instead of cramming every guideline you have for LinkedIn posts, blog articles, and branded emails into one enormous prompt that confuses the model, Claude just knows which folders exist and opens the one it needs. Ask for a branded email and it opens the email skill, follows your template, and builds it, with no LinkedIn instructions getting in the way.

Under the hood, a skill has three layers: the metadata (name and description, always visible so Claude knows the skill exists), the instructions (a markdown file read only when the skill is triggered), and the resources (fonts, logos, scripts, opened only when needed). That staged loading is what makes skills fast and cheap to run.

The way to build a good one is counterintuitive: don't start with the skill builder. Do the task with Claude first, step by step, because you're the expert and you're teaching it your way of working. Verify the output, refine it, and only once it's right do you save it as a skill. The one skill everyone should switch on first is Anthropic's Skill Creator, the skill used to build every other skill. It even smoke-tests what it builds before packaging it. Save it, test it in a fresh task, and from then on a job that used to take an hour runs from a single command.

The deeper point is reuse. Skills shared online are great for learning, but the real value is encoding your company's own process once so anyone on the team can run it. A plugin takes this further by bundling several related skills together with the connectors they need, so a new hire can install one package and have every workflow and integration ready on day one.

Context engineering: what separates good results from great ones

This is the skill that divides beginners from advanced users, and it has nothing to do with clever prompt wording. The old tricks ("you are a senior expert," "your job depends on this") mattered when models were small. With modern models, what matters is context: the right files, instructions, tools, and detail in front of Cowork for the task at hand.

Everything Claude can see while working sits in its context window, measured in tokens. The latest Opus model has a one-million-token window, roughly 750,000 words. That sounds limitless, but it fills faster than you'd think, and as it fills, results degrade. Replies get worse as the model loses track of earlier facts, similarly named tools start competing for attention, responses slow down because the whole context is re-sent each message, and your usage burns faster.

Managing that deliberately is context engineering, and in Cowork you have five levers: the conversation you send, the working folder you mount, the connectors you enable, the skills you load, and the instructions Claude always reads first. Use only what each task needs.

Instructions deserve special mention. Where a skill covers one task, instructions are general guidance Cowork reads before it starts. You can set them globally for your whole account, per Cowork, or, most usefully, per folder using a claude.md file. Drop a claude.md into a working folder and Cowork reads it before any task there, which is perfect for naming conventions, organisation rules, and "never delete this" warnings. A team can sync a shared folder through Google Drive so everyone works from the same files and the same claude.md, and suddenly even a lazy prompt like "what were the highlights from this week's workshop?" produces the right result, because the structure does the heavy lifting.

Usage, limits, and mistakes to avoid

The most common frustration with Cowork and Claude Code is hitting usage limits, so it's worth understanding how they work. There are two: a session limit on a rolling five-hour window, which you'll meet first and which is shared across all of Claude, and a weekly limit. Usage shows as a percentage rather than a token count because your allowance flexes with overall demand. Pro gives you more than free, and Max offers five or twenty times more again for heavier users. When you hit a wall, you either wait for the session to reset or switch on usage credits to keep working at API rates.

A few habits keep you well inside those limits and produce better work at the same time.

Work on local files before connecting to live data, especially for reporting and analysis. A connector often pulls only the first few hundred or thousand rows, whereas a CSV export gives Cowork the full dataset, and it'll tell you which fields a connector would have missed. Be specific with connectors, too: paste the exact URL or ID of the spreadsheet, channel, or database rather than asking Cowork to go hunting, which wastes tokens and risks the wrong file.

Avoid long-running conversations. Reusing one endless task for unrelated work is the top cause of wasted usage, because every message reprocesses the entire context. When the topic shifts, start a fresh task in the same project and run the relevant skill. And build skills as you go: the expensive trial-and-error happens once while you're teaching Cowork the task, after which it runs as an efficient script instead of rediscovering the process every time.

Finally, treat Cowork like a colleague, not a search box. It's slower than chat because it's actually doing the work, so hand off a task, go and do something else, and check back. Line up three or four jobs, delegate them all, then review. That batching is a real shift in how you work, and it's where the hours come back.

Start delegating real work

The shift that matters is the one from asking to delegating. Once you've set Cowork up, mounted a folder, and watched it finish a task you'd normally dread, the habit clicks. Pick something tedious and file-based for your first job, lean on connectors to reach your tools, and the moment you find yourself repeating a process, save it as a skill so you never explain it twice. Manage your context deliberately and your limits will look after themselves.

If you'd rather learn this with structure and real examples for your function, our hands-on Claude Cowork training takes you and your team from first task to a working set of skills and automations built around how you actually operate.