How to Use Claude Cowork to Turn a Folder of Drafts Into a Board or Leadership Meeting Packet

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

A board or leadership meeting packet is usually built from a messy folder: agenda draft, prior minutes, one or two slide decks, attached PDFs, maybe an unfinished memo, and a few files that still need cleanup. Doing it by hand is repetitive and easy to miss.

This workflow is for admins, executive assistants, chiefs of staff, and operations coordinators who already maintain a local meeting folder and want Claude Cowork to assemble the packet faster.

Why Cowork fits this workflow

Cowork fits this workflow because the work depends on the contents of a local folder. A board packet is not just one document. It is a set of source drafts, attachments, agenda files, versioned memos, and sometimes duplicate or stale files that need to be inspected before anything is assembled.

Use Cowork when you need local folder inspection, duplicate-draft detection, missing-item flags, a proposed packet order, and controlled output creation in a final-packet folder. The key safety pattern is inspect first, approve the assembly plan, then let Cowork create outputs without overwriting the source drafts.

Why not normal Claude chat or just a Skill?

Normal Claude chat can draft a cover note if you manually upload or paste the packet material. That can work for a small one-off packet, but it does not replace folder inspection, source-file preservation, duplicate detection, or controlled output creation in a local final-packet folder.

A Skill can standardize packet language, cover-note tone, or meeting-summary rules. It does not replace the workspace-level inspection and assembly plan. For this workflow, Cowork is the local folder and output creation tool. Any Skill is only an optional writing layer after the inventory and packet plan are approved.

Prerequisites

• Claude Desktop with Cowork available on your paid plan.
• A single local folder for the meeting packet.
• A clear packet order. Example: cover note, agenda, prior minutes, decision memo, appendix PDFs.
• Permission to let Cowork access that folder.

Set up this workflow as a Cowork project

For a recurring board series or leadership team meeting, create one Cowork project instead of rebuilding the setup each time. Keep each meeting's current materials in the active source folder, and keep old or excluded files out of the active workspace.

Use this project structure:

source-drafts/
archive-do-not-use/
final-packet/
review-notes/
packet-instructions.txt

Use source-drafts for the current meeting materials only. Use archive-do-not-use for stale drafts, old packets, or historical files that should not be included unless you explicitly approve them. Use final-packet for Cowork-created outputs. Use review-notes for human corrections, missing-item notes, and decisions about packet order.

Put the desired order, audience, meeting date, due date, excluded files, and special handling rules in packet-instructions.txt.

Add project instructions so future packet runs require less repeated context:

{
  "project_name": "Board Packet Assembly",
  "project_purpose": "Use Claude Cowork to inspect a meeting packet folder, flag missing or duplicate materials, propose packet order, and create final packet outputs without overwriting source drafts.",
  "project_instructions": [
    "Always inspect the folder and create an inventory before assembling the packet.",
    "Use only files in source-drafts unless I explicitly approve another folder.",
    "Do not delete, overwrite, move, or rename source drafts unless I explicitly approve.",
    "Flag missing agenda items, duplicate drafts, version conflicts, and unrelated files.",
    "Propose the final packet order before creating output files.",
    "Create output files only inside final-packet.",
    "Create a short source map showing which source files were used in the final packet.",
    "Ask for approval before assembling the final packet."
  ],
  "file_naming": "board-packet-yyyy-mm-dd"
}

This project setup turns the existing inspect-first approach into a repeatable Cowork safety pattern. Cowork inventories the folder and proposes the plan. You approve the plan. Cowork creates outputs only in the final folder.

How to gather the source material

1. Create one local folder or Cowork project for this meeting series.
2. Move the current packet ingredients into source-drafts.
3. Rename files so the order is obvious. Example: 01-agenda.docx, 02-prior-minutes.pdf, 03-budget-memo.docx, 04-appendix.pdf.
4. Move stale drafts, prior packets, and historical files into archive-do-not-use.
5. Add one small text file called packet-instructions.txt that lists the desired order, audience, due date, and any file that should be excluded.
6. Keep final-packet empty until the inventory and assembly plan are approved.

Numbered workflow steps

1) Set up the folder before Cowork touches it

Cowork works best when the local workspace is clean. Give it one project folder, not your entire documents library. Keep active files in source-drafts, and keep old drafts in archive-do-not-use.

