How Educators Can Use Claude Cowork to Turn a Folder of Readings, Notes, and Slide Drafts Into a Workshop Pack

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 with local files and folders you choose to share. For related examples, see the Claude Cowork tool hub and the Anthropic Workflows series.

Problem and who this is for

A workshop pack usually lives in too many places at once: readings in one folder, notes in another, half-finished slides somewhere else, and the handout still in your head. Claude Cowork is a good fit when the real problem is not writing one paragraph. The real problem is gathering local files, sorting what matters, and producing a finished working set.

This workflow is for instructors, trainers, faculty, and coaches building a workshop from material they already have on their computer.

Why Cowork fits this workflow

Cowork fits this workflow because the real job is folder-level work. A workshop pack usually depends on reading several files, sorting sources, finding gaps, aligning outputs to the time limit and audience, and creating multiple deliverables from the same source set.

Use Cowork when the source materials already live in a local folder and the output needs more than one file: a source inventory, workshop plan, slide structure, participant handout, and missing-items checklist. Cowork can inspect the selected folder, propose a plan, and save finished outputs into an output-pack folder after you approve the plan.

Cowork does not prove that the readings are accurate or complete. It organizes and drafts from the sources you provide, so you still review the educational content before teaching from it.

Why not normal Claude chat or just a Skill?

Normal Claude chat can draft a handout if you manually upload or paste the readings, notes, and slide draft content. That can work for a small one-off workshop, but it adds friction when the source material already lives in a local teaching folder.

A Skill can standardize a workshop-pack format, such as the headings, facilitation style, or handout structure. It does not replace Cowork's source inspection and assembly role. For this workflow, Cowork is the better layer for inspecting the local folder, identifying gaps, planning the outputs, and creating the pack from one source set.

Prerequisites

• Claude Desktop with Cowork available on a paid Claude plan.
• One clearly scoped local workshop folder or Cowork project.
• A short file called workshop-brief.txt with audience, session length, and learning goals.
• Enough disk organization that you can isolate only the files for this workshop.

Set up this workflow as a Cowork project

If you build similar workshop packs repeatedly, create one Cowork project for the workshop series or template. Keep the folder structure stable so each new workshop starts with the same setup.

Use this project structure:

source-readings/
facilitation-notes/
slide-drafts/
output-pack/
archive/
workshop-brief.txt

Use source-readings for PDFs, articles, excerpts, or approved source material. Use facilitation-notes for your teaching notes, timing notes, examples, and discussion prompts. Use slide-drafts for existing decks, outlines, or rough slide files. Use output-pack only for finished outputs. Move old or unrelated materials into archive.

Use workshop-brief.txt to state the audience, session length, learning goals, required outputs, and any boundaries about what not to include.

Add project instructions so future workshop builds need less repeated prompting:

{
  "project_name": "Workshop Pack Builder",
  "project_purpose": "Use Claude Cowork to inspect a workshop folder and create a source-grounded workshop pack with slide structure, participant handout, and missing-items checklist.",
  "project_instructions": [
    "Use only files in the current workshop project unless I approve another source.",
    "Read workshop-brief.txt before proposing any output.",
    "Inventory readings, notes, slide drafts, and missing materials before drafting.",
    "Keep the session length, audience level, and learning goals visible in the plan.",
    "Do not fabricate citations, examples, or source details not present in the folder.",
    "Create the workshop plan first and wait for approval before creating final outputs.",
    "Save finished outputs in output-pack."
  ],
  "file_naming": "workshop-pack-topic-yyyy-mm-dd"
}

This setup keeps the source folders, output folder, and review rules stable. Cowork inspects first, proposes the plan, and creates final outputs only after you approve the plan.

How to gather the source material

1. Create one local folder or Cowork project for the workshop and copy only the relevant source files into it.
2. Rename files clearly. Example: week-3-reading.pdf, slide-draft-v2.pptx, facilitation-notes.txt.
3. Sort readings into source-readings, teaching notes into facilitation-notes, and existing decks or outlines into slide-drafts.
4. Move outdated materials into archive if you want to keep them nearby but out of the main run.
5. Create workshop-brief.txt with the audience, time limit, learning goals, and the exact outputs you want. Example: slide deck outline, participant handout, missing-items list.
6. If the readings include scans or images, make sure they are readable or convert them to searchable PDFs first.
7. Keep output-pack empty until you approve the workshop plan.

Numbered workflow steps

