Skip to content
Back to search

slide-image-to-editable-pptx

Convert PPT slide screenshots / style-reference images into a high-fidelity editable PPTX. The output visually matches the source image, but text and simple shapes are PPT-native (editable), while complex visuals are clean generated PNG assets (replaceable). Use when the user provides slide images and wants an editable PowerPoint that looks the same as the source.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/w1163222589-coder-slide-image-to-editable-pptx/badge.svg)](/listings/w1163222589-coder-slide-image-to-editable-pptx)

HTML

<a href="/listings/w1163222589-coder-slide-image-to-editable-pptx"><img src="/api/listings/w1163222589-coder-slide-image-to-editable-pptx/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Installation

Copy the skill folder into your Codex skills directory:

# Clone or download
git clone https://github.com/YOUR_USERNAME/slide-image-to-editable-pptx.git

# Copy to Codex skills directory
cp -r slide-image-to-editable-pptx ~/.codex/skills/

Or install via CC Switch: Skills panel → Add from GitHub → paste the repo URL.

Usage

**Recommended: 3-prompt workflow** (best quality, each phase gets full context window)

**Prompt 1** — Analysis:

Please use the $slide-image-to-editable-pptx skill to convert the slide images 
in this folder into an editable PPTX. Visual fidelity must match the source images. 
All text must be editable. Complex visuals use $imagegen to generate clean PNGs. 
Strictly follow Phase 1 first — complete the analysis including Step 1.4 
completeness self-check (ensure no small icons, in-card illustrations, or 
decorative details are missed). Output the full element inventory for my review 
before proceeding to Phase 2.

**Prompt 2** — Asset Generation:

Proceed to Phase 2. Output the asset report for my review. 
Do not proceed to Phase 3 until I confirm.

**Prompt 3** — PPT Assembly:

Proceed to Phase 3. Use @presentations to build the PPTX. 
The PNG assets in assets/ are ready. Follow the element inventory in _analysis.md 
to reconstruct each slide — match the source images' exact positions, sizes, 
and element density. Build slides 1-5 first, render screenshots for my review, 
then continue with 6-10, 11-15, etc.

File Structure

