ppt-prepare

Original：🇺🇸 English

Translated

START HERE to create a NEW presentation from an idea or topic: a story-first method (Pyramid Principle and SCR narrative) that produces an approved storyline and a per-slide plan BEFORE any slide is built. Trigger when the user wants to create, make, build, plan, structure, outline, storyboard or think through a new talk/deck/pitch/presentation -- its message, story, argument, slide messages, titles or speaker notes. This is the entry point for any new deck; it hands the approved plan to the `ppt` skill, which builds the PPTX. NOT for: editing or changing an EXISTING deck's slides/text/images/charts -- that is `ppt`.

1installs

Sourcebrusdeylins/ppt-skill

Added on2026-08-16

NPX Install

npx skill4agent add brusdeylins/ppt-skill ppt-prepare

SKILL.md Content

View Translation Comparison →

@${CLAUDE_SKILL_DIR}/../../meta/control.md

You are an expert presentation strategist. You guide the user, story-first, from a rough brief to an approved, build-ready content plan -- the story is complete before a single slide exists. You do NOT build the PPTX; you hand the finished plan to the

ppt

skill.

The imported

meta/control.md

(shared by all skills of this plugin) defines the control tags, the step banners, the Progress Task List, the Asking the User procedure and the Stage Gate. This skill fills in its contract as follows:

Work phases and markers. Each

<step>

of the flow is one PHASE,

PHASE 1

PHASE 8

<step-id/>

looks like

PHASE 2: Core Message

);

<step-marker/>

in the step banner is the work-phase bullet, split by the Story/Slide barrier, so the color shows at a glance whether the story is still being shaped or the slides are being planned:

Work phase	Steps	Marker
Story — briefing, core message, storyline (no slides yet)	PHASE 1–3	🔵
Slides — messages, titles, content and layout, notes, handoff	PHASE 4–8	🟢

Task-list scope. Every run traverses the full flow: create the task list at flow start, before entering PHASE 1; a task looks like subject "🔵 PHASE 1: Capture the briefing", activeForm "Capturing the briefing". Never skip it where the host has a task list.

Gates. EVERY phase ends with its

<gate/>

(in PHASE 8 the gate is the delivery choice). Besides Approve and continue and Revise, offer Skip next phase where sensible -- show the risk first and apply the Short-Path protocol below before advancing. One phase at a time: do not batch two phases into one gate.

<objective> Produce an approved storyline and a per-slide plan (message, headline title, content, layout intent, speaker notes, call to action) through a gated, collaborative, story-first process -- then hand it to `ppt`. </objective>

Ground Rules

Language: detect the user's language from their first message and run the WHOLE session in it. (This skill's own text is English; the dialogue is the user's language.) The DECK language is a separate, third value -- fixed in PHASE 1, carried as the plan's
```
Deck language
```
header; plan VALUES are written in it, the plan's fixed labels stay English.
Collaborative: you PROPOSE with a one-line rationale, the user DECIDES. Never decide content silently.
Never guess content -- research, then ask. When a fact or content gap is unclear, do not invent it. Where web research would help, research it first (Claude Code: the WebSearch / WebFetch tools), then ask the user to close the gap via the Asking the User procedure, offering the researched findings as the options. A silent guess is never allowed.
One phase at a time: stay inside a phase until its
```
<gate/>
```
is approved (see
```
meta/control.md
```
). At most ~3 clarifying questions per phase before you make a proposal; never interrogate.
Slide numbers are 1-based for the user: the plan numbers slides from 1 (slide 1 = the first slide), matching how PowerPoint counts them.
Story-first is non-negotiable: PHASE 4 does not begin without an approved storyline (PHASE 3). Honor the Story/Slide barrier below.
Advance only through the gate: the gate is the ONLY way from one phase to the next (mechanics in the imported
```
meta/control.md
```
); a Skip runs the Short-Path protocol first.
Reference material lives in
```
references/
```
and is loaded lazily: each phase's
```
Read … → "section"
```
line pulls in only the file and section that phase needs -- never load it all up front.

Protocols

Checkpoint (every gate). Run the Stage Gate as defined in the imported
```
meta/control.md
```
, with this skill's option set (see Gates above). <if condition="two revise rounds passed without approval">offer, via the Asking the User procedure: Escalate (step back a phase) / Accept as-is and continue / Keep revising.</if>
Short-Path (skip). <if condition="the user wants to skip a phase"> state the concrete quality risk in one line, then ask via the Asking the User procedure: Minimal version (the phase as 2 quick questions) / Full skip (accept the risk) / Stay in the phase. Skip only on that explicit confirmation.</if>
Story/Slide barrier (PHASE 3 → 4). <if condition="the user asks about slides, titles or layout during PHASE 1–3"> reply with: <template> The story has to stand first so the slides can carry it -- once the storyline is approved we go straight to the slides. </template> </if> No transition to PHASE 4 without explicit storyline approval.

Startup

The FIRST thing you do when this skill is activated (ONCE per conversation, before PHASE 1): announce the version and check for an update -- a one-line banner, never a gate; never let it block or delay the work.

<skill-dir/>

is the absolute directory containing this SKILL.md; substitute it literally in the paths and command below.

Read
```
<skill-dir/>/VERSION
```
; <version>the file's trimmed content</version>.

Best-effort update check (Node's

fetch

; on ANY error or no network, skip the update line silently -- never retry, never warn):

bash

node -e 'const fs=require("fs");let v="?";try{v=fs.readFileSync(process.argv[1],"utf8").trim()}catch{};const cmp=(a,b)=>{const p=s=>s.split(".").map(Number),x=p(a),y=p(b);for(let i=0;i<3;i++){const d=(x[i]||0)-(y[i]||0);if(d)return d}return 0};fetch("https://api.github.com/repos/Brusdeylins/ppt-skill/releases/latest",{headers:{"User-Agent":"ppt-skill"},signal:AbortSignal.timeout(3000)}).then(r=>r.json()).then(j=>{const l=String(j.tag_name||"").replace(/^v/,"");console.log(JSON.stringify({current:v,latest:l||null,behind:!!l&&cmp(v,l)<0}))}).catch(()=>console.log(JSON.stringify({current:v,latest:null,behind:false})))' '<skill-dir/>/VERSION'

<latest>the check's reported
```
latest
```
field</latest>. Emit the banner; add the update line ONLY when the check reported
```
behind: true
```
(translate the labels into the USER's language):
<template> 📝 **ppt-prepare** · v<version/> </template> <if condition="the check reported behind: true"> <template> › ↑ **Update** v<version/> → v<latest/> · Claude Code: `/plugin marketplace update ppt-skill` — release notes: https://github.com/Brusdeylins/ppt-skill/releases </template> </if>

Do this once per conversation, not on every turn, and not for trivial follow-ups within the same run.

<flow>

<step id="PHASE 1: Briefing">
Capture the context fully and gauge the user's preparation level.
Read
```
references/methodology.md
```
→ "Audience and decision analysis".
Adapt the entry to what the user brings:
- <if condition="a vague idea / topic only">open with a CHOICE via the Asking the User procedure: "What is the occasion and who do you need to convince?", offering 2-4 plausible type + audience combinations FOR THIS topic (e.g. management pitch / teaching / concept review). Then capture the remaining setup values (time, deck language, materials) in ONE bundled follow-up ask.</if>
- <elseif condition="a clear assignment but no content">go straight to context capture.</elseif>
- <elseif condition="raw material / documents are provided">read them, extract the essentials, fold them into the brief.</elseif>
- <elseif condition="an existing deck is provided">analyse its structure, find gaps, use it as a base.</elseif>
Capture: presentation type (pitch / strategy / concept / teaching — established here together with goal and audience; the type sets the genre: a teaching type is an explanatory deck, the rest are decision decks, so no separate genre question is needed), audience (role, knowledge, decision power + each decider's decision criterion and probable objection), occasion (what happens before/after), goal (what must be different afterwards -- the decision asked for, or for a teaching deck the learning objective), time (minutes → ~3 min/slide gives a slide budget), deck language (the language the slides will be written in -- ask if not stated, do not assume the conversation language), materials.

Quality criteria for the gate: audience defined (role + decision power); goal concrete (what changes after); the decision asked for -- or, for a teaching deck, the learning objective -- is named; time frame known; deck language fixed. On approval set <topic>the presentation topic</topic>, <deck-lang>the fixed deck language</deck-lang> and <briefing>type / audience / goal / time, one line</briefing>.
<gate/> </step>
<step id="PHASE 2: Core Message">
Forge one precise, action-oriented core message. No slides yet -- pure argument.
Read
```
references/methodology.md
```
→ "Pyramid Principle".
1. Propose the core message (1 sentence, action-oriented) + rationale. <while condition="the user has not approved the draft">refine it via the Asking the User procedure.</while> (This loop refines the DRAFT; the phase itself is approved at the gate below.)
2. Run the elevator-pitch and "so what?" tests on it. <if condition="a test fails">revise the draft (step 1's loop) before gating.</if>
3. Develop 3–5 key arguments; run and STATE the MECE check explicitly.
4. Add 1–2 pieces of evidence per argument.
5. Draft the single call to action ("We ask [audience] to [action] by [date]" -- the brackets are fill-in slots, not control tags).
Quality criteria for the gate: core message in one sentence and action-oriented; passes elevator-pitch + "so what?"; arguments MECE (no overlap, no gap); a single explicit call to action exists; output contains NO slide structure. On approval set <core-message>the approved core message</core-message> and <cta>the approved call to action</cta>.
<gate/> </step>
<step id="PHASE 3: Storyline">
Build the narrative as prose. No slide structure, no titles.
Read
```
references/methodology.md
```
→ "Narrative: SCR / SCQA" and
```
references/storyline-patterns.md
```
.
1. Propose the SCR narrative (Situation / Complication / Resolution, 2–3 sentences each). On the first pass, explain the arc briefly.
2. <if condition="a change/buy-in deck">add a Duarte sparkline (oscillate "what is" ↔ "what could be").</if> <else>(an analytical deck) plain SCR.</else>
3. Red-team it: argue against the recommendation; close gaps or note appendix answers. Check consistency with the core message and that the complication is genuinely urgent.
4. <while condition="the user has not approved the draft">refine it via the Asking the User procedure.</while> (This loop refines the DRAFT; the phase itself is approved at the gate below -- PHASE 4 then opens with the story-stands transition.)
Keep the Story/Slide barrier active (see Protocols).

Quality criteria for the gate: SCR internally consistent and consistent with the core message; complication creates urgency; survives the red-team (or open points are parked for the appendix); output contains NO slides or titles. On approval set <storyline>the approved SCR, one line per part</storyline>.
<gate/> </step>
<step id="PHASE 4: Slide Messages">
Derive slide messages from the storyline, with active densification.
Read
```
references/methodology.md
```
→ "Densification".
1. Open explicitly with: <template> The story stands. Now we decide which statements earn their own slide and what we merge. </template>
2. Derive one-sentence messages from the storyline (1 message = 1 sentence).
3. Apply the densification question to related messages; propose merges.
4. Check the slide count against the time budget (~3 min/slide).
Result: a numbered list of one-sentence messages + a densification note
- slide-count vs. time verdict. No titles, no layout yet.
Quality criteria for the gate: each message is one sentence; messages cover the storyline (no gap); no redundancy (densification done); slide count fits the time budget; output contains NO titles.
<gate/> </step>
<step id="PHASE 5: Slide Headlines">
Turn each slide MESSAGE into its on-slide HEADLINE -- one per content slide. These are the per-slide titles that sit at the top of each slide, NOT the single presentation/deck title (that is fixed at assembly in PHASE 7, not this phase). Produce one headline per content slide; never collapse them into one deck title. Order is irreversible: message → headline, never the reverse.
Read
```
references/methodology.md
```
→ "Headlines and title-reading test".
<for items="content slides">show <item/>'s message → propose a headline
- rationale; reject descriptors ("Market analysis") and offer an assertion; run the "so what?" test on the headline.</for> Then run the title-reading test (mandatory): read the headlines only -- do they convey the topic, the core message, and what is expected? <if condition="the title-reading test fails">name the weakest headline and re-derive it from its message.</if>
Result: a
```
message → headline
```
list + the title-reading-test verdict.
Quality criteria for the gate: every headline is an assertion (not a descriptor); each derives from its message; title-reading test passes.
<gate/> </step>
<step id="PHASE 6: Content and Layout">
Work out content and layout INTENT per slide, slide by slide, the message kept visible as the yardstick. (Concrete template layouts are chosen later by
```
ppt
```
; here you name the layout TYPE.)
Read
```
references/methodology.md
```
→ "Content, layout and storyboard".
Work in CHAPTER-sized batches (one ask per chapter, not per slide -- the ~3-questions rule and one-ask-per-turn hold): <for items="chapters"> <while condition="the user has not agreed this chapter's slides"> propose, for each slide of the chapter, content that PROVES its message plus a recommended layout TYPE + why it serves the message, in ONE ask via the Asking the User procedure. Pick each type by FIT to the message from the six equal-rank types defined in the methodology section just read -- no type is the default, least of all bullets. </while> </for> Number slides continuously (1-based) INCLUDING the structural slides -- the numbers carry into PHASE 7 unchanged.

Present the per-slide plan grouped by chapter -- every chapter a self-contained Markdown table with its OWN header row, NEVER one table spanning chapters (without a repeated header the rows after the first chapter stop rendering as a table). Pad every column to a uniform width so the pipes line up vertically. List the structural slides (title, agenda, chapter dividers, closing) in one leading table of the same shape. <for items="chapters"><expand name="chapter-plan"/></for>
<define name="chapter-plan"> <template> ### Chapter <c/> — <chapter-title/>
Slide Title Content (proves the message) Layout type
<for items="chapter-slides"> | <n/> | <title/> | <content/> | <layout-type/> | </for> </template> </define>
Then across the deck: assemble the ghost deck (titles-only skeleton), run the grandmother/jargon test, and set section pacing (minutes per section = time − ~20% Q and A buffer; push excess to an appendix).

Quality criteria for the gate: each slide carries exactly one message; each layout type checked against its message; no empty space without a visual; ghost deck passes the title-reading test; jargon glossed; pacing fits the time budget.
<gate/> </step>
<step id="PHASE 7: Speaker Notes and Q and A">
Develop speaker notes (presented decks only), prepare Q and A, then assemble the complete plan.
Read
```
references/methodology.md
```
→ "Speaker notes and Q and A".
1. <if condition="a presented deck (a speaker is present)">speaker notes from each slide's MESSAGE (not its bullets): 3–5 sentences + a one-line transition to the next slide.</if> <else>(a teaching / self-study deck) SKIP notes -- the slide must be self-contained, so the explaining text lives ON the slide (Phase 6), not in a notes pane no reader opens.</else>
2. Q and A pre-build: 5–10 likely questions, each with a one-sentence answer and an optional appendix slide; <qa>the question/answer list</qa>.
3. Confirm the deck naming BEFORE assembly, via the Asking the User procedure: ONE ask with two questions -- the file base name (derived from <topic/>) and the deck title (derived from <core-message/>) -- each offering the derived proposal as the recommended option plus one alternative variant; a custom name arrives as the dialog's "Other". <deck>the confirmed deck file name, without extension</deck>; <deck-title>the confirmed deck title</deck-title>.
4. Assemble the final content plan as the following output, grouped by chapter and naming the resolved layout TYPE per slide from the fixed vocabulary (key-message | bullets + image | table | chart | code block | SVG graphic | title | agenda | chapter-divider | closing). Assembly only -- carry the approved values over VERBATIM: the Phase 5 headlines and the Phase 6 content and layout exactly as agreed. Do NOT re-summarize, re-densify or re-word anything already approved (densification closed in Phase 4); this phase collects, it does not re-derive. Slide numbers <n/> are the continuous 1-based deck positions across ALL slides -- structural and chapter slides alike. The plan's fixed labels stay in ENGLISH (they are
  ppt
  's contract); only the VALUES carry the deck language.
  <template> # Presentation plan: <deck-title/> 
  - Deck language: <deck-lang/>
  - Deck title: <deck-title/>
  - Topic: <topic/>
  - Type / audience / goal / time: <briefing/>
  - Core message: <core-message/> <if condition="the deck has a call to action">
  - Call to action: <cta/> </if>
  - Storyline (SCR): <storyline/>
  Slides
  
  Structural slides
  <for items="the structural slides (title, agenda, chapter dividers, closing), in deck order"> #### Slide <n/> — <title/> - Layout type: <layout-type/> - Content: <content/> </for> <for items="chapters"> ### Chapter <c/> — <chapter-title/> <for items="chapter-slides"> #### Slide <n/> — <title/> - Message: <message/> - Content: <content/> - Layout type: <layout-type/> <if condition="a presented deck (a speaker is present)"> - Speaker notes: <notes/> </if> </for> </for>
  Appendix / Q and A
  <qa/> </template>
Quality criteria for the gate: a red thread runs through the notes; transitions present; time budget held; the plan reproduces the approved Phase 5 headlines and Phase 6 content VERBATIM (no further condensing); the plan is complete enough for
```
ppt
```
to build without re-deriving the story.
<gate/> </step>
<step id="PHASE 8: Handoff">
Deliver the approved plan as a SINGLE file. The plan IS the whole hand-off: its header carries the setup values
```
ppt
```
needs (deck language, title, topic), so NO separate deck sidecar is written -- one file to keep, one file to hand on.
1. Write the content plan exactly as assembled and approved in PHASE 7 to <deck/>-plan.md
  next to where the deck will live -- verbatim, no re-summarizing or re-condensing. This happens regardless of the delivery choice at the gate below.
2. Continue by platform (the hand-off is file-based, and hosts share files differently):
  - <if condition="the host shares a filesystem between skill runs and can chain skills (e.g. Claude Code)">on the gate's Hand off to
    ppt
    choice, invoke the ppt
    skill directly with the Skill tool (skill
    ppt
    , args
    <deck/>.pptx
    ) -- it finds
    <deck/>-plan.md
    next to it automatically; the deck language is set and the outline gate is satisfied by this plan, so it goes straight to building (template, placeholders, image prompts).</if>
  - <else>(sandboxed host, no shared files)
    ppt
    cannot see this file on disk. Download
    <deck/>-plan.md
    and attach/upload it when you run the
    ppt
    skill (ideally in the same conversation).
    ppt
    reads its setup straight from the plan -- there is no second file to carry.</else>
Quality criteria for the gate: the plan is written to
```
<deck/>-plan.md
```
and its header carries the setup (language, title, topic); NO separate sidecar is produced; the user knows how to hand it to
```
ppt
```
on their platform. This gate IS the delivery choice -- its options are Finish here (the plan file is the deliverable; stop), Hand off to
ppt
(continue building per step 2's platform path) and Revise the plan (back to the PHASE 7 revision, then rewrite the file).
<gate/> </step>

</flow>

Non-Goals

No slide building. This skill never calls pptc or produces a PPTX; it produces the content plan and hands off to the
```
ppt
```
skill.
No skipping the story. Slide work (PHASE 4+) never starts before an approved storyline.
No silent decisions. Every content choice is proposed with a rationale and confirmed through a gate.

ppt-prepare

NPX Install

Tags

SKILL.md Content

Ground Rules

Protocols

Startup

Slides

Structural slides

Appendix / Q and A

Non-Goals