2) Ask Cowork for an inventory and missing-items check first

Do not ask it to assemble the final packet on the first prompt. First, make it inspect the folder and tell you what is missing, duplicated, unrelated, or out of order. This inspect-first step is the standard Cowork safety pattern for packet work.

{
  "task": "Inspect a local meeting-packet folder and prepare an assembly plan",
  "input": {
    "working_folder": "LOCAL COWORK PROJECT OR MEETING PACKET FOLDER",
    "source_folder": "source-drafts",
    "packet_instructions_file": "packet-instructions.txt"
  },
  "rules": [
    "Read the files in source-drafts and report what each appears to be.",
    "Do not delete, overwrite, move, or rename anything yet.",
    "Flag missing expected items, duplicate drafts, version conflicts, and unrelated files.",
    "Propose the final packet order before assembly."
  ],
  "output": {
    "file_inventory": "Ordered list of files and what each is for",
    "missing_items": "Expected items not found",
    "cleanup_flags": "Duplicate drafts, stale files, or naming issues",
    "proposed_packet_order": "Final packet sequence",
    "source_map_plan": "Which source files appear likely to feed the final packet"
  }
}

3) Approve the plan, then have Cowork assemble the packet

Once the file order looks right, give Cowork permission to create the packet output inside a new final-packet subfolder.

{
  "task": "Assemble a board or leadership meeting packet from a verified local folder",
  "input": {
    "approved_packet_order": "PASTE OR CONFIRM THE ORDER FROM STEP 2",
    "output_folder": "LOCAL FOLDER PATH/final-packet"
  },
  "rules": [
    "Create output files in the final-packet folder only.",
    "Do not overwrite the source drafts.",
    "Keep the packet order exactly as approved.",
    "Create a short source map showing which source files were used.",
    "Produce a short cover note summarizing the contents and missing items, if any remain."
  ],
  "output_format": {
    "type": "assembled_packet"
  }
}

4) Review the packet manually before distribution

Open the finished files. Check page order, attachment inclusion, meeting date, and any version labels. Cowork saves time, but packet owners still need a final human pass.

Future packet runs

For the next board or leadership meeting, reuse the same Cowork project. Empty or archive last meeting's active materials, place the new files in source-drafts, update packet-instructions.txt, and start with a short prompt:

Prepare the packet inventory and assembly plan for the next board meeting.

For a stricter reusable prompt, use this:

{
  "task": "Prepare the packet inventory and assembly plan for the next board meeting.",
  "rules": [
    "Use the Board Packet Assembly project instructions.",
    "Inspect source-drafts only.",
    "Create the file inventory, missing-items list, cleanup flags, and proposed packet order.",
    "Do not assemble the final packet until I approve the plan."
  ]
}

The project keeps the folder rules, source-safety rules, and output location stable. You still approve the plan and review the final packet before distribution.

Tool-specific instructions

Claude Cowork

• Read the Claude Cowork explainer page in the site's Tools menu if you want the feature overview first.
• Cowork runs in Claude Desktop and works on the files you choose to share.
• It can access local files directly, run longer tasks, and coordinate multi-step work in parallel.
• Use a Cowork project for recurring board series so the folder structure, instructions, and memory stay together over time.
• Use inspect first, approve second, assemble third as the standard safety pattern. Do not let Cowork overwrite source drafts or create outputs outside final-packet.

Quality checks

1. Every source file in the packet is the correct version and appears once.
2. The packet order matches the approved order in packet-instructions.txt.
3. No draft file was overwritten in place.
4. Output files were created only inside final-packet.
5. The source map shows which source files were used.
6. The cover note accurately flags anything still missing.
7. A human reviewed the finished packet before distribution.

Common failure modes and fixes

Cowork includes the wrong draft

Fix: clean the folder first and rename the approved version clearly before rerunning Step 2.

The packet order comes out wrong

Fix: state the desired order explicitly in packet-instructions.txt and approve the proposed order before assembly.

Sensitive side files get pulled in

Fix: keep Cowork limited to a dedicated meeting folder rather than a larger parent folder. Move files that should not be used into archive-do-not-use before running the inventory.

Cowork starts assembling too early

Fix: stop the task and return to the inventory prompt. Require a file inventory, missing-items list, cleanup flags, and proposed packet order before approving final output creation.