ppt-from-anything

name	ppt-from-anything
description	Create a polished presentation deck from arbitrary source material by planning a narrative, generating one 16:9 slide image per slide, and assembling the images into a .pptx file. Use when the user wants a PPT from an article, webpage, document, prompt, repo, notes, or mixed materials and an image-based deck is acceptable.

PPT From Anything

Purpose

Create an image-first presentation deck from arbitrary source material.

This skill now separates deck workflow from deck style:

• SKILL.md contains the reusable workflow, prompt assembly rules, and deck assembly rules.
• references/style-system.md defines how style profiles are used.
• references/styles/minimal-tech.md, references/styles/apple-keynote-like.md, references/styles/cinematic-photo-impact.md, and references/styles/red-patriotic-education.md are reusable style profiles.
• references/create-style-template.md explains how to author a new style profile.

Prerequisites

Before generating any slide image, make sure these environment variables are already set in the active shell:

• OPENAI_API_KEY
• RESPONSES_URL

This skill does not ship credential values or endpoint values. Both bundled image-generation scripts fail fast if either variable is missing. Example commands below assume the current working directory is the skill root.

When to use

Use this skill when the user wants to:

• turn notes, an article, a webpage, a repo, or mixed material into a PPT
• auto-generate a slide deck with a coherent narrative
• produce a visually consistent presentation quickly
• create a deck where image-based slides are acceptable

When not to use

Do not use this skill when:

• the user only wants a textual summary
• the user explicitly needs fully editable native slide elements instead of image-based slides
• the material is too thin and the user really only needs one image, not a deck

Core principles

• Understand the source before designing slides.
• Keep each slide focused on one dominant idea.
• Separate content planning from visual style selection.
• Use one active style profile per deck unless the user explicitly asks for a hybrid.
• Make slide images look like real presentation pages, not generic illustrations.
• Generate slides in 16:9 from the start so PPT assembly stays simple and lossless.

Style-first rule

Before planning the deck, select exactly one style profile.

Selection logic:

• If the user names a style file or a matching visual brief, read that style profile.
• If the user asks for a new style, read references/style-system.md and references/create-style-template.md, then create a new file under references/styles/.
• If the user does not specify a style, choose the closest preset from:
  • references/styles/minimal-tech.md
  • references/styles/apple-keynote-like.md
  • references/styles/cinematic-photo-impact.md
  • references/styles/red-patriotic-education.md

After reading the chosen style file, distill it into a style_contract with at least:

• style_id
• tone
• text_density
• detail_level
• image_priority
• diagram_priority
• layout_system
• role_treatments
• prompt_block
• negative_constraints

Carry the same style_contract through the entire deck.

Supported inputs

This skill can work from:

• a short paragraph or prompt
• a long article
• a webpage
• a document
• a codebase or project folder
• mixed materials from multiple sources

Final output

The normal output is:

1. a .pptx deck assembled from slide images
2. one generated slide image per slide
3. a deck outline or slide spec summary
4. optional speaker notes or prompt log when useful

Important:

• every content slide must originate from a GPT-generated slide image
• the .pptx is a container that preserves slide order and presentation format
• do not substitute native editable slide composition for the intended image-generation workflow

Workflow

1) Select the style profile

Read one style file before outlining the deck.

The chosen style profile must influence:

• text density
• visual language
• image versus diagram emphasis
• title length and wording style
• preferred slide layouts
• how each slide role should look

Do not start generating slide prompts before the style profile is fixed.

2) Normalize the source material

Turn the source into a unified internal representation.

Depending on source type:

• paragraph/article: extract claims, structure, examples, conclusion
• webpage: extract identity, sections, positioning, trust signals, CTA
• codebase: infer problem solved, architecture, modules, flow, usage, strengths
• technical paper/doc: extract background, problem, method, setup, results, takeaways
• mixed sources: merge, deduplicate, and resolve contradictions

If the source is noisy, prioritize presentation-worthy material.

3) Infer presentation intent

Infer:

• target audience
• tone
• use case
• deck type
• language
• depth level

Also align the intent with the chosen style profile. For example:

• a low-text style should bias toward more visual, fewer-word slides
• a diagram-heavy style should bias toward architecture, pipeline, comparison, and system slides
• a photo-led style should bias toward scene-setting, evidence, contrast, and impact slides

4) Plan the deck

Create an outline before generating any images.

For each slide, define:

• slide number
• slide role
• title
• one core message
• supporting points
• recommended visual composition
• approximate text density
• transition relation to the previous slide

Typical roles:

• title page
• agenda / framing
• problem
• context
• architecture / method
• workflow / pipeline
• comparison
• results
• case study
• conclusion
• next steps

5) Build slide specs

For every slide, create a slide_spec with:

• title
• slide_role
• core_message
• bullets
• visual_scene
• layout_type
• text_elements
• speaker_note
• style_profile
• style_prompt_block
• role_treatment
• negative_constraints

Keep one dominant idea per slide.

6) Generate slide images

Generate one 16:9 presentation-style image per slide.

This is a required step for every slide in the deck. Do not skip image generation and replace it with manual native PPT composition.

Each prompt should explicitly specify:

• this is a presentation slide
• 16:9 composition
• the slide role
• the intended layout
• the intended diagram / visual metaphor / photo treatment
• the chosen style profile
• the selected style profile's text policy
• the selected style profile's negative constraints

If all slide prompts are already finalized, this step may be parallelized across slides. Prefer bounded parallelism rather than unbounded fan-out. Inside this repo, use:

• scripts/render_slides_parallel.py

Practical guidance:

• default to --jobs 4
• keep stable slide basenames like slide-01, slide-02, ...
• if rate-limit or transient failures occur, lower concurrency or retry failed slides only

7) Quality check slides

Check each slide image for:

• correct title / labels
• obvious text corruption
• layout clarity
• consistency with the chosen style profile
• message alignment with the outline
• redundancy across slides

If a slide is weak:

• regenerate only that slide
• simplify text
• strengthen layout instructions
• reduce ambiguity
• restate the active style profile more concretely

8) Assemble the PPT

Create a 16:9 PPT deck and place one generated image per slide.

This step should be deterministic. Use the bundled assembly script rather than rebuilding the logic ad hoc each time.

Important:

• each slide in the final .pptx should be a full-slide generated image
• the assembly layer should not introduce a new bespoke visual layout
• if a slide looks wrong, regenerate the source image and rebuild the deck

Prompt assembly

Use the slide content and the chosen style profile together.

Prompt skeleton

Use this skeleton and fill in the fields from the slide spec and style contract:

Create a polished 16:9 presentation slide image.
Deck style profile: "{style_profile}".
Slide role: "{slide_role}".
Slide title: "{title}".
Core message: "{core_message}".
Layout: {layout_type}.
Visual composition: {visual_scene}.
Text policy for this style: {text_density} density, {detail_level} detail.
Role treatment: {role_treatment}.
Include only this slide text: {text_elements}.
Style prompt block: {style_prompt_block}.
Avoid: {negative_constraints}.
High readability, clean hierarchy, presentation-grade spacing, consistent with the rest of the deck.

Practical rules for slide generation

• Generate one slide per call.
• Every slide in the final deck should come from one such image-generation call.
• Save files with stable names like slide-01, slide-02, ...
• Reuse the same style_profile and style_prompt_block across the whole deck.
• Keep slide text conservative even in higher-density styles; generated slide text degrades quickly when overloaded.
• Ask for presentation layout explicitly, not just “an illustration about X”.
• When one slide fails, regenerate that slide only.
• When prompts are finalized, it is acceptable to render multiple slides concurrently within your rate limits.
• Native PPT editing is only for final assembly, not for designing slide contents.

GPT image generation method

Important: use the wrapped Responses API path

For slide rendering:

• do not prefer /v1/images/generations
• use Responses API via /v1/responses
• use the bundled scripts/generate_image_via_responses.mjs
• let gpt-5.4 drive the image tool
• use gpt-image-2 for the image tool model
• keep stream: true
• do not write API keys or endpoint URLs into the skill or repo; pass them via env

For repeatable use inside this skill, prefer the bundled wrapper:

• scripts/render_slide_via_gpt_image.sh

Example:

scripts/render_slide_via_gpt_image.sh \
  /absolute/path/to/slide-images \
  slide-03 \
  "Create a polished 16:9 presentation slide image. Deck style profile: 'minimal-tech'. Slide role: 'architecture'. Slide title: 'System Architecture'. Core message: 'Three-layer pipeline from ingestion to serving'. Layout: left text, right architecture diagram. Visual composition: clean boxes and arrows with restrained labeling. Text policy for this style: medium-low density, balanced detail. Role treatment: technical explainer with one diagram as the hero. Include only this slide text: title, 3 short bullets, and 4 short module labels. Style prompt block: bright restrained technology aesthetic, cool grayscale palette, cyan accent, generous whitespace, precise geometry. Avoid: photo collage, decorative clutter, poster-like overload."

Equivalent raw command shape:

OUTPUT_DIR='/absolute/path/to/slide-images' \
OUTPUT_BASENAME='slide-03' \
node scripts/generate_image_via_responses.mjs \
"Create a polished 16:9 presentation slide image. Deck style profile: 'minimal-tech'. Slide role: 'architecture'. Slide title: 'System Architecture'. Core message: 'Three-layer pipeline from ingestion to serving'. Layout: left text, right architecture diagram. Visual composition: clean boxes and arrows with restrained labeling. Text policy for this style: medium-low density, balanced detail. Role treatment: technical explainer with one diagram as the hero. Include only this slide text: title, 3 short bullets, and 4 short module labels. Style prompt block: bright restrained technology aesthetic, cool grayscale palette, cyan accent, generous whitespace, precise geometry. Avoid: photo collage, decorative clutter, poster-like overload."

How to assemble many slide images into a .pptx

The key simplification

Make every generated slide already be 16:9.

If every slide image is already 16:9, PPT assembly becomes trivial:

• create a widescreen presentation
• add a blank slide for each image
• place the image at (0, 0)
• set image width and height to the full slide size
• preserve the image order

Use the bundled script

Use:

• scripts/build_pptx_from_images.py

Example:

python3 scripts/build_pptx_from_images.py \
  --images-dir /absolute/path/to/slide-images \
  --pattern 'slide-*.png' \
  --output /absolute/path/to/final-deck.pptx

Dependency note:

• the assembly script requires python-pptx
• if import fails, install it in the active environment with pip install python-pptx and rerun

Output contract

Return:

• the generated .pptx
• the slide images folder or named slide image files
• optional outline summary
• optional per-slide notes
• optional prompt log when useful

Success criteria

A successful deck:

• is coherent from start to finish
• reflects the source accurately
• follows one clear style profile consistently
• keeps each slide focused on one idea
• looks like a real presentation, not random art
• is ready for human presentation with minimal further editing