Domain 1 · Task Statement 1.5

Effective Task Delegation

TL;DR

Master the art of delegating to an AI agent — describing outcomes instead of steps, providing context that persists, reviewing execution plans, steering mid-task, and selecting the right model for the job.

What You Need to Know

Delegation is the skill that separates someone who uses Cowork from someone who is genuinely productive with it. Previous lessons covered the architecture, the sandbox, and the parallel execution engine. This lesson is about the human side: how you communicate a task so Cowork's agentic engine can do its best work.

Most people arrive at Cowork with habits formed in Chat. They type conversationally, ask open-ended questions, wait for a response. That approach produces mediocre results — not because the tool is worse, but because agentic execution rewards a fundamentally different communication style. You are no longer prompting a chatbot. You are briefing a capable colleague who will go away and do the work autonomously. Brief well, get good output. Brief poorly, get polished rubbish.

Describe outcomes, not steps

[i]

The Pizza Principle

Ordering a pizza: you tell the chef "large pepperoni," not how many grams of flour to use or what temperature to set the oven. Cowork is the chef — it knows how to cook. It just needs to know what you want on the plate.

Over-specification is the single most common delegation failure. Users write ten-step manuals: "First open file A, then read column B, then copy the value into cell C3, then move to file D..." Feels thorough. It is counterproductive. Over-specification forces the agent down a rigid path, blocks parallelisation, and confuses the planning engine when your prescribed steps conflict with how the tool actually operates.

Vagueness is equally destructive. "Fix my files" or "make this better" gives Cowork nothing to aim at. Without a defined end-state, the agent guesses. It might organise files alphabetically when you wanted them by date. It might rewrite a document in formal tone when you wanted conversational. Technically competent output, completely wrong for your purpose.

Expert delegation lives between these two failure modes. You describe what "done" looks like: output format, naming convention, folder structure, columns in the spreadsheet, tone of the writing. You define constraints: "do not delete any files," "flag duplicates instead of merging them," "use British English." Then you leave the execution path to Claude.

Expect the exam to test this distinction heavily. Scenario questions will present a task with four delegation approaches — one too prescriptive, one too vague, one that misuses a feature, one that describes the end-state clearly. The correct answer is always outcome-focused delegation.

Providing context that persists

Every new standalone Cowork session starts blank. Claude doesn't remember your role, your writing preferences, your brand voice, or the decisions you made last Tuesday. Stateless. This catches people off guard — they assume Cowork accumulates knowledge across conversations. It doesn't.

[!]

Exam Trap: Automatic Memory

A common exam distractor claims Cowork remembers everything across sessions automatically. False. Standalone sessions start from zero. You need Projects or context files to create persistence. This distinction is tested repeatedly across Domains 1 and 5.

Context files solve this. They're persistent documents Claude reads at the start of every session within a Project folder. Think of them as a new-starter handbook. You wouldn't drop someone at a desk on day one and expect them to know your brand guidelines, reporting preferences, and communication style. You'd hand them reference documents. Context files do exactly that for Cowork.

Three context files have the biggest impact:

  1. about-me.md — your role, your goals, the teams you work with, the decisions you make. This tells Claude who it's working for.
  2. brand-voice.md — writing samples, tone rules, terminology to use and avoid, formatting preferences. This tells Claude how to sound.
  3. working-preferences.md — behavioural guardrails. "Always show the plan before executing." "Never delete files without asking." "Use British English." This tells Claude how to behave.

Thirty minutes setting these up transforms output quality permanently. Power users describe the shift as turning Claude from an intern into a colleague. The exam expects you to know that context files live within Projects, that they are read at session start, and that skipping this setup is a mistake — not a neutral choice.

Reviewing execution plans before approval

Before Cowork executes any task, it generates an execution plan and shows it to you. This is your pre-flight checklist. The plan lists every action Claude intends to take: which files it will read, what it will create, how it will organise, what it will rename. You review, then approve or redirect.

