Domain 2 · Task Statement 2.5

File Organisation & Cleanup

TL;DR

Use Cowork to impose structure on chaotic folders — automated sorting by type, date, or project, consistent naming conventions, safe duplicate handling, repeatable cleanup workflows, and scheduled maintenance that keeps folders tidy permanently.

What You Need to Know

Every knowledge worker has at least one folder that makes them wince. Downloads with 400 items. A shared drive where file names range from "Final_v3_REAL_USE_THIS.docx" to "asdkjf.pdf." A project folder where last year's receipts sit next to this quarter's board pack. You know the problem. You've been meaning to sort it for months. You never will. Not manually. Life's too short and the pile never stops growing.

This is the lesson where Cowork earns its place on your machine. Folder organisation is the task that converts sceptics. Visible, tangible, and fast. You point Cowork at a mess, describe the structure you want, and watch it rename and sort hundreds of files in minutes. Schedule the task to recur, and the mess never comes back.

But speed creates risk. Cowork will move and rename files without asking permission. It'll cheerfully restructure a folder of 500 documents according to whatever logic you describe, and if that logic was wrong, reversing the damage is tedious at best. This lesson teaches you the expert approach: define conventions first, test before automating, protect against irreversible mistakes, and let Cowork handle the grunt work while you keep control of the decisions.

Automated folder organisation: type, date, project

Three organisation strategies cover the vast majority of real-world folder chaos.

By file type is the simplest. Tell Cowork the categories and file extensions that belong in each: "/Documents for PDF, DOCX, and TXT. /Spreadsheets for XLSX and CSV. /Images for JPG, PNG, and SVG. /Installers for DMG, PKG, and ZIP. /Other for everything else." Cowork reads the extensions, creates the subfolders, and moves every file into its home. For a Downloads folder that's accumulated everything from presentation decks to disk images, this alone changes the experience.

By date imposes chronological structure. "Create subfolders for each month (YYYY-MM) and sort files based on their last-modified date." Cowork reads file metadata, creates 2024-01 through 2026-03 (or whatever range your files span), and distributes everything. Particularly effective for receipts, invoices, screenshots, and any workflow where "when" matters more than "what."

By project or client is the most sophisticated. "Read the content of each file and sort into project folders based on which client is mentioned." Cowork opens documents, scans for identifying information (client names, project codes, account numbers), and files each one accordingly. Powerful but imperfect: Cowork reads content heuristically, not via a database lookup. Files that mention multiple clients or contain no identifying text will be mis-sorted or placed in an /Uncategorised folder. That's expected. The point is that Cowork handles 85% of the sorting instantly, leaving you with a small pile to resolve manually rather than 300 files to process from scratch.

[~]

Combine Strategies in One Prompt

You don't need to choose a single approach. "Sort by project into top-level folders, then within each project sort by file type" produces a two-tier structure in a single pass. Cowork handles nested organisation without difficulty. Just describe the hierarchy clearly.

The YYYY-MM-DD naming convention

Inconsistent file names are the root cause of most folder dysfunction. "Q1 Report," "q1-report-final," "Q1_Report_v2_WJ," and "report q1 2026" are four names for what might be two files or four. Cowork can't fix the underlying ambiguity, but it can impose consistent naming going forward.

The professional standard is YYYY-MM-DD_description, e.g. "2026-03-15_q1-sales-report.xlsx." This pattern sorts chronologically in every file manager and operating system without effort. Specify it in your prompt and Cowork applies it across all files, extracting dates from file metadata (last-modified, creation date) or from content within the document when metadata isn't available.

[!]

Exam Trap: Source of the Date

The exam may present a scenario where Cowork uses the wrong date. Say you rename a January report and it gets a March date because the file was last modified in March. If your instructions say "rename using last-modified date" and the file was edited recently for a formatting fix, you get an incorrect date prefix. Specify the date source explicitly: "Use the earliest of creation date and last-modified date" or "Extract the report date from the document title or first page."

For the description portion, lowercase with hyphens ("q1-sales-report") is the cleanest convention. No spaces (they break scripts and URLs), no underscores (they disappear in hyperlinks), no mixed case. Cowork applies this reliably across hundreds of files. Define it once in your prompt, or better yet in a context file, and never think about naming again.

Deduplication: effective but not infallible

Over time, folders accumulate duplicates. The same document saved with different names. Multiple versions of the same report. Files accidentally copied across locations. Cowork identifies suspected duplicates by comparing file names, sizes, and content. It's good at this. It's not perfect.

The safe approach is always a two-step process: detect, then review. Ask Cowork to move suspected duplicates into a /Review-Duplicates folder and generate a duplicate-report.txt listing each suspected pair with file sizes and original locations. Then you review the report and make the final call.

Why not auto-delete? Because files with identical content can serve different purposes. A company logo appears in every project folder; it's duplicated by design, not by accident. A template spreadsheet is deliberately placed in three directories so team members can find it without searching. A contract PDF has an identical copy in both the client folder and the legal archive because it belongs in both. Automated deduplication that deletes without review will break these workflows, and you won't notice until someone asks "where did the logo go?"

