Presentation Talk Track Builder

Overview

This skill turns slides into a spoken talk track. For each requested slide it

writes a first-person script the presenter can read aloud, grounded in the

slide's content and — above all — its speaker notes. It calibrates the

script length to a target time and speaking pace and returns a timing table

so the presenter knows whether they will land on time.

Core rule: the speaker notes are the source of truth. When notes and

slide text disagree, the script follows the notes and silently drops the

contradicted slide text. This is what the author intended to say.

Works across Scout, Copilot Studio, and Cowork. The user can attach a

.pptx, provide slide images, paste slide text, or provide an outline.

When to Use

• "I'm presenting slides 8-11, write a script for each so I can present them."
• "Turn my speaker notes into what I should actually say."
• "Make a ~6-minute talk track for these four slides; I speak fast."
• "Write presenter narration for this deck / these slide images."
• "Give me a word-for-word script with pauses and a handoff to the next

speaker."

When NOT to Use

• Creating, designing, or editing the visible content of the slides

themselves.

• Summarizing a recorded meeting, call, or transcript.
• Writing a standalone document, memo, or article.
• A quick one-line answer that isn't a spoken script — answer inline.

Quick Start

User: "I'm presenting slides 8-11, write a script for each. If the notes
       contradict the slides, follow the notes. Target ~6 minutes, business
       audience."
1. Capture inputs — audience & goals, slide content, optional supporting
   context.
2. Extract BOTH slide text AND speaker notes for the requested slides.
3. Reconcile: where notes contradict slides, follow the notes.
4. Calibrate: target minutes × pace (words/min) = word budget; split by
   slide.
5. Write a first-person script per slide with delivery cues + a handoff line.
6. Return the scripts + a per-slide timing table (words → spoken minutes).
7. Offer to save as speaker notes back into a copy of the deck, or as a doc.

Core Instructions

Step 0 — Capture audience & goals (required)

Before writing anything, capture:

• Audience: who is in the room (or on the call)? Role, seniority,

technical depth, familiarity with the topic.

• Event context: keynote, internal review, customer meeting, training,

panel, webinar.

• Presenter goal: what should the audience *understand*, *decide*, or

*do* after the presentation?

• Tone: formal, conversational, energetic, deliberate.
• Target duration and speaking pace (see Step 4).

If the user hasn't provided these, ask once. If they decline, use the

defaults below and label them as assumptions in the output:

• Audience: general business audience.
• Tone: clear, confident, conversational.
• Goal: help the audience understand the deck's main message and next step.

Step 1 — Locate the slides and any supporting context

• If a .pptx/.pptm is attached or on disk, use it. Check the user's

likely input folders first (Downloads, current workspace) even when the

user does not name a path.

• If only slide images are provided, work from what's visible and tell

the user there were no speaker notes to follow.

• If only pasted text or an outline is provided, use that directly.
• Confirm exactly which slide numbers to cover. If the user did not name

specific slides, cover the whole deck.

• Ask the user for optional supporting context the model can weave into

the narration (but not into the slides themselves): a product one-pager,

a prior version of the talk, a customer brief, an FAQ, source links, or

presenter background notes. This is especially useful when the existing

speaker notes are thin or missing.

Step 2 — Extract slide text AND speaker notes (both matter)

• Slide text and existing speaker notes can be extracted with the bundled

helper:

  python scripts/pptx_talk_track.py extract <deck>.pptx <slides>.json

The output JSON contains title, visibleText, and existingNotes per

slide. Both fields matter.

• If you have python-pptx available you can also use

slide.notes_slide.notes_text_frame.text to read notes.

• Map notes to the correct slide numbers.

Step 3 — Reconcile notes vs. slides (notes win)

• Read both. Where the notes state something different from the slide (a

different figure, name, framing, date, or emphasis), write the script to

match the notes and drop the contradicted slide text.

• Where notes add context the slide omits, include it. Where notes are

sparse, lean on the slide content and any supporting context to fill the

spoken narrative — never invent.

• Note any contradiction you resolved in a one-line aside after the

scripts, so the presenter knows why the script diverges from what's on

screen.

Step 4 — Calibrate timing to the target

• Ask for (or infer) two things: target duration and speaking pace. If the

user says they "speak fast", use a brisk pace; otherwise default to

average.

• Pace reference (words per minute):

| Pace | WPM | Use when |

|------|-----|----------|

| Deliberate | 110-130 | Technical/dense content, non-native audience |

| Average | 130-150 | Default |

| Brisk / "I speak fast" | 165-185 | User says they rush or speak quickly |

• Word budget = target minutes × chosen WPM. Divide across slides by

weight (slides with denser notes get more words). Compute totals and

per-slide times with a code tool — never estimate arithmetic by hand.

• Presenters speed up live, so aim the *written* script slightly LONG of

the target (e.g. write to ~6:15 for a 6:00 goal) and add [pause] cues,

which both reinforce key points and naturally slow a fast speaker.

Step 5 — Write the script (spoken, first person)

• One clearly-headed section per slide: ## Slide N — <short title>.
• Natural spoken language, first person ("Let me show you…", "Here's why

this matters…"). Contractions on. Short sentences. No bulleted

fragments — full spoken prose.

• Put delivery cues in italics or brackets: *[pause]*, *(gesture to the

diagram)*, *(click to reveal)*, *(hand off)*.

• Open each slide with a one-line bridge from the previous slide; close

the last covered slide with a handoff line to the next presenter or to

Q&A if relevant.

• Mirror the deck's terminology and the user's domain voice.
• Tailor the depth and framing to the audience captured in Step 0.

Step 6 — Deliver with a timing table

• After the scripts, show a table: Slide | approx. words | spoken time,

with a total and the estimated overall minutes at the chosen pace.

• Call out the easiest lines to cut if running long, and offer to tighten

any slide to a specific per-slide time.

Step 7 — Offer to save the output

• Offer to save the scripts back into a copy of the deck as speaker notes,

using:

  python scripts/pptx_talk_track.py apply <deck>.pptx <notes>.json <output>.pptx

The helper writes speaker notes only. It never changes visible slide

content, order, formatting, images, charts, or animations.

• Alternatively, offer to save as a Word document for presenter notes.
• Only save a file when the user asks for one.

Output

• Markdown by default (inline), one section per slide, in slide order.
• First-person spoken prose with italic delivery cues; a handoff line

where relevant.

• A closing timing table (words + spoken minutes per slide, plus total)

and a one-line note of any note-vs-slide contradiction resolved.

• Tone matches the deck; length matches the time budget.

See references/tone-examples.md for target voice samples.

Guardrails

• Notes are authoritative. When speaker notes contradict slide text,

follow the notes and drop the contradicted slide content — this is the

whole point of the skill.

• Never modify visible slide content. Slide text, order, layouts,

images, charts, and animations must stay unchanged. If notes are written

back to a .pptx, only speaker notes in a copied file are updated.

• Never fabricate facts. Do not invent figures, names, dates, or

quotes that aren't in the slides, notes, or supporting context. Mark

genuine gaps as [confirm: …] rather than guessing.

• Confidentiality and sensitivity. If slides or notes carry a

confidentiality label or sensitivity marking (for example

"Confidential", "Internal Only", "Restricted", or an enterprise

information-protection label), or contain unreleased figures,

customer or partner identifiers, or names that aren't public yet,

flag them and confirm with the user before including that content in

the spoken script. Never add PII or customer identifiers the source

material doesn't already contain.

• Compute timings with code, not by hand; state the pace assumption

so the presenter can recalibrate.

• Cover exactly the requested slides — no more, no fewer — and

preserve their order. If the user asks for "the whole deck", cover

every slide.

• Do not reproduce third-party copyrighted text verbatim from slide

images; paraphrase into the presenter's own spoken words.

• If you can't read the deck after a couple of attempts, say so plainly

and ask the user to re-attach it — do not substitute placeholder slide

content.

Bundled helper script

scripts/pptx_talk_track.py uses only the Python standard library.

• extract <deck>.pptx <slides>.json — read slide titles, visible text,

and existing speaker notes.

• template <deck>.pptx <notes>.json — write an empty notes JSON template

with one entry per slide, ready to fill in with generated scripts.

• apply <deck>.pptx <notes>.json <output>.pptx — write the generated

scripts into a copied deck as speaker notes. Never overwrites the

original.

If a deck has no notes master, open and save it once in PowerPoint (or add

a note to one slide) before rerunning the helper.

Runtime note: the helper needs Python 3 available in the runtime.

Scout, Copilot Studio, and Cowork all support this, so the extract /

template / apply commands work on all three platforms. If the

runtime doesn't have Python for any reason, the skill still works —

paste slide text, an outline, or slide images, and the model writes

the talk track and timing table inline. In that case, users who want

the scripts embedded back into a .pptx as speaker notes can run the

helper locally with Python 3 installed.

Assets and references

• references/tone-examples.md — short excerpts of the target

first-person, spoken voice with delivery cues.

• assets/example-notes.json — example of the notes JSON shape the

apply command consumes.