Presentation Prompt Pipeline
Six staged prompts that take a deck from idea to presentable, in the order the
work actually has to happen: message → outline → story → visual direction → copy
→ file. Each stage produces an artifact the next stage consumes, and each has a
gate you can check before spending the next prompt. This skill is the planning
and review layer; the mechanical creation of the .pptx is plain python-pptx.
When to Use
- Building a deck with a model from a brief, a document, or a pile of notes
- A deck exists but reads as a wall of bullets, or says nothing memorable
- Pitching, teaching, or reporting where the ask on the last slide matters
- Reviewing someone else's deck against a repeatable standard
- Don't use for: decks whose content is fixed by a template or mandate (drive
python-pptx directly), format conversion, or as a substitute for rendering
the slides and looking at them
The Six Stages
| # |
Stage |
Produces |
Gate before moving on |
| 1 |
Blueprint |
One message, audience, 3 emotional angles, slide flow, target slide count |
The deck's single message fits one falsifiable sentence, and you can name who it changes |
| 2 |
Structure |
Slide-by-slide outline: one-line purpose and intended feeling per slide |
Every slide has a purpose line; no slide exists "for context" |
| 3 |
Story frame |
Hook → Problem → Insight → Solution → Proof → Takeaway beat sheet mapped onto slides |
All six beats present; the last slide carries exactly one action |
| 4 |
Visual direction |
Emotional visual intent, chart-for-data choice, icon/grid for lists, 3-colour palette, font pairing |
Palette and fonts are named with hex/font values and cover every slide |
| 5 |
Content |
Titles ≤6 words, 3–5 bullets ≤10 words, one speaker note per slide, audience-matched tone |
deck_lint.py passes on the draft text |
| 6 |
Build |
The .pptx: bold titles, tight bullets, notes on every slide, clean flow |
deck_lint.py passes on the real file; rendered slides reviewed by eye |
Prompt Templates
Each prompt names its input and the shape of its output — that is what makes the
output checkable rather than merely plausible.
1 — Blueprint
You are a presentation strategist. From the material below, give me: (a) the ONE
message in a single sentence, phrased as a claim, not a topic; (b) the audience
and the three things they care about most; (c) three emotional angles I could
take and the risk of each; (d) a slide-by-slide flow in ≤12 steps; (e) the ideal
slide count and why that number. Be specific — no generic advice.
Material: {brief}
2 — Structure
Using this blueprint, write a slide-by-slide outline. For each slide: a one-line
purpose ("this slide makes the audience ___"), what they should feel, and the
single idea it carries. Flag any slide that repeats another's job. {blueprint}
3 — Story frame
Rewrite the outline into this six-beat story frame: Hook (grab attention),
Problem (the pain), Insight (the surprise), Solution (what to do), Proof (one
statistic or example), Takeaway (one action). Map each beat onto slide numbers,
and say in one line what the audience should feel at each beat. {outline}
4 — Visual direction
For each slide, specify: the emotion the visual must carry, whether the data is
better shown as a bar, line, pie, or a single big number and why, whether lists
become icons or a grid, one 3-colour palette with hex codes (background, ink,
accent), and one heading/body font pairing available in standard Office or
Google fonts. No stock-photo descriptions; describe the composition.
5 — Content
Write the final copy per slide: a title of ≤6 words, 3–5 bullets of ≤10 words
each (no sentences), and one speaker note of 2–3 sentences that says what to
say out loud — not a restatement of the bullets. Match this tone: {tone}.
Audience: {audience}. Keep the Takeaway slide to a single action.
6 — Build
Produce a python-pptx JSON spec for this content: 16:9, title+content layouts,
the palette and fonts above, speaker notes included per slide. Then the deck is
built and linted — not hand-assembled.
How to Run
Stages 1–5 are prompts: run each in a fresh context with the previous stage's
artifact pasted in, not as one mega-prompt. Stage 6 builds the file and then
lints it:
uv run --with python-pptx scripts/deck_lint.py deck.pptx
The linter is the only script here. It reads a .pptx, prints JSON or a human
line per finding, and exits 0 clean, 1 with findings, 2 unreadable file.
Tune the ceilings per deck:
uv run --with python-pptx scripts/deck_lint.py deck.pptx \
--max-title-words 8 --max-bullets 6 --max-bullet-words 12
Rules it enforces by default: title ≤6 words, ≤5 bullets per slide, ≤10 words per
bullet, speaker notes on every slide, ≤2 font families, ≤3 explicit text colours.
Quick Reference
| Symptom |
Where the process broke |
| Message is fuzzy |
Stage 1 accepted a topic ("Q3 review") instead of a claim |
| 30 slides of bullets |
Stage 2 outline has no purpose lines, so nothing could be cut |
| Every slide feels the same |
Stage 4's emotional intent was never specified |
| Titles are sentences |
Stage 5's ≤6-word rule, enforced by the linter |
| Data slide is unreadable |
Stage 4: one chart type per idea, one number per chart |
| Deck "done" but not delivered |
Notes missing, or the last slide has no single ask |
Pitfalls
- One mega-prompt. Asking for message + outline + copy + design at once
produces a generic deck, because the model optimises every constraint at once.
The stages exist so each constraint gets attention.
- A blueprint that names a topic, not a claim. "Q3 review" is not a message;
"Churn doubled and ownership fixes it" is. Stage 1's output must be falsifiable.
- Bullet walls dressed as structure. 5 bullets × 12 words reads as prose. The
≤10-word rule forces one idea per bullet.
- Decoration before storyline. Picking a theme or template first locks you
into layouts that fight the story; stage 4 comes after stage 3 for that reason.
- Speaker notes that repeat the bullets. Notes are the spoken track; if they
duplicate the slide, the deck is a document, not a presentation.
- Palette creep. Every extra accent colour dilutes the one that matters; the
linter caps explicit text colours at three by default.
- Trusting the outline instead of the rendered slide. Overflow, overlap and
contrast problems exist only in the render — always look at the slides.
- A Takeaway slide with three asks. One action. Three asks means the deck has
three messages and none of them lands.
Verification
deck_lint.py exits 0 on the final file
- Slides rendered to images and reviewed — no overflow, no contrast failure, no
orphaned bullet
- Stage 1's one-sentence message appears near the front, and the Takeaway slide
repeats the action rather than the message
- Every slide traces to a stage-2 purpose line; none is "context"
Reference
references/six-prompts-cheatsheet.md — transcription of the source infographic
(Cyberman AI, "How to build a presentation using AI: 6 powerful prompts"),
including each stage's checklist items.
1---2name: presentation-prompt-pipeline3description: Use this skill when building or repairing a presentation with an AI model — the six staged prompts (blueprint → structure → story frame → visual direction → content → build) that turn an idea into a deck with one message, each stage producing an artifact and a checkable gate, with prompt templates, eight named failure modes, and a deck_lint.py script that mechanically enforces short titles, tight bullets, speaker notes, a two-font and three-colour ceiling.4version: 1.0.05license: MIT6author: Joerg Peetz (JPeetz), Hermes Agent7platforms:8 - linux9 - macos10 - windows11metadata:12 source: https://skillmd.com/skills/jpeetz/presentation-prompt-pipeline13 hermes:14 tags:15 - presentations16 - slides17 - storytelling18 - prompting19 - deck-review20 - pptx21 related_skills:22 - spec-writer23---2425# Presentation Prompt Pipeline2627Six staged prompts that take a deck from idea to presentable, in the order the28work actually has to happen: message → outline → story → visual direction → copy29→ file. Each stage produces an artifact the next stage consumes, and each has a30gate you can check before spending the next prompt. This skill is the planning31and review layer; the mechanical creation of the `.pptx` is plain `python-pptx`.3233## When to Use3435- Building a deck with a model from a brief, a document, or a pile of notes36- A deck exists but reads as a wall of bullets, or says nothing memorable37- Pitching, teaching, or reporting where the *ask* on the last slide matters38- Reviewing someone else's deck against a repeatable standard39- Don't use for: decks whose content is fixed by a template or mandate (drive40 `python-pptx` directly), format conversion, or as a substitute for rendering41 the slides and looking at them4243## The Six Stages4445| # | Stage | Produces | Gate before moving on |46|---|-------|----------|------------------------|47| 1 | **Blueprint** | One message, audience, 3 emotional angles, slide flow, target slide count | The deck's single message fits one falsifiable sentence, and you can name who it changes |48| 2 | **Structure** | Slide-by-slide outline: one-line purpose and intended feeling per slide | Every slide has a purpose line; no slide exists "for context" |49| 3 | **Story frame** | Hook → Problem → Insight → Solution → Proof → Takeaway beat sheet mapped onto slides | All six beats present; the last slide carries exactly one action |50| 4 | **Visual direction** | Emotional visual intent, chart-for-data choice, icon/grid for lists, 3-colour palette, font pairing | Palette and fonts are named with hex/font values and cover every slide |51| 5 | **Content** | Titles ≤6 words, 3–5 bullets ≤10 words, one speaker note per slide, audience-matched tone | `deck_lint.py` passes on the draft text |52| 6 | **Build** | The `.pptx`: bold titles, tight bullets, notes on every slide, clean flow | `deck_lint.py` passes on the real file; rendered slides reviewed by eye |5354## Prompt Templates5556Each prompt names its input and the shape of its output — that is what makes the57output checkable rather than merely plausible.5859**1 — Blueprint**6061> You are a presentation strategist. From the material below, give me: (a) the ONE62> message in a single sentence, phrased as a claim, not a topic; (b) the audience63> and the three things they care about most; (c) three emotional angles I could64> take and the risk of each; (d) a slide-by-slide flow in ≤12 steps; (e) the ideal65> slide count and why that number. Be specific — no generic advice.66> Material: {brief}6768**2 — Structure**6970> Using this blueprint, write a slide-by-slide outline. For each slide: a one-line71> purpose ("this slide makes the audience ___"), what they should feel, and the72> single idea it carries. Flag any slide that repeats another's job. {blueprint}7374**3 — Story frame**7576> Rewrite the outline into this six-beat story frame: Hook (grab attention),77> Problem (the pain), Insight (the surprise), Solution (what to do), Proof (one78> statistic or example), Takeaway (one action). Map each beat onto slide numbers,79> and say in one line what the audience should feel at each beat. {outline}8081**4 — Visual direction**8283> For each slide, specify: the emotion the visual must carry, whether the data is84> better shown as a bar, line, pie, or a single big number and why, whether lists85> become icons or a grid, one 3-colour palette with hex codes (background, ink,86> accent), and one heading/body font pairing available in standard Office or87> Google fonts. No stock-photo descriptions; describe the composition.8889**5 — Content**9091> Write the final copy per slide: a title of ≤6 words, 3–5 bullets of ≤10 words92> each (no sentences), and one speaker note of 2–3 sentences that says what to93> say out loud — not a restatement of the bullets. Match this tone: {tone}.94> Audience: {audience}. Keep the Takeaway slide to a single action.9596**6 — Build**9798> Produce a python-pptx JSON spec for this content: 16:9, title+content layouts,99> the palette and fonts above, speaker notes included per slide. Then the deck is100> built and linted — not hand-assembled.101102## How to Run103104Stages 1–5 are prompts: run each in a **fresh** context with the previous stage's105artifact pasted in, not as one mega-prompt. Stage 6 builds the file and then106lints it:107108```bash109uv run --with python-pptx scripts/deck_lint.py deck.pptx110```111112The linter is the only script here. It reads a `.pptx`, prints JSON or a human113line per finding, and exits `0` clean, `1` with findings, `2` unreadable file.114Tune the ceilings per deck:115116```bash117uv run --with python-pptx scripts/deck_lint.py deck.pptx \118 --max-title-words 8 --max-bullets 6 --max-bullet-words 12119```120121Rules it enforces by default: title ≤6 words, ≤5 bullets per slide, ≤10 words per122bullet, speaker notes on every slide, ≤2 font families, ≤3 explicit text colours.123124## Quick Reference125126| Symptom | Where the process broke |127|---|---|128| Message is fuzzy | Stage 1 accepted a topic ("Q3 review") instead of a claim |129| 30 slides of bullets | Stage 2 outline has no purpose lines, so nothing could be cut |130| Every slide feels the same | Stage 4's emotional intent was never specified |131| Titles are sentences | Stage 5's ≤6-word rule, enforced by the linter |132| Data slide is unreadable | Stage 4: one chart type per idea, one number per chart |133| Deck "done" but not delivered | Notes missing, or the last slide has no single ask |134135## Pitfalls1361371. **One mega-prompt.** Asking for message + outline + copy + design at once138 produces a generic deck, because the model optimises every constraint at once.139 The stages exist so each constraint gets attention.1402. **A blueprint that names a topic, not a claim.** "Q3 review" is not a message;141 "Churn doubled and ownership fixes it" is. Stage 1's output must be falsifiable.1423. **Bullet walls dressed as structure.** 5 bullets × 12 words reads as prose. The143 ≤10-word rule forces one idea per bullet.1444. **Decoration before storyline.** Picking a theme or template first locks you145 into layouts that fight the story; stage 4 comes after stage 3 for that reason.1465. **Speaker notes that repeat the bullets.** Notes are the spoken track; if they147 duplicate the slide, the deck is a document, not a presentation.1486. **Palette creep.** Every extra accent colour dilutes the one that matters; the149 linter caps explicit text colours at three by default.1507. **Trusting the outline instead of the rendered slide.** Overflow, overlap and151 contrast problems exist only in the render — always look at the slides.1528. **A Takeaway slide with three asks.** One action. Three asks means the deck has153 three messages and none of them lands.154155## Verification156157- `deck_lint.py` exits 0 on the final file158- Slides rendered to images and reviewed — no overflow, no contrast failure, no159 orphaned bullet160- Stage 1's one-sentence message appears near the front, and the Takeaway slide161 repeats the action rather than the message162- Every slide traces to a stage-2 purpose line; none is "context"163164## Reference165166- `references/six-prompts-cheatsheet.md` — transcription of the source infographic167 (Cyberman AI, "How to build a presentation using AI: 6 powerful prompts"),168 including each stage's checklist items.