[~]

The 30-Second Habit

Reading the plan takes 30 seconds. Fixing a mistake after execution takes 30 minutes. One user caught Claude about to delete files they intended to keep — spotted in the plan, corrected before any damage. This habit is the single strongest signal of an expert user, and the exam treats skipping plan review as always wrong.

This matters even more before parallel execution. When sub-agents process files in parallel, an error in the plan multiplies across every sub-agent simultaneously. Wrong naming convention? All 50 files renamed incorrectly at once. Sequential processing might let you catch the error on file two. Parallel processing applies it everywhere before you notice.

Iterating on results through steering

Delegation doesn't end when you click "Allow." Cowork might get 90% of the report right on the first pass, but you still need to refine the tone, add a chart, or restructure a section. The expert move is to stay in the same session and steer.

Don't start a new session to fix issues. The current session holds full context of what was done, what was attempted, and what the intermediate results look like. Give specific feedback: "The summary is too long — cut it to 150 words" or "Move the financial data to a separate tab and add conditional formatting for values over 10,000." Claude treats this as iteration on the existing work, not a fresh task.

You can also intervene mid-task. If Cowork is heading in the wrong direction during execution — processing the wrong files, using an unexpected approach — interrupt and redirect. This is steering, and the exam values it because it demonstrates understanding of the agentic execution model. You're not waiting for a finished response to react to (that's Chat thinking). You're managing an active process.

Model selection: matching the tool to the task

[i]

The Model Tier

Haiku — quick tasks and simple extraction. Renaming files, pulling a value from a document, formatting a list. Fast, light on rate limits. Sonnet — the daily workhorse. Analysis, writing, multi-step workflows, most file processing. Handles 80% of real work. Opus — deep reasoning and complex analysis. Multi-document synthesis, sophisticated writing where Sonnet fell short, tasks requiring extended chains of logic.

Not every task needs Opus. Using Opus to sort a folder alphabetically is like hiring a barrister to post a letter. It works, but you burn through rate-limit budget you'll miss later when a genuinely complex task arrives.

Model selection appears directly on the exam. Expect questions where one option uses Opus for a trivial task and another matches the model to the complexity. The correct answer is always the appropriate match. "Always use Opus for best quality" is a trap — it wastes rate limits and is explicitly wrong.

Practical rule: start with Sonnet. If the output falls short — shallow reasoning, missed nuances, flat writing — escalate to Opus for that specific task. Drop to Haiku for mechanical operations where speed matters more than reasoning depth. This tiered approach preserves your rate limit for tasks that genuinely need the most capable model.

Putting it all together

Expert delegation combines all five skills in a single interaction:

  1. Outcome description — what "done" looks like, with specific deliverables
  2. Context provision — either via context files in a Project or inline references to relevant documents
  3. Plan review — always requested, always read before approving
  4. Steering — refining the output after the first pass rather than starting over
  5. Model selection — choosing the tier that matches the task complexity

This task statement carries heavy weight within Domain 1. Questions test whether you can identify effective delegation in realistic business scenarios, spot the failure mode in a badly delegated task, and choose the right model for a given workload. Roughly 85% are application or scenario-analysis level — situations, not definitions.

Common Mistakes

Common Mistake

Writing a 10-step manual prescribing every action Cowork should take — which files to open first, what order to process them, exactly how to format each cell.

Instead: Describe the end-state: output format, folder structure, naming convention, and quality criteria. Let Cowork plan the execution path. Its planning engine optimises for speed and correctness when given room to work.

Common Mistake

Asking Cowork to 'fix my files' or 'make this better' without specifying what fixed or better means — no target format, no naming rules, no success criteria.

Instead: Define the deliverable precisely: 'Organise by file type into /Images, /Docs, and /Data subfolders. Rename using lowercase-with-hyphens. Flag duplicates in a /Review folder.' The more concrete the end-state, the better the output.