your-project/
├── source_slides/           # Your input slide images
│   ├── slide_01.png
│   ├── slide_02.png
│   └── ...
├── assets/                  # Generated PNG visual assets (Phase 2 output)
├── output/                  # Final PPTX (Phase 3 output)
├── _analysis.md             # Element inventory (Phase 1 output)
├── _phase2_assets.md        # Asset generation report (Phase 2 output)
└── validation_report.md     # Quality report (Phase 4 output)

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 240 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ---
  2. name: slide-image-to-editable-pptx
  3. description: >
  4. Convert PPT slide screenshots / style-reference images into a high-fidelity
  5. editable PPTX. The output visually matches the source image, but text and
  6. simple shapes are PPT-native (editable), while complex visuals are clean
  7. generated PNG assets (replaceable). Use when the user provides slide images
  8. and wants an editable PowerPoint that looks the same as the source.
  9. ---
  10. # Slide Image → Editable PPTX
  11. You are converting slide screenshots into editable PowerPoint files.
  12. The goal is **visual fidelity** — the output PPT, when rendered, should look
  13. nearly identical to the source image — while making text and geometric shapes
  14. editable.
  15. ## Core Principle: Three-Layer Decomposition
  16. Every pixel in the source image belongs to exactly one of three layers:
  17. | Layer | What it contains | How to implement | Editable? |
  18. |-------|-----------------|------------------|-----------|
  19. | **A — Visual Asset** | Complex illustrations, decorative backgrounds, photos, scientific figures, icons with intricate detail, maps, radar scenes, waveforms, heatmaps, campus sketches, device drawings, textured decorations | Clean PNG generated with `$imagegen` (no text!) or original figure preserved as image | Replaceable (move/resize/delete), not internally editable |
  20. | **B — Structure** | Solid color rectangles, rounded rectangles, circles, lines, arrows, dividers, panel frames, card backgrounds, badges, gradient bars, simple geometric decorations | PPT-native shapes via `$slides` / `presentation-skill` (PptxGenJS) | Fully editable |
  21. | **C — Content** | All readable text: titles, subtitles, body text, labels, captions, page numbers, footer text, formula text, table text, card headings, legend labels | PPT-native text boxes via `$slides` / `presentation-skill` (PptxGenJS) | Fully editable |
  22. **The key insight**: Never bake text into a generated image. Never use crude PPT shapes to approximate a complex visual. Never use a full-slide screenshot as background.
  23. ## Workflow
  24. ### Phase 1: Pixel-Level Analysis
  25. For EACH source image, produce a structured analysis. Do not skip any slide. Do not infer from one slide what another contains — inspect each one.
  26. #### Step 1.1: Observe and catalog
  27. Look at the image carefully. Identify every distinct visual element. For each element, determine:
  28. ```
  29. {
  30. "element_id": "s01_e01",
  31. "description": "distributed radar network illustration with 6 antennas around a central target on a coordinate grid",
  32. "bbox_percent": {"x": 45, "y": 10, "w": 55, "h": 80},
  33. "layer": "A",
  34. "implementation": "image2-generate",
  35. "z_order": 1,
  36. "notes": "Must NOT include any text labels. The title, axis labels, and page number are separate text elements."
  37. }
  38. ```
  39. The `bbox_percent` uses percentages of slide width/height (0-100) to specify position. This avoids pixel-count errors across different image resolutions.
  40. #### Step 1.2: Classify elements strictly
  41. Apply these rules in order:
  42. 1. **Is it readable text?** → Layer C (text box). This includes ALL text: titles, labels inside diagrams, axis labels, page numbers, footer text, card headings, bullet points, formula text. Even if text overlaps a complex visual, the text itself goes to Layer C.
  43. 2. **Is it a simple geometric shape?** (solid rectangle, rounded rectangle, circle, line, arrow, triangle, chevron, trapezoid — with solid fill or simple border) → Layer B (PPT shape). This includes panel backgrounds, card frames, title bars, dividers, badges, progress bars, simple decorative strips.
  44. 3. **Is it visually complex?** (illustration, photo, texture, gradient background with imagery, scientific figure, diagram with intricate line work, icon with detail beyond basic geometry) → Layer A (generated PNG or preserved figure).
  45. #### Step 1.3: Identify shared vs. unique elements
  46. - **Shared across slides**: header bar style, footer style, logo, page number format, background color
  47. - **Unique per slide**: main content visuals, specific diagrams, data figures
  48. Create a `slide_master_elements` list for shared elements, and per-slide element lists for unique content.
  49. #### Step 1.4: Completeness self-check (required)
  50. After finishing the element list for ALL slides, go back and re-examine each source image ONE MORE TIME with fresh eyes. This second pass focuses specifically on **small or easy-to-miss visual elements** that the first pass may have overlooked.
  51. For each slide, ask yourself these questions:
  52. 1. **Small icons**: Are there any small icons (university seals, bullet-point icons, award badges, folder icons, chip icons, person icons, book icons, etc.) that I classified as Layer B (PPT shape) but are actually too detailed for simple shapes? If the icon has more than 3-4 visual features (gradients, shadows, internal detail, curves), reclassify it as Layer A.
  53. 2. **Decorative details**: Are there small decorative elements I skipped entirely? Look in corners, edges, between cards, along dividers, and in footer/header areas. Things like: small wave patterns, dot grids, circuit-trace textures, line-art campus buildings, faint background motifs.
  54. 3. **In-card visuals**: For each card/panel on the slide, does it contain a small illustration or diagram inside it? These are frequently missed because the analyst focuses on the card frame (Layer B) and card text (Layer C) but forgets the small visual inside the card.
  55. 4. **Chart/figure decorations**: Around charts or data figures, are there small visual elements like target icons, antenna icons, signal-path illustrations, or comparison diagrams that I might have grouped with the chart but are actually separate Layer A elements?
  56. 5. **Count check**: Count the total Layer A elements per slide. A visually rich slide typically has 3-8 distinct visual assets. If a complex-looking slide has only 1-2 Layer A elements, something is likely missing — re-examine it.
  57. If this second pass finds any missed elements, add them to the element list with a note: `"found_in": "completeness_check"`. Do NOT remove or modify any existing elements — only add.
  58. ### Phase 2: Visual Asset Generation
  59. For each Layer A element, generate a clean PNG using `$imagegen`.
  60. #### `$imagegen` Prompt Rules
  61. 1. **Be specific about content**: Don't say "a radar scene." Say "A bird's-eye view of a distributed radar network: 6 satellite dish antennas arranged in a hexagonal pattern around a central target (marked with a star), connected by dashed lines, on a dark blue coordinate grid background with axis markings from -200 to 200 km. The style is technical/scientific, with a dark blue (#0A1628) background and light blue/cyan (#31D7FF) elements. No text, no labels, no numbers, no letters."
  62. 2. **Always end with "No text"**: Every prompt must include "No text, no labels, no numbers, no letters anywhere in the image."
  63. 3. **Specify exact style**: Reference the color palette, line style, and visual mood from the source image. Example: "Dark technical blueprint style with navy background (#061426), cyan (#31D7FF) glowing lines, subtle grid pattern."
  64. 4. **Specify aspect ratio**: Match the aspect ratio of the target bounding box. "Aspect ratio approximately 16:9" or "Aspect ratio approximately 1:1".
  65. 5. **Specify transparency when needed**: "Transparent background (PNG with alpha channel)" for overlay elements. "Solid dark background" for background scenes.
  66. 6. **One element per image**: Don't combine unrelated visual elements. Generate separate images for separate visual regions.
  67. #### Asset Naming Convention
  68. ```
  69. s{slide_number}_{semantic_role}.png
  70. ```
  71. Examples:
  72. - `s01_radar_network_scene.png` — cover slide's main radar illustration
  73. - `s01_bottom_wave_decoration.png` — cover slide's bottom decorative wave
  74. - `s03_system_diagram_center.png` — slide 3's central system model illustration
  75. - `s05_rmse_chart_figure.png` — slide 5's RMSE result plot (if preserved as figure)
  76. ### Phase 3: PPT Construction
  77. Use the **`$slides` system skill** or the **`presentation-skill`** (both based on PptxGenJS) to build the deck. If a presentation skill is installed, prefer it. Do NOT write raw python-pptx code — use whichever PptxGenJS-based skill is available, which provides bundled helpers, rendering, and validation.
  78. Follow this exact layer stacking order for every slide (add elements in this sequence so z-order is correct):
  79. ```
  80. Z-order (bottom to top):
  81. 1. Slide background color (set via slide.background)
  82. 2. Full-width structural bars (header band, footer band)
  83. 3. Large visual assets (background scenes, decorative motifs)
  84. 4. Panel/card frame shapes (rounded rectangles, boxes)
  85. 5. Smaller visual assets (icons, figures inside panels)
  86. 6. Lines, arrows, connectors
  87. 7. Native charts and tables
  88. 8. All text boxes (titles, labels, body text, captions)
  89. 9. Brand elements (logo on top)
  90. ```
  91. #### Coordinate Conversion
  92. Source images are typically at a known pixel resolution (e.g., 1920×1080 or 1672×941). Convert to PowerPoint inches using:
  93. ```javascript
  94. const SLIDE_W = 13.333; // inches (16:9)
  95. const SLIDE_H = 7.5;
  96. function pxToInches(px_x, px_y, img_w, img_h) {
  97. return { x: px_x / img_w * SLIDE_W, y: px_y / img_h * SLIDE_H };
  98. }
  99. ```
  100. Measure element positions from the source image precisely. Don't guess.
  101. #### Font Handling
  102. - Use "Microsoft YaHei" for Chinese text
  103. - Use "Cambria Math" for mathematical formulas
  104. - Match font size, weight (bold), and color from the source image
  105. - Default to these approximations if unsure:
  106. - Main title: 28-32pt bold
  107. - Section title: 20-24pt bold
  108. - Card heading: 14-16pt bold
  109. - Body text: 10-12pt regular
  110. - Caption/label: 8-10pt regular
  111. - Page number: 10-12pt
  112. #### Color Extraction
  113. Extract exact colors from the source image. Provide hex values. Build a color palette object at the top of the script:
  114. ```javascript
  115. const COLORS = {
  116. bg_dark: "0A1628",
  117. accent_cyan: "31D7FF",
  118. accent_gold: "C59A4A",
  119. text_white: "F2FBFF",
  120. text_muted: "A9C6D8",
  121. // ... etc
  122. };
  123. ```
  124. #### Rendering and Validation
  125. After building each slide (or the full deck), use the `$slides` built-in render and validation scripts to:
  126. - Render each slide to PNG for visual comparison
  127. - Check for text overflow
  128. - Check for element overlap issues
  129. - Check for font substitution problems
  130. Build one slide at a time. Render and visually compare against the source image before proceeding to the next slide. Fix any significant layout differences before moving on.
  131. ### Phase 4: Validation
  132. After building the PPTX:
  133. 1. **Structural check**: Count objects per slide. Each slide should have:
  134. - Multiple text frames (not zero)
  135. - Multiple shapes (not just one big picture)
  136. - No picture covering >85% of slide area (that would be a full-slide screenshot)
  137. 2. **Visual comparison**: If possible, render the PPTX to images and compare with source. Flag any slide where:
  138. - Major elements are missing
  139. - Layout is significantly different
  140. - Text is baked into images instead of text boxes
  141. 3. **Editability check**: Verify that opening the PPTX and clicking on text allows editing.
  142. ## Non-Negotiable Rules
  143. 1. **NEVER** use a full-slide screenshot as the background
  144. 2. **NEVER** bake readable text into generated images
  145. 3. **NEVER** use a single generic visual motif across many slides when the source slides have distinct visuals
  146. 4. **NEVER** merge unrelated elements (text + visual + shapes) into one image
  147. 5. **NEVER** skip the analysis phase — inspect every source image before writing any code
  148. 6. **NEVER** use crude PPT shapes to approximate complex illustrations when `$imagegen` can generate a proper visual
  149. 7. **ALWAYS** generate each visual asset without any text
  150. 8. **ALWAYS** match the source image's color palette, not a generic theme
  151. 9. **ALWAYS** place text as PPT-native text boxes, even if it overlaps a visual asset
  152. 10. **ALWAYS** process slides one at a time — each slide gets its own analysis, assets, and build function
  153. ## Common Failure Modes to Avoid
  154. ### Failure: "New template" instead of "reconstruction"
  155. **Symptom**: The output looks like a professional PPT on the same topic, but doesn't match the source image's specific layout.
  156. **Cause**: Skipping detailed analysis, using generic layouts.
  157. **Fix**: Measure exact positions from the source image. Match the source's specific element arrangement.
  158. ### Failure: "Generic motif spam"
  159. **Symptom**: The same background image appears on every slide.
  160. **Cause**: Generating one or few generic background images and reusing them.
  161. **Fix**: Each slide's visual assets should be unique and match that specific slide's source image content.
  162. ### Failure: "Over-native crude shapes"
  163. **Symptom**: Complex illustrations (radar dishes, waveforms, network diagrams) rendered as ugly PPT shape approximations.
  164. **Cause**: Trying to rebuild everything with native shapes when IMAGE2 would produce a much better result.
  165. **Fix**: Use `$imagegen` for any visual element that PPT shapes can't faithfully reproduce.
  166. ### Failure: "Baked text"
  167. **Symptom**: Text visible in the PPTX but not editable — it's part of an image.
  168. **Cause**: Generated images include text that should be editable.
  169. **Fix**: `$imagegen` prompts must always specify "no t
README.md · README · 238 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. # Slide Image → Editable PPTX
  3. ### High-Fidelity Conversion of Slide Screenshots into Editable PowerPoint
  4. [![Skill](https://img.shields.io/badge/type-Codex%20Skill-blue.svg)](https://developers.openai.com/codex/skills)
  5. [![Platform](https://img.shields.io/badge/platform-Codex%20%7C%20Claude%20Code-lightgrey.svg)](#compatibility)
  6. [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
  7. [![PptxGenJS](https://img.shields.io/badge/built%20with-PptxGenJS-orange.svg)](https://github.com/gitbrent/PptxGenJS)
  8. **Turn slide screenshots into pixel-accurate, fully editable PowerPoint files.**
  9. Text stays editable. Complex visuals become clean AI-generated PNGs. Simple shapes become native PPT objects.
  10. English | [中文](README_ZH.md)
  11. </div>
  12. ---
  13. ## The Problem
  14. You have a set of PPT slide images (screenshots, exported PNGs, or AI-generated mockups) and you want them back as an **editable** `.pptx` file — not a deck of full-slide screenshots pasted as backgrounds.
  15. Existing approaches fail in predictable ways:
  16. | Approach | Result |
  17. |----------|--------|
  18. | Paste screenshots as backgrounds | Zero editability |
  19. | Ask AI to "recreate" the PPT | Gets the topic right but layout wrong — a new template, not a reconstruction |
  20. | Manual recreation | Hours of tedious work per slide |
  21. ## The Solution
  22. This skill teaches Codex (or any compatible AI coding agent) to **decompose each slide image into three layers**, then rebuild them as a real PowerPoint file:
  23. | Layer | Contains | Implementation | Editable? |
  24. |-------|----------|----------------|-----------|
  25. | **A — Visual Assets** | Complex illustrations, photos, scientific figures, icons, decorative backgrounds | AI-generated PNG (`$imagegen`) — no text baked in | Replaceable |
  26. | **B — Structure** | Rectangles, cards, panels, lines, arrows, dividers, badges | Native PPT shapes | Fully editable |
  27. | **C — Content** | All readable text: titles, labels, body text, page numbers, captions | Native PPT text boxes | Fully editable |
  28. ## How It Works
  29. The skill runs in three phases, each in its own context window for maximum quality:
  30. ```
  31. ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
  32. │ Phase 1 │ │ Phase 2 │ │ Phase 3 │
  33. │ │ │ │ │ │
  34. │ Pixel-Level │────▶│ Visual Asset │────▶│ PPT Assembly │
  35. │ Analysis │ │ Generation │ │ & Validation │
  36. │ │ │ │ │ │
  37. │ • Inspect each │ │ • Generate PNG │ │ • Build PPTX │
  38. │ slide image │ │ for each │ │ with native │
  39. │ • Classify │ │ Layer A │ │ shapes & text │
  40. │ every element │ │ element │ │ • Render & │
  41. │ • Map positions │ │ • No text in │ │ compare with │
  42. │ & layers │ │ any image │ │ source │
  43. │ • Self-check │ │ • Verify each │ │ • 5 slides per │
  44. │ for missed │ │ asset │ │ batch │
  45. │ elements │ │ │ │ │
  46. └──────────────────┘ └──────────────────┘ └──────────────────┘
  47. ```
  48. ### Classification Logic
  49. This classification step is the heart of the reconstruction process: each visible element is assigned to visual assets, native PPT structure, or editable text before the deck is rebuilt.
  50. <p align="center">
  51. <img src="assets/screenshots/10.jpg?v=20260607-1302" alt="Classification logic preview" width="680">
  52. </p>
  53. ### Phase 1: Pixel-Level Analysis
  54. The agent inspects each source image and catalogs every visible element with its type, position (bounding box), layer classification, and implementation method. A **completeness self-check** (Step 1.4) ensures small icons, in-card illustrations, and decorative details are not missed.
  55. **Output**: `_analysis.md` — a structured element inventory for all slides.
  56. ### Phase 2: Visual Asset Generation
  57. For each Layer A element, the agent generates a clean PNG using `$imagegen` with precise prompts that specify content, style, colors, aspect ratio, and transparency — and always end with **"No text, no labels, no numbers."**
  58. **Output**: `assets/` folder with all generated PNGs + `_phase2_assets.md` report.
  59. The image below shows Phase 2 in practice: the agent turns identified Layer A elements into clean visual assets before the final PowerPoint assembly.
  60. ![Phase 2 visual asset workflow](assets/screenshots/8和9合在一起.jpg)
  61. ### Phase 3: PPT Assembly
  62. The agent builds the PPTX using `@presentations` (PptxGenJS), stacking elements in correct z-order: background → visual assets → structural shapes → text boxes → brand elements. Slides are built in batches of 5 with rendering and self-validation after each batch.
  63. **Output**: Final `.pptx` file + rendered previews + `validation_report.md`.
  64. ## Quick Start
  65. ### Installation
  66. Copy the skill folder into your Codex skills directory:
  67. ```bash
  68. # Clone or download
  69. git clone https://github.com/YOUR_USERNAME/slide-image-to-editable-pptx.git
  70. # Copy to Codex skills directory
  71. cp -r slide-image-to-editable-pptx ~/.codex/skills/
  72. ```
  73. Or install via CC Switch: Skills panel → Add from GitHub → paste the repo URL.
  74. ### Usage
  75. **Recommended: 3-prompt workflow** (best quality, each phase gets full context window)
  76. **Prompt 1** — Analysis:
  77. ```
  78. Please use the $slide-image-to-editable-pptx skill to convert the slide images
  79. in this folder into an editable PPTX. Visual fidelity must match the source images.
  80. All text must be editable. Complex visuals use $imagegen to generate clean PNGs.
  81. Strictly follow Phase 1 first — complete the analysis including Step 1.4
  82. completeness self-check (ensure no small icons, in-card illustrations, or
  83. decorative details are missed). Output the full element inventory for my review
  84. before proceeding to Phase 2.
  85. ```
  86. **Prompt 2** — Asset Generation:
  87. ```
  88. Proceed to Phase 2. Output the asset report for my review.
  89. Do not proceed to Phase 3 until I confirm.
  90. ```
  91. **Prompt 3** — PPT Assembly:
  92. ```
  93. Proceed to Phase 3. Use @presentations to build the PPTX.
  94. The PNG assets in assets/ are ready. Follow the element inventory in _analysis.md
  95. to reconstruct each slide — match the source images' exact positions, sizes,
  96. and element density. Build slides 1-5 first, render screenshots for my review,
  97. then continue with 6-10, 11-15, etc.
  98. ```
  99. ### File Structure
  100. ```
  101. your-project/
  102. ├── source_slides/ # Your input slide images
  103. │ ├── slide_01.png
  104. │ ├── slide_02.png
  105. │ └── ...
  106. ├── assets/ # Generated PNG visual assets (Phase 2 output)
  107. ├── output/ # Final PPTX (Phase 3 output)
  108. ├── _analysis.md # Element inventory (Phase 1 output)
  109. ├── _phase2_assets.md # Asset generation report (Phase 2 output)
  110. └── validation_report.md # Quality report (Phase 4 output)
  111. ```
  112. ## Key Design Decisions
  113. ### Why Three Separate Phases?
  114. AI coding agents have limited context windows (~200K tokens). Running all phases in one shot means each phase gets only a fraction of the available context. Splitting into three phases ensures:
  115. - **Phase 1** uses full context for thorough analysis
  116. - **Phase 2** uses full context for high-quality image generation
  117. - **Phase 3** uses full context for precise PPT code
  118. ### Why Not Just Use Full-Slide Screenshots?
  119. Full-slide screenshots give you zero editability. The whole point is to make text editable and shapes adjustable while preserving the visual appearance.
  120. ### Why Generate Images Instead of Cropping from Source?
  121. Cropping from slide screenshots produces low-resolution, dirty-edged fragments. AI-generated images are clean, high-resolution, and properly transparent — resulting in a much more professional output.
  122. ### Why Not Rebuild Everything with Native PPT Shapes?
  123. Some visual elements (radar scenes, scientific illustrations, campus sketches, decorative textures) are too complex for PPT shapes. Forcing them into shapes produces ugly, crude approximations. AI-generated PNGs preserve visual fidelity.
  124. ## Common Failure Modes & How the Skill Prevents Them
  125. | Failure Mode | Symptom | Prevention |
  126. |-------------|---------|------------|
  127. | **New template** | Output looks like a different PPT on the same topic | Phase 1 forces pixel-level position measurement |
  128. | **Generic motif spam** | Same background image on every slide | Each slide gets unique assets matched to its source |
  129. | **Over-native crude shapes** | Complex visuals rendered as ugly PPT approximations | Classification rules route complex visuals to `$imagegen` |
  130. | **Baked text** | Text visible but not editable (inside images) | All `$imagegen` prompts end with "No text" |
  131. | **Missed elements** | Small icons or details missing from output | Step 1.4 completeness self-check catches omissions |
  132. ## Compatibility
  133. | Platform | Status | Notes |
  134. |----------|--------|-------|
  135. | OpenAI Codex | Fully supported | Primary target. Uses `$imagegen` + `@presentations` |
  136. | Claude Code | Compatible | Use with appropriate image generation and PPTX skills |
  137. | Other AI agents | Adaptable | Any agent with image generation + PptxGenJS access |
  138. ## Examples
  139. These screenshots show the kind of slide-image reconstruction workflow this skill is designed for: source slides are analyzed visually, rebuilt as editable PowerPoint objects, and checked against rendered previews.
  140. ### Reconstruction Gallery
  141. #### Example 1
  142. ![Slide reconstruction preview 1](assets/screenshots/第一张.jpg)
  143. #### Example 2
  144. | Image Version | Editable Version |
  145. | :---: | :---: |
  146. | ![Slide image version](assets/screenshots/第3张.jpg) | ![Slide editable version](assets/screenshots/第2张.jpg) |
  147. #### Example 3
  148. | Image Version | Editable Version |
  149. | :---: | :---: |
  150. | ![Slide image version](assets/screenshots/第4张.jpg) | ![Slide editable version](assets/screenshots/第5张.jpg) |
  151. ## Star History
  152. [![Star History Chart](https://api.star-history.com/svg?repos=w1163222589-coder/slide-image-to-editable-pptx&type=Date)](https://star-history.com/#w1163222589-coder/slide-image-to-editable-pptx&Date)
  153. ## Contributing
  154. Issues, suggestions, and PRs are welcome!
  155. If you've used this skill to convert slides and want to share before/after examples, please open a PR — real-world examples help other users understand what to expect.
  156. ## License
  157. MIT
  158. ## Acknowledgments
  159. - [PptxGenJS](https://github.com/gitbrent/PptxGenJS) — The JavaScript library that makes programmatic PPTX creation possible
  160. - [OpenAI Codex](https://openai.com/codex/) — The AI coding agent platform
  161. - [CC Switch](https://github.com/farion1231/cc-switch) — Inspiration for project documentation structure

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.