1) Set up a small local project folder before you start Cowork

Cowork works best when the folder is clean, current, and limited to the specific task. Create the project folder, drop in only the files you want Claude to use, and add workshop-brief.txt before asking for output.

2) Let Cowork inspect the folder and build a working plan

{
  "task": "Inspect this workshop folder and prepare a plan for a complete workshop pack",
  "input": {
    "folder": "LOCAL WORKSHOP PROJECT OR FOLDER",
    "source_readings_folder": "source-readings",
    "facilitation_notes_folder": "facilitation-notes",
    "slide_drafts_folder": "slide-drafts",
    "brief_file": "workshop-brief.txt"
  },
  "rules": [
    "Inspect only files in the selected workshop project.",
    "Read workshop-brief.txt before proposing any output.",
    "Identify readings, notes, existing slides, and missing source gaps.",
    "Keep session length, audience level, and learning goals visible in the plan.",
    "Propose a slide structure, handout structure, and unresolved item list.",
    "Do not finalize files until the plan is reviewed."
  ],
  "output": {
    "workshop_plan": "Clear plan for the pack",
    "source_inventory": "What files are being used",
    "missing_items": "What is still needed or unclear"
  }
}

3) Review the plan before you let Cowork finish the output

Check the source inventory first. If Cowork pulled in the wrong draft or an outdated reading, fix that before the output stage. Then confirm the workshop plan still matches the audience, time limit, and learning goals in workshop-brief.txt.

This inspect-first and review-plan-before-output pattern is the safety layer. Do not create final outputs until the source inventory and plan are correct.

4) Ask Cowork for the finished deliverable

{
  "task": "Create a workshop pack from the reviewed local folder plan",
  "input": {
    "approved_plan": "USE THE REVIEWED PLAN",
    "deliverables": [
      "slide deck outline or draft",
      "participant handout",
      "missing-items checklist"
    ]
  },
  "rules": [
    "Write outputs directly from the files in the selected folder.",
    "Keep the workshop aligned to the stated time limit.",
    "Use the missing-items checklist to show what still needs human input.",
    "Do not fabricate citations or source details not present in the folder.",
    "Save final outputs in output-pack."
  ],
  "output_format": {
    "type": "workshop_pack"
  }
}

5) Save the result and archive the input folder

Rename the finished files clearly and keep them in output-pack. Move older source sets, drafts, or unused materials into archive after you finish the review.

Future workshop runs

For the next workshop, reuse the same Cowork project. Replace the current source files, update workshop-brief.txt, and start with a shorter request:

Create a workshop pack plan from the current project files.

For a stricter reusable prompt, use this:

{
  "task": "Create a workshop pack plan from the current project files.",
  "rules": [
    "Use the Workshop Pack Builder project instructions.",
    "Inspect the current source-readings, facilitation-notes, and slide-drafts folders.",
    "Create a source inventory, missing-items list, and proposed output plan.",
    "Do not create final outputs until I approve the plan."
  ]
}

The repeatability comes from the stable folder structure and project instructions. You still review the source inventory, workshop plan, handout, slide structure, and missing-items list before using the pack with learners.

Tool-specific instructions

Cowork fits this job because the friction is folder-level work: file inspection, source sorting, gap finding, plan creation, and multi-file output. Use a Cowork project if you run this kind of workshop build repeatedly.

Use normal Claude chat for a one-off handout only when you are willing to upload or paste the needed source material yourself. Use a Skill if you want a reusable workshop-pack format, but keep Cowork as the source inspection and assembly layer.

Quality checks

1. The source inventory lists only files that belong to this workshop.
2. The slide structure fits the session length.
3. The participant handout matches the actual workshop plan.
4. The missing-items list is honest about what Cowork could not infer.
5. Citations, examples, and source details come from the selected folder.
6. Finished outputs are saved in output-pack.
7. A human reviews educational accuracy before teaching from the pack.

Common failure modes and fixes

Old materials leak into the pack

Fix: archive or remove outdated files before you start Cowork. Keep only current materials in source-readings, facilitation-notes, and slide-drafts.

The output is too broad

Fix: make workshop-brief.txt tighter. Session length and audience level matter a lot.

Scanned readings are hard to use

Fix: convert them to searchable PDFs before you run the folder through Cowork.

Cowork starts drafting before the plan is right

Fix: stop the task and return to the inspection prompt. Approve the source inventory, missing-items list, and proposed output plan before final output creation.