Common Mistake

Defaulting to Opus for every task — simple file sorting, quick formatting, straightforward extraction — because 'it gives the best quality'.

Instead: Match the model to the task. Haiku for mechanical operations (renaming, moving, simple extraction). Sonnet for standard analytical and writing work. Opus only when Sonnet's output was genuinely insufficient — complex multi-document reasoning, subtle analysis, or extended logical chains.

Delegating a folder organisation task

Before

Look at my folder and tell me what's in there, then maybe make some folders if you think that's a good idea.

After

Organise this folder by file type. Create subfolders: /Images, /Docs, /Data. Move all files into their respective homes and flag duplicates in a /Review folder.

Delegating receipt processing

Before

Step 1: Open the first receipt. Step 2: Read the total. Step 3: Put it in a list. Step 4: Repeat for all 20 receipts.

After

Process all receipts in this folder. Create a formatted Excel spreadsheet with columns for Date, Vendor, and Total. Include a SUM formula at the bottom of the Total column.

Hands-On Activity

Hands-On Activity

Practice Effective Delegation with Context

15 min

Build a context file, delegate a task using outcome-focused language, review an execution plan, and iterate on the results — combining four expert delegation habits in a single 15-minute exercise.

What you will learn

  • Write a context file that persists instructions across Cowork sessions
  • Delegate a task by describing the desired end-state rather than prescribing steps
  • Review and refine an execution plan before approving it
  • Iterate on results by steering within the same session
  1. 01

    Create a folder called 'Delegation-Test' on your desktop. Add 5 random images and 5 random text files — any files you have on hand will do.

    Why: A small, mixed set lets you iterate quickly while practising the full delegation pattern. You need enough variety to see how Cowork handles different file types.

    Expected: A folder with 10 mixed files (images and text documents) ready for processing.

  2. 02

    Inside the folder, create a file called 'rules.md' with this content: 'Always rename files using lowercase with hyphens. Include the date as a prefix in YYYY-MM-DD format. Never delete any files — move uncertain items to a /Review subfolder.'

    Why: This is your first context file — persistent instructions Claude reads automatically when working in this folder. It encodes your preferences once so you never repeat them.

    Expected: A rules.md file sitting alongside your 10 test files. Claude will read this before doing anything else.

  3. 03

    Open Cowork, select the 'Delegation-Test' folder, and enter: 'Organise these files by type into subfolders. Rename them based on the rules in rules.md. Show me the plan first.'

    Why: This single prompt combines three expert habits: outcome-focused delegation (organise by type), context file reference (rules.md), and plan review request (show me the plan first).

    Expected: Claude reads rules.md, generates a detailed plan with lowercase-hyphenated date-prefixed filenames, proposes subfolders for each file type, and waits for your approval before making any changes.

  4. 04

    Read the plan carefully. Then tell Cowork: 'Change the plan — put the file type as a suffix after the date prefix instead of using it as the subfolder name.' Review the revised plan and click 'Allow'.

    Why: This practises steering — refining the plan before execution rather than fixing mistakes afterwards. You are iterating on the approach, not the output.

    Expected: Claude revises the plan to reflect your feedback, presents the updated version, and executes only after your explicit approval.

  5. 05

    Once execution completes, check the folder. If anything isn't quite right, stay in the same session and give specific feedback: 'The image files should be in /Images, not /Media — move them and update the names accordingly.'

    Why: This practises post-execution iteration. Staying in the same session preserves full context. Starting fresh would mean re-explaining everything from scratch.

    Expected: Claude makes the correction within the existing session, referencing the original rules.md and the previous execution context. The final folder structure matches your refined specifications.

Practice Question

Practice Question

You have a folder containing 50 CSV files with inconsistent naming. You want them organised by date into subfolders and summarised into one Excel file. What is the most effective way to delegate this to Cowork?

Sources