[!]

Exam Trap: Byte-Level Accuracy

A common distractor claims Cowork's duplicate detection compares files at the byte level for perfect accuracy. False. Cowork uses heuristics: file name similarity, file size, and content comparison. Effective, but not infallible. That's precisely why a human review step is mandatory, not optional. Any exam answer that skips the review step is wrong.

Repeatable workflows with context files

The first time you clean up a folder, you explain your conventions in the prompt. The second time, you explain them again. By the third time, you're wondering why you keep repeating yourself. Context files fix this.

Create a file called cleanup-rules.md in the working folder. Inside, define everything Cowork needs to know:

  • Folder structure: /Documents, /Spreadsheets, /Images, /Other
  • Naming convention: YYYY-MM-DD_description-in-lowercase-with-hyphens
  • Duplicate handling: move to /Review-Duplicates, do not delete
  • Unknown types: move to /Uncategorised
  • Guardrails: never delete any files without explicit permission

Cowork reads this file at the start of each session within that folder. You go from a 200-word prompt to a 20-word one: "Read cleanup-rules.md and apply those conventions to all new files in this folder." The conventions persist across sessions, and any colleague who uses Cowork on the same folder gets the same rules automatically.

[!]

Exam Trap: Global Context Files

Context files like cleanup-rules.md aren't shared globally across all Cowork sessions. They're only read when they exist in the working folder for that session. If you switch to a different folder, Cowork doesn't carry your cleanup-rules.md along. Each folder needs its own context file, or you need to use a Project with global instructions (covered in Domain 5).

Scheduled cleanup with /schedule

Running a cleanup once is satisfying. Keeping it clean is the real challenge. Cowork's /schedule command turns a one-off task into a recurring automation.

"Sort my Downloads folder by file type every Friday at 5pm." "Rename and file any new receipts in my Expenses folder every Monday morning." "Check my Inbox-Attachments folder daily and move anything older than 7 days to the appropriate project folder." You define the trigger (day, time), the scope (which folder), and the conventions (your cleanup-rules.md or inline instructions). Cowork does the rest.

There's one constraint the exam tests relentlessly: scheduled tasks only run while the Claude Desktop app is open and the computer is awake. No cloud-based scheduler. If your laptop is closed on Friday at 5pm, the cleanup doesn't happen. If Claude Desktop isn't running, nothing fires. Not a bug. It's an architectural consequence of Cowork's local-execution model. Plan your schedules for times you're typically at your desk with the app open.

[i]

The Test-Then-Schedule Rule

Never schedule a task you haven't run manually at least once. If the logic is wrong (wrong naming convention, wrong folder structure, wrong duplicate handling), a scheduled task will execute that wrong logic every time it fires. One bad manual run wastes 10 minutes. One bad scheduled run, left unchecked for three weeks, creates a mess that takes hours to untangle. Manual first, verify, then /schedule.

Guardrails for destructive operations

File organisation inherently involves moving and renaming, operations Cowork performs freely without a permission prompt. Only permanent file deletion triggers Cowork's built-in confirmation gate. This asymmetry is by design (moves and renames are reversible in principle; deletion isn't), but it means a badly specified reorganisation can scatter files across wrong folders before you notice.

Set explicit guardrails every time:

  1. "Do not delete any files." Redundant with Cowork's deletion protection, but defensive programming applies to AI delegation too. Belt and braces.
  2. "Move anything you can't categorise to /Uncategorised." Gives Cowork a safe default for files that don't match your rules, instead of forcing a guess.
  3. "Move suspected duplicates to /Review-Duplicates." Routes duplicates to human review instead of automated disposal.
  4. "Show me the full plan before making any changes." Your pre-flight checklist. For a 20-file folder, the plan takes 10 seconds to read. For a 500-file folder, it's the difference between a clean reorganisation and a recovery operation.

These four rules belong in every cleanup-rules.md. They cost nothing to include and prevent the two most common disaster scenarios: unintended deletion and files sorted into the wrong structure at scale.

What the exam tests

Task statement 2.5 focuses on practical application. Expect scenario questions presenting a messy folder and asking you to choose the best approach. Four common traps:

  1. /schedule runs when the app is closed. No. Requires Claude Desktop open and computer awake.
  2. Cowork prompts before renames and moves. No. Only permanent deletion triggers a confirmation. Renames and moves execute freely.
  3. Duplicate detection is byte-level perfect. No. Heuristic-based, effective but not infallible. Review step mandatory.
  4. cleanup-rules.md is shared globally. No. Only read from the current working folder for that session.

Know these cold. They rotate through questions in different guises.

Common Mistakes

Common Mistake

Asking Cowork to 'find and remove all duplicate files' in a single step, trusting the deduplication logic to be perfect and safe.

Instead: Use a two-step process: first, move suspected duplicates to a /Review-Duplicates folder and generate a duplicate-report.txt with file pairs, sizes, and locations. Second, review the report yourself before deleting anything. Files with identical content can serve different purposes across different folders.

Common Mistake

Letting Cowork reorganise hundreds of files without first making a backup copy of the folder's original structure.

Instead: Copy the entire folder before running a mass reorganisation. A bulk rename or restructure across hundreds of files is difficult to reverse manually if the naming convention was wrong or the sorting logic misfired. Five minutes spent on a backup saves five hours of recovery.

Common Mistake

Jumping straight to /schedule without testing the cleanup task manually first — scheduling a task you have never verified.

Instead: Run the cleanup once manually, review every result, fix any issues with the conventions or logic, and only then set up /schedule for recurrence. A scheduled task with wrong logic compounds its mistakes with every execution.

Organising a chaotic Downloads folder

Before

Clean up my Downloads folder.

After

Organise all files in this folder by type: /Documents (PDF, DOCX, TXT), /Spreadsheets (XLSX, CSV), /Images (JPG, PNG, SVG), /Installers (DMG, PKG, ZIP), and /Other for anything else. Rename every file to follow the pattern YYYY-MM-DD_original-name using the file's last-modified date. Move suspected duplicates to /Review-Duplicates. Do not delete anything.

Handling duplicate files

Before

Find duplicates and delete them.

After

Scan every file in this folder and identify suspected duplicates based on file name similarity and content comparison. Move all suspected duplicates to /Review-Duplicates. Create duplicate-report.txt listing each suspected pair with their file sizes and original locations. Do not delete any files.

Hands-On Activity

Hands-On Activity

Automated Folder Cleanup with Conventions

15 min

Build a deliberately messy folder, create a conventions file, run a structured cleanup with plan review, and verify duplicate handling — practising every expert habit from this lesson in 15 minutes.

What you will learn

  • Create a context file that codifies organisation conventions for Cowork to follow
  • Delegate a folder cleanup using outcome-focused language with explicit guardrails
  • Review an execution plan before allowing a mass rename-and-sort operation
  • Evaluate Cowork's duplicate detection results and make the final human judgement call
  1. 01

    Create a folder called 'Cleanup-Lab' on your desktop. Populate it with 15-20 files: mix file types (PDFs, images, spreadsheets, text files), use inconsistent names (some with dates in different formats, some without dates, some with spaces, some with underscores). Include 2-3 files with identical or near-identical content but different names to simulate duplicates.

    Why: A deliberately messy folder with inconsistent naming and duplicates creates a realistic cleanup scenario that exercises all of Cowork's organisation capabilities. You need enough variety to see how it handles ambiguity.

    Expected: A chaotic folder that mirrors the state of most real-world shared drives — inconsistent, unsorted, and containing duplicates.

  2. 02

    Inside the folder, create a file called 'cleanup-rules.md' with: 'Naming: YYYY-MM-DD_description-in-lowercase-with-hyphens. Folders: /Documents, /Spreadsheets, /Images, /Other. Duplicates: move to /Review-Duplicates (do not delete). Unknown types: move to /Other. Never delete any files.'

    Why: This context file codifies your conventions once. Cowork reads it at session start, eliminating the need to repeat instructions. Every future cleanup in this folder inherits these rules automatically.

    Expected: A cleanup-rules.md file alongside your test files, ready for Cowork to read.

  3. 03

    Open Cowork, select the 'Cleanup-Lab' folder, and enter: 'Read cleanup-rules.md and apply those conventions to every file in this folder. Show me the full plan before making any changes. Do not delete anything.'

    Why: Referencing the rules file, requesting plan review, and adding an explicit no-deletion guardrail are three expert habits in a single prompt. This is how you safely run large-scale file operations.

    Expected: A detailed execution plan listing every rename, every move, and every folder creation — with duplicates flagged for the /Review-Duplicates folder. No actions taken yet.

  4. 04

    Review the plan carefully. Verify the naming convention is applied correctly, folder assignments make sense, and no files are marked for deletion. Then click Allow to execute.

    Why: Plan review before mass operations is your primary safety net. For 15-20 files this takes 30 seconds. For 200+ files in real work, it is the difference between a clean reorganisation and a recovery headache.

    Expected: The folder reorganised into subfolders (/Documents, /Spreadsheets, /Images, /Other) with consistently named files. Suspected duplicates sit in /Review-Duplicates.

  5. 05

    Open the /Review-Duplicates folder and manually verify the flagged files. Compare each pair: are they true duplicates, or files that share content for a legitimate reason? Delete only the ones you are certain are redundant.

    Why: This step reinforces the non-negotiable human review requirement for deduplication. Cowork's heuristic detection is effective but not infallible — the final judgement on what to keep is always yours.

    Expected: A small set of files requiring your human judgement. Some will be genuine duplicates; others may be files that legitimately belong in multiple locations.

Practice Question

Practice Question

A team lead has a 'Shared-Docs' folder with over 200 files accumulated over two years. Files have inconsistent names, no subfolder structure, and likely duplicates. They want this cleaned up and want it to stay clean going forward. What is the best approach?

Sources