How Freelancers Can Use Claude Cowork to Review a Deliverable Folder Against a Client Checklist

If Claude Cowork is new to you

Start with the Claude Cowork explainer page in the site's Tools menu before you run this workflow. Cowork runs in Claude Desktop and can work on the local files you choose to share. For related examples, see the Claude Cowork tool hub and the Anthropic Workflows series.

Problem and who this is for

Before delivery, you need a boring but important answer: is everything here, is it named correctly, and does it match what you promised. That is exactly the kind of work people rush when they are tired.

This workflow is for freelancers and consultants who deliver a folder of client files and want Cowork to compare it against the brief before the handoff.

Why Cowork fits this workflow

Cowork fits this workflow because the work depends on inspecting the actual local folder before anything is sent. It can compare file names, file formats, subfolders, duplicates, and missing assets against the client brief or delivery checklist.

Use Cowork when you want a pre-delivery comparison report, cleanup flags, and a final delivery-readiness verdict grounded in the files on your machine. It can tell you what appears present, missing, wrong-format, duplicated, optional, or needing review without requiring you to manually list every file in a chat.

Why not normal Claude chat or just a Skill?

Normal Claude chat can help if you manually list the folder contents or upload the files. That may be enough for a small one-off handoff, but it adds friction when the deliverables already live in a local folder and the review depends on filenames, formats, and subfolders.

A Skill can standardize review criteria, verdict language, or client-specific delivery rules. It does not replace Cowork's workspace inspection layer. For this workflow, Cowork is the stronger tool for checking the local deliverable folder against the brief and checklist.

Prerequisites

• Claude Desktop with Cowork available on a paid Claude plan.
• One clearly scoped deliverable folder or Cowork project.
• The client brief, statement of work, or promised asset checklist in the same workspace.
• A clear rule about what counts as complete.

Set up this workflow as a Cowork project

For recurring clients or repeated delivery reviews, create one Cowork project for delivery checks. Keep the project narrow so Cowork reviews only the files needed for this handoff.

Use this project structure:

deliverables/
client-brief/
checklist/
final-verdicts/
archive/
delivery-checklist.txt

Use deliverables for the files you intend to send. Use client-brief for the statement of work, brief, scope notes, or delivery terms. Use checklist for client-provided checklist files, QA notes, or platform requirements. Use final-verdicts for Cowork's reports and delivery-ready checks. Use archive for old exports, drafts, prior versions, and files that should not be sent.

Use delivery-checklist.txt as the plain-English delivery standard. List each promised asset, required format, naming convention, subfolder expectation, optional item, and anything that should be excluded.

Add project instructions so future reviews reuse the same client delivery rules:

{
  "project_name": "Client Delivery Review",
  "project_purpose": "Use Claude Cowork to compare a deliverable folder against a client brief and delivery checklist before anything is sent.",
  "project_instructions": [
    "Inspect files only inside deliverables, client-brief, and checklist unless I approve another source.",
    "Use delivery-checklist.txt as the delivery standard.",
    "List each promised asset as present, missing, wrong format, naming mismatch, duplicate, optional, or needs review.",
    "Do not rename, move, delete, or modify files unless I approve a specific operation.",
    "Flag conflicts between the brief and checklist instead of resolving them automatically.",
    "Create a comparison report before any cleanup.",
    "Create a final delivery-ready verdict only after I confirm the cleanup is complete."
  ],
  "file_naming": "client-delivery-review-client-name-yyyy-mm-dd"
}

This setup protects client trust by making the review repeatable without letting Cowork change files before you approve exactly what should happen.

How to gather the source material

1. Put the current deliverable files in deliverables.
2. Add the client brief or SOW to client-brief.
3. Add client-provided checklist files or QA notes to checklist.
4. Add one plain-text file called delivery-checklist.txt that lists each promised asset and any naming or format requirement.
5. Move drafts, exports you do not plan to send, and unrelated scratch files into archive or outside the project.
6. If the client requires a specific archive structure, spell that out in delivery-checklist.txt.

Numbered workflow steps

1) Ask Cowork for a comparison report first

