How Educators Can Use Claude Cowork to Turn a Semester Folder Into a Course Retrospective 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 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

At the end of a term, you may have feedback exports, attendance notes, assignment summaries, weekly lesson plans, and informal observations spread across a semester folder. The retrospective packet is useful, but gathering the material is the hard part. That makes it a strong Cowork job.

This workflow is for educators, course leads, program coordinators, and instructional teams who want a practical end-of-term review packet.

Why Cowork fits this workflow

Cowork fits this workflow because the difficult part is evidence gathering across local artifacts. A semester review may include feedback exports, assignment summaries, attendance trend reports, revision logs, lesson notes, LMS exports, and informal observations. Those materials often live in a local folder, not in one clean prompt.

Use Cowork when you need the folder inspected, the sources inventoried, and the evidence mapped before a packet is drafted. Cowork can separate evidence of strengths, friction points, and revision opportunities, then create a plan for the retrospective packet from the scoped folder.

Cowork does not make final curricular decisions. It helps organize the evidence you provide. You still decide what claims are fair, what student details must stay private, and what changes are appropriate for the next term.

Why not normal Claude chat or just a Skill?

Normal Claude chat can help draft a memo after you paste the evidence into the conversation. That can work for a short summary, but it adds friction when the evidence already lives across a local semester-review folder.

A Skill may help standardize retrospective sections, such as strengths, friction points, revision opportunities, and next-term actions. It does not replace Cowork's source inspection layer. For this workflow, Cowork is the better tool for reviewing the local folder, creating an evidence map, and keeping weak or uncertain evidence visible before drafting.

Prerequisites

• Claude Desktop with Cowork available on a paid Claude plan.
• One carefully scoped semester-review folder or Cowork project.
• A short file called retrospective-brief.txt with the audience, packet length, and the decisions the packet should support.
• A willingness to trim the folder before you run Cowork.

Set up this workflow as a Cowork project

If you prepare end-of-term reviews repeatedly, create one Cowork project for course retrospective packets. Keep the folder structure consistent across terms so project instructions and project memory can support future semester reviews without repeated setup.

Use this project structure:

source-artifacts/
excluded-private-material/
output-packet/
review-notes/
archive-prior-terms/
retrospective-brief.txt

Use source-artifacts for the materials Cowork may inspect: feedback exports, assignment summaries, attendance trend reports, revision logs, course notes, and approved observations. Use excluded-private-material for files that should not be used in the retrospective, such as raw gradebooks, files with unnecessary student identifiers, accommodations, private messages, or sensitive student details. Use output-packet for finished drafts. Use review-notes for human interpretation, caveats, and decisions about what should be revised. Use archive-prior-terms for old packets or previous-term source sets.

Put the audience, course or program context, term, review goals, packet length, and decision questions in retrospective-brief.txt.

Add project instructions so future semester reviews start from the same evidence-handling rules:

{
  "project_name": "Course Retrospective Packet",
  "project_purpose": "Use Claude Cowork to inspect a semester-review folder, create an evidence map, and draft a practical end-of-term retrospective packet.",
  "project_instructions": [
    "Use only files in source-artifacts unless I explicitly approve another source.",
    "Do not use files placed in excluded-private-material.",
    "Inventory all source files before creating the retrospective plan.",
    "Separate evidence of strengths, friction points, and revision opportunities.",
    "Keep student identifiers, grades, and private details out of the final packet unless formally approved and appropriate.",
    "Mark uncertain or weak evidence instead of turning it into strong claims.",
    "Create a packet plan and wait for approval before drafting the final packet.",
    "Save final outputs in output-packet."
  ],
  "file_naming": "course-retrospective-course-term-yyyy"
}

The project instructions and project memory help future runs because Cowork can keep the review pattern, folder boundaries, and preferred packet structure together. They do not replace human judgment about student privacy or course changes.

How to gather the source material

1. Create a clean semester-review folder or Cowork project and copy only the files needed for the retrospective into it.
2. Good candidates include feedback exports, assignment summaries, course notes, attendance trend reports, and major revision logs.
3. Put approved review materials in source-artifacts.
4. Move private or out-of-scope material into excluded-private-material, or leave it outside the project entirely.
5. Bad candidates include random downloads, duplicate slide decks, raw gradebooks, and private material that does not belong in a review packet.
6. Create retrospective-brief.txt with the audience, the decisions the packet should support, and the sections you want. Example: what worked, where students struggled, what to revise next term.
7. If key files are in spreadsheets or LMS exports, keep them in their native format if readable. Cowork can inspect local files directly.

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, put approved review files in source-artifacts, keep private material out of scope, and add retrospective-brief.txt.

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

{
  "task": "Inspect a semester-review folder and prepare a course retrospective packet plan",
  "input": {
    "folder": "LOCAL SEMESTER REVIEW PROJECT OR FOLDER",
    "source_folder": "source-artifacts",
    "excluded_folder": "excluded-private-material",
    "brief_file": "retrospective-brief.txt"
  },
  "rules": [
    "Inventory the files in source-artifacts and identify what each contributes.",
    "Do not use files in excluded-private-material.",
    "Separate evidence of strengths, friction points, and revision opportunities.",
    "Keep student identifiers, grades, and private details out of the packet plan unless explicitly approved.",
    "Keep uncertain inferences visible.",
    "Do not write the final packet until the plan is reviewed."
  ],
  "output": {
    "source_inventory": "What files are being used and why",
    "evidence_map": "Strengths, problems, and revision opportunities",
    "uncertain_items": "Areas that need human interpretation",
    "packet_plan": "Recommended section structure"
  }
}

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

Read the source inventory and evidence map before you let Cowork finish the packet. This is where you remove weak or irrelevant files, keep one noisy document from shaping the whole retrospective, and catch any private student details that should not be in the final packet.

Keep the uncertain-items list visible. If evidence is thin, mixed, or based on a small number of comments, keep it marked as uncertain instead of turning it into a strong claim.

4) Ask Cowork for the finished deliverable

{
  "task": "Create a course retrospective packet from the reviewed semester folder plan",
  "input": {
    "approved_plan": "USE THE REVIEWED PLAN"
  },
  "rules": [
    "Keep the packet tied to the reviewed evidence map.",
    "Use headings for strengths, friction points, and next-term changes.",
    "Make uncertainty visible instead of flattening it into certainty.",
    "Keep student identifiers, grades, and private details out unless formally approved and appropriate.",
    "End with a short next-term action list.",
    "Save final outputs in output-packet."
  ],
  "output_format": {
    "type": "retrospective_packet"
  }
}

5) Save the result and archive the input folder

Rename the finished files clearly and save them in output-packet. Move the prior term's source set into archive-prior-terms before starting the next term's review.

Future term runs

For the next semester review, reuse the same Cowork project. Replace the current files in source-artifacts, keep private material in excluded-private-material or out of the project, update retrospective-brief.txt, and start with a shorter prompt:

Prepare this term's course retrospective packet plan.

For a stricter reusable prompt, use this:

{
  "task": "Prepare this term's course retrospective packet plan.",
  "rules": [
    "Use the Course Retrospective Packet project instructions.",
    "Inspect only source-artifacts.",
    "Create a source inventory, evidence map, uncertain-items list, and packet plan.",
    "Do not draft the final packet until I approve the plan."
  ]
}

The project instructions and memory reduce repeated setup over time. They can keep the same folder boundaries, packet sections, and evidence-handling rules in view, while you still make the final calls about student privacy and course revisions.

Tool-specific instructions

Cowork is a good fit because the core work is evidence gathering across a local folder, not just drafting one memo from memory. Cowork projects are especially useful if you prepare retrospective packets every term because the folder structure, instructions, and memory can stay together over time.

Use normal Claude chat when you have already pasted a small, approved evidence set and only need a draft memo. Use a Skill if you want a consistent retrospective format. Keep Cowork as the source inspection and evidence-mapping layer when the material lives across a local semester folder.

Quality checks

1. Every major point in the packet comes from identifiable source files.
2. One dramatic comment or one unusual week did not dominate the packet.
3. Next-term actions are limited enough to be realistic.
4. Student identifiers, grades, and private details are absent unless formally approved and appropriate.
5. Weak or uncertain evidence remains marked as uncertain.
6. The packet reflects the audience and decision goals named in retrospective-brief.txt.
7. A human reviews the packet before curricular or program decisions are made.

Common failure modes and fixes

The packet becomes too broad

Fix: trim the folder and tighten retrospective-brief.txt so Cowork knows what the packet is for.

Too much private material is included

Fix: remove or redact sensitive files before you run Cowork. Keep private files in excluded-private-material or outside the project, and instruct Cowork not to use that folder.

Weak evidence becomes strong claims

Fix: keep an uncertain-items section and review it before the final packet stage.

The packet turns into a decision instead of evidence

Fix: keep the packet framed as evidence and options. Final course, grading, staffing, or policy decisions need human review by the appropriate educator or program lead.