From a stalled deck to a course outline

A slide deck holds real expertise, but it was built for one hour in a room, with you there to fill the gaps out loud. A course has to work when you're not there. Every lesson needs one thing the learner can do by the end of it, in an order that builds. So the job isn't rewriting your content. It's restructuring it.

Get the words out

Take the slides and the speaker notes together. The notes matter: they hold what you only ever said out loud. You can copy them by hand, or, for a PowerPoint file, let a short script read them. This one uses python-pptx and the Anthropic Python SDK:

pip install python-pptx anthropic
export ANTHROPIC_API_KEY="..."   # your key, from console.anthropic.com

"""Turn a slide deck into a course outline with Claude.

Reads every slide's text and speaker notes from a .pptx,
then gives Claude the brief: who the course is for, what
they'll be able to do, modules, one outcome per lesson,
and the gaps the deck left for the speaker to fill.

    python3 outline.py workshop.pptx          # the outline
    python3 outline.py workshop.pptx --text   # deck text
"""
import sys

import anthropic
from pptx import Presentation

BRIEF = """Here is the text of a one-hour workshop deck, with the speaker notes.
Turn it into the outline of a short paid online course.

Who it's for: people who use Claude at work but get uneven results.
By the end they can: write a prompt that gets a usable answer the first time.

1. Group the material into 3 or 4 modules, in the order a learner needs it.
2. Under each module, list its lessons. Give every lesson one outcome, starting "You can".
3. Then list GAPS: places the deck relies on the speaker being in the room.
Use only what the deck covers. Plain text, no markdown, under 30 lines."""


def deck_text(path):
    lines = []
    for n, slide in enumerate(Presentation(path).slides, 1):
        text = [s.text_frame.text for s in slide.shapes
                if s.has_text_frame and s.text_frame.text]
        notes = ""
        if slide.has_notes_slide:
            notes = slide.notes_slide.notes_text_frame.text
        line = f"Slide {n}: " + " / ".join(text)
        lines.append(line + (f"\nNotes: {notes}" if notes else ""))
    return "\n".join(lines)


if __name__ == "__main__":
    text = deck_text(sys.argv[1])
    if "--text" in sys.argv:
        sys.exit(print(text))
    slides = text.count("Slide ")
    print(f"Read {slides} slides with their speaker notes. Asking Claude...\n")
    response = anthropic.Anthropic().messages.create(
        model="claude-sonnet-5-5",
        max_tokens=4000,
        messages=[{"role": "user", "content": f"{BRIEF}\n\n<deck>\n{text}\n</deck>"}],
    )
    print("".join(b.text for b in response.content if b.type == "text"))

python3 outline.py yourdeck.pptx --text prints just what it read, so you can check that the notes came through. Without --text, it sends that text to Claude with the brief.

The brief

The brief gives Claude three things: who the course is for, what they can do at the end, and the shape you want back. That shape is modules in the order a learner needs them, one outcome per lesson, and a list of gaps. Change the "Who it's for" and "By the end they can" lines to fit your own deck.

Read what comes back

The modules should follow what a learner needs first, not the order you gave the talk in. The gap list is often the most useful part: it marks the places where the deck relied on you being in the room. Those are the lessons you still have to write.

The common mistakes

• Treating each slide as a lesson. A slide is a talking point, and twenty slides don't make twenty lessons.
• Keeping everything Claude suggests. It can propose a lesson on something your deck never covered. Check every lesson against what you actually teach, and cut or rewrite any that aren't yours.