{
  "task": "Compare a local deliverable folder against a client checklist and brief",
  "input": {
    "deliverable_folder": "deliverables",
    "brief_folder": "client-brief",
    "checklist_folder": "checklist",
    "delivery_checklist_file": "delivery-checklist.txt"
  },
  "rules": [
    "Inspect the folder and list what is present.",
    "Compare actual files to the promised assets in the brief and checklist.",
    "Flag missing items, naming mismatches, wrong formats, and likely duplicates.",
    "Flag conflicts between the brief and checklist instead of resolving them automatically.",
    "Do not rename, move, delete, or modify files."
  ],
  "output": {
    "present_assets": "What exists now",
    "missing_assets": "Promised items not found",
    "format_or_naming_issues": "Anything that violates the checklist",
    "duplicates_or_optional_items": "Duplicates, optional assets, or files needing review",
    "brief_checklist_conflicts": "Any mismatch between the brief and checklist",
    "suggested_fixes": "Specific cleanup actions before delivery"
  }
}

2) Fix the flagged items

Do the cleanup yourself or ask Cowork to perform only the specific file operations you approve. Do not approve broad cleanup instructions such as "fix everything." Approve one operation at a time, such as renaming one file, moving one duplicate to archive, or creating one missing export.

3) Run one last delivery-ready check

{
  "task": "Run a final delivery-ready check on the cleaned deliverable folder",
  "input": {
    "deliverable_folder": "deliverables",
    "delivery_checklist_file": "delivery-checklist.txt"
  },
  "rules": [
    "Confirm whether all promised assets are present.",
    "Confirm whether file names and formats match the checklist.",
    "Return a one-screen final verdict only.",
    "Do not send files to the client."
  ],
  "output_format": {
    "type": "delivery_verdict",
    "sections": [
      "Ready to send",
      "Any remaining blockers"
    ]
  }
}

Save the comparison report and final verdict in final-verdicts so you have a delivery-review trail.

Future delivery checks

For the next delivery to the same client, reuse the same Cowork project. Replace the files in deliverables, update delivery-checklist.txt, and start with a shorter request:

Review the deliverables folder against the current delivery checklist.

For a stricter reusable prompt, use this:

{
  "task": "Review the deliverables folder against the current delivery checklist.",
  "rules": [
    "Use the Client Delivery Review project instructions.",
    "Create a comparison report first.",
    "Do not modify files.",
    "Flag missing, duplicate, wrong-format, and naming issues.",
    "Return a final delivery verdict only after I approve cleanup."
  ]
}

The project instructions carry the review style, client-specific delivery rules, and file-safety constraints forward. You still decide what to change and send the final files yourself.

Tool-specific instructions

Claude Cowork

• Read the Claude Cowork explainer page in the site's Tools menu if you want the overview first.
• Cowork works on local files directly, which makes it a better fit than a normal chat workflow for folder inspection and cleanup.
• For recurring clients, consider a Cowork project so the same instructions and folder expectations stay attached to the task.
• Treat Cowork as a pre-send inspection tool. It should not send files to the client.
• Do not let Cowork rename, move, delete, or modify files unless you approve specific operations.

Quality checks

1. Every promised asset is explicitly accounted for as present or missing.
2. Naming and format requirements are checked against the actual checklist, not guessed.
3. No source file is renamed or moved unless you approved that step.
4. Duplicates, wrong-format assets, naming mismatches, and optional files are clearly separated.
5. Conflicts between the brief and checklist are flagged for a human decision.
6. The final verdict is short enough that you can trust it as a pre-send gate.
7. Nothing is sent to the client automatically.

Common failure modes and fixes

Cowork flags too many false problems

Fix: make delivery-checklist.txt more explicit about which files are optional and which are final.

Important files are buried in subfolders

Fix: either flatten the delivery folder or state the intended subfolder structure in the checklist.

The brief and checklist disagree

Fix: resolve that conflict yourself before the final review pass. Cowork can flag the mismatch, but you still need the decision.

Cowork starts changing files too early

Fix: stop the task and return to the comparison report. Approve only specific file operations after you understand the issue.