G-resentation

What does G-resentation do?

Turn "make a PPT" into a complete production pipeline from questioning to delivery. The name comes from "grill me in presentation": first, it grills you until you can't say anything vague, then it gets to work.

This skill only orchestrates: clarifies requirements, defines structure, selects the route, assigns the work to the appropriate production skill, and finally validates. It does not create the slides itself.

First time usage: run python3 "<SKILL_DIR>/scripts/doctor.py" — it will tell you what's missing and what command to run next. The complete onboarding path is in QUICKSTART.md.

Boundaries

• Use when: The content hasn't been finalized and you need to create a presentation from scratch.
• Do NOT use when: You already have a page-by-page outline and just need it formatted, or you only need beautification, single-page changes, or format conversion — directly invoke the production skill.
• Trigger priority: This skill first selects the route, then calls the production skill. The production skill may also claim it can "generate presentations" — prevent it from skipping step 0.

Project Structure

Each job is a folder decks/<slug>/. File names are fixed; every subsequent step refers to files by name only:

decks/<slug>/
├── brief.md      Requirement specification (output of step 0)
├── outline.md    Page-by-page content (P01, P02…)
├── assets/
│   ├── sources/  Raw materials for fact-checking
│   └── media/    Images, logos, screenshots that go on slides
├── out/          Final deliverables
└── versions/     Snapshots

For trivial tasks, assets/ and versions/ can be omitted.

Scripts

The three scripts perform only deterministic actions; they don't replace judgment. They use only the standard library and can run on any Python 3.10+ installation without extra packages.

Replace <SKILL_DIR> with the absolute path to this skill's directory before execution. The commands below work on macOS / Linux / Git Bash; for PowerShell, replace "$S/xxx.py" with "$S\xxx.py".

S="<SKILL_DIR>/scripts"

python3 "$S/new_deck.py" q4-review --title "Q4 Review"      # Create project folder and two empty templates
python3 "$S/new_deck.py" weekly-sync --small              # Small task template
python3 "$S/check_outline.py" decks/q4-review             # Check sequential page numbers, six fields, and compare against baseline
python3 "$S/snapshot.py" decks/q4-review outline          # Snapshot, automatically increments v01, v02…

On Windows, python3 may be a placeholder from the Microsoft Store. First run python3 -V to verify; if it fails, try python or py -3. All scripts accept any working interpreter.

If check_outline.py exits with a non-zero code, fix the issues before proceeding. After freezing, run it again — it will list page number differences against versions/v01-outline/, serving as a safety net for "edit P07 by reference only."

External Dependencies (Optional, Install as Needed)

This skill is only the orchestration layer; it does not bundle any production tools. The four dependencies below are needed depending on the chosen route. If they are missing, the skill degrades gracefully:

Dependency	Route Used By	What to Do If Missing
frontend-slides	HTML presentations	Write a single-file HTML yourself, or switch to one of the other two routes
guizang-ppt-skill	Alternative style for HTML presentations	Use frontend-slides instead
ppt-master	Editable PPTX	Fall back to HTML or images; note on the output "PPTX not generated"
imagegen	Export full pages as images	Export HTML screenshots as PNG instead

Installation is always npx skills add <owner/repo>; see the respective repositories for details. When a dependency is missing, honestly inform the user which route is affected and what the impact is — do not pretend you can produce output.

ppt-master has a set of non-standard library dependencies (python-pptx, PyYAML, skia-pathops, uharfbuzz, etc.). Do not hardcode the interpreter path; first probe:

PY=$(command -v python3 || command -v python)
"$PY" -c "import pptx, yaml, pathops, uharfbuzz" 2>/dev/null \
  || echo "Missing dependencies: ask the user to run pip install -r <PPT_MASTER_DIR>/requirements.txt in that Python environment"

After the probe passes, run its integrity check: "$PY" "<PPT_MASTER_DIR>/scripts/attribution_guard.py". If it returns non-zero, stop — do not fix or bypass it.

Materials and Facts

When discussing "current" content, do not rely on memory. If the aihot skill is installed, use it to fetch the latest information. It reads public APIs only and does not require an API key:

curl -sL "https://aihot.virxact.com/api/v1/items?mode=selected&window=7d&q=<keyword>&limit=10"
curl -sL "https://aihot.virxact.com/api/v1/hot-topics"

• mode=selected is a curated pool; if the query with q returns empty, retry with mode=all and note "Not in curation pool."
• Save the raw response into assets/sources/ for later fact-checking; do not include it in deliverables.
• In footers, only cite the third-party original source (publisher, report name, date). Do not paraphrase summaries from news aggregators or link to them.
• It is allowed for personal and non-commercial use. For customer-facing commercial deliveries, paid services, or bulk redistribution, obtain authorization according to its terms — do not assume it is free.
• If this skill is not installed or data fetching fails, fall back to public search or ask the user to provide materials, and state the data cutoff date.

Workflow

1. Determine Scope

The single criterion: Can this job be fixed if it goes wrong?

• External clients, formal reviews, archivable or distributable materials, cross-department deliveries → Major task.
• Internal weekly meetings, small familiar audience, easily redoable → Minor task.

After determination, state it in one sentence: "I'll handle this as a major task" or "Minor task — just fill out the form." The user may override the classification. Then proceed.

2. Gather Requirements (Gate)

• Minor task: Give the user assets/brief-template.md to fill out. For missing fields, ask targeted questions — do not guess.
• Major task: Ask one question at a time: first content, then the four-dimensional audience analysis, finally format. See references/step0.md for phrasing and scripts.

Regardless of scope, after gathering, repeat back in three sentences: "Who is this for, what do you want them to do, and what should they remember?" Only after user confirmation write brief.md.

3. Page-by-Page Outline (Gate)

Write outline.md using the seven-field template from references/step0.md. Assign a unique number to each page starting from P01. Write the title on the same line as the page number; the remaining six fields go below. Use P1 Page-by-Page Outline from references/prompts.md, replacing all ［ ］ placeholders with actual content from brief.md. After writing, run check_outline.py — if page numbers are non‑sequential or fields are missing, the outline is not complete.

On confirmation, freeze: immediately run snapshot.py <deck> outline to save the baseline. The page count and numbering must not change after this. Any addition or deletion requires user approval. Any renumbering must be reported as "Original P07 → Current P05." All subsequent "edit page X" instructions refer only to these frozen numbers.

4. Select Route + Three Sample Slides (Gate)

Make an educated guess before asking the user: based on the brief, infer a route, explain the reasoning, and let the user reject it. Do not directly ask "Which one do you want?" Criteria and invocation details are in references/paths.md.

The three sample slides must be the hardest pages: the cover, the most information-dense page, and the page with the most complex chart or flow. Produce genuine artifacts (a viewable HTML, a visible PNG, or an openable PPTX) — not screenshots. Only after direction confirmation proceed to full production. The route-specific prompts (P3 / P4 / P6) already include the sample requirements; no additional description needed.

5. Production

Call the appropriate skill for the selected route and invoke the corresponding prompt:

Route	Prompt Used	Skill
Web presentation	P3	frontend-slides or guizang-ppt-skill
Images	P4, optionally P5	imagegen; P5 goes to ppt-master
Editable PPTX	P6	ppt-master

If reference images or high visual requirements exist, add P2 Style Breakdown before the prompt; otherwise skip it and let the production skill use its defaults.

Replace all ［ ］ in prompts with actual content from brief.md. Do not send any prompt with unfilled placeholders.

Produce in batches of ten pages. After each batch, report "P11–P20 ready" without interrupting the flow. Only stop and ask when a specific page cannot be produced.

Before using ppt-master, verify the interpreter can import its required packages. If not, ask the user to install the requirements.txt in that environment — do not hardcode paths to virtual environments:

PY=$(command -v python3 || command -v python)
"$PY" -c "import pptx, yaml, pathops, uharfbuzz" || echo "Missing dependencies — see the External Dependencies section above"

6. Validation + Snapshot

Review against the four categories in references/checklist.md. For web versions, open them in the built-in browser and test navigation, zoom, and offline behavior. For any failed item, use P7 Single-Page Edit with the page number and screenshot. Make only one change per iteration. For multiple pages with the same issue, describe the scope and then re-check the entire deliverable.

Before delivery, run snapshot.py <deck> final to archive a copy.

7. Delivery Instructions

State in one sentence: which file to open, what runtime it requires, and any known limitations.

Hard Rules

• At each checkpoint, ask only specific questions (e.g., "Is the direction of these three pages correct? What is wrong?"). Do not ask "What do you think?"
• Do not fabricate facts, figures, or case studies. If materials conflict or are missing, stop and ask — do not guess.
• If a requirement cannot be met, clearly state the limitation and an alternative. Do not silently degrade.
• If the same issue persists for two rounds without improvement, investigate the root cause before regenerating further.
• The full workflow only pauses twice: at the sample slide review and the final check. Do not ask for page-by-page confirmation in between.