PPTX Slide Generator

This prevents token limit errors and catches quality issues early.

CRITICAL: Always clean up part files after combining. The user should only see ONE final PPTX file, not multiple part files.

⚠️ PREREQUISITE: Brand Check

Before generating slides, check if any brands exist.

Glob: .claude/skills/pptx-generator/brands/*/brand.json

If NO brands found (only template/ exists):

1. STOP - Do not proceed with slide generation

2. Ask the user:

   "No brands are configured yet. Would you like me to help you create a brand first? I'll need your brand colors, fonts, and style guidelines to set this up."

3. If user wants to create a brand, follow the Creating a New Brand section below.

4. If user declines, explain that slides require a brand configuration and offer to use generic styling as a fallback.

Creating a New Brand

When no brands exist or user requests a new brand:

Step 1: Read the Template

Read: .claude/skills/pptx-generator/brands/template/README.md
Read: .claude/skills/pptx-generator/brands/template/brand.json
Read: .claude/skills/pptx-generator/brands/template/config.json

Step 2: Gather Brand Information

Ask the user for (or extract from provided materials):

Step 3: Create Brand Files

1. Create the brand folder:

   mkdir -p .claude/skills/pptx-generator/brands/{brand-name}
   

2. Create brand.json with the gathered values:

   {
     "name": "Brand Name",
     "description": "One-line description",
     "colors": {
       "background": "hex-without-hash",
       "background_alt": "hex-without-hash",
       "text": "hex-without-hash",
       "text_secondary": "hex-without-hash",
       "accent": "hex-without-hash",
       "accent_secondary": "hex-without-hash",
       "accent_tertiary": "hex-without-hash",
       "code_bg": "hex-without-hash",
       "card_bg": "hex-without-hash",
       "card_bg_alt": "hex-without-hash"
     },
     "fonts": {
       "heading": "Font Name",
       "body": "Font Name",
       "code": "Monospace Font"
     },
     "assets": {
       "logo": "assets/logo.png",
       "logo_dark": null,
       "icon": null
     }
   }
   

3. Create config.json with output settings:

   {
     "output": {
       "directory": "output/{brand}",
       "naming": "{name}-{date}",
       "keep_parts": false
     },
     "generation": {
       "slides_per_batch": 5,
       "auto_combine": true,
       "open_after_generate": false
     },
     "defaults": {
       "slide_width_inches": 13.333,
       "slide_height_inches": 7.5
     }
   }
   

4. Create brand-system.md - Copy from template and fill in brand guidelines

5. Create tone-of-voice.md - Copy from template and fill in voice guidelines

6. Add assets - Copy logo/images to brands/{brand-name}/assets/

Step 4: Verify

After creating the brand, verify with:

Glob: .claude/skills/pptx-generator/brands/{brand-name}/*

Then proceed to slide generation.

Skill Modes

This skill operates in four modes:

Mode 1: Generate Presentation Slides

User wants presentation slides (16:9) created using a brand's styling. → Follow: Brand Discovery → Layout Selection → Content Adaptation → Execute → Layouts in: cookbook/*.py

Mode 2: Generate LinkedIn Carousels

User wants a LinkedIn carousel (square 1:1 format) for social media. → Follow: Brand Discovery → Carousel Planning → Generate → Export PDF → Layouts in: cookbook/carousels/*.py

Mode 3: Manage Cookbook Layouts

User wants to create, edit, or improve layout templates. → Follow: Layout CRUD Operations section

Mode 4: Generate RAN Feature Presentations

User wants Ericsson LTE/NR RAN feature documentation slides. → Follow: Feature Discovery → Load Ericsson Brand → Select Mode → Generate → Layouts in: cookbook/ran/*.py → Data from: elex-ran-features skill (features.json)

Mode 1: Generate Presentation Slides

Step 1: Brand Discovery

1. List available brands:

   Glob: .claude/skills/pptx-generator/brands/*/brand.json
   

   Extract unique brand names from paths (e.g., brands/rasmus/... → "rasmus")

2. Read the brand configuration files:

   Read: .claude/skills/pptx-generator/brands/{brand-name}/brand.json
   Read: .claude/skills/pptx-generator/brands/{brand-name}/config.json
   

   • brand.json - Colors, fonts, assets
   • config.json - Output directory, generation settings

3. Read supporting markdown files for context:

   Glob: .claude/skills/pptx-generator/brands/{brand-name}/*.md
   

   These provide voice, tone, and design philosophy.

4. Extract from brand files:

   • From brand.json: Colors (hex without #), fonts, asset paths
   • From config.json: Output directory, slides per batch, naming convention
   • From markdown: Voice, tone, vocabulary, visual principles

If brand not found, list available brands and ask user to choose.

Step 2: Layout Discovery (READ ALL FRONTMATTERS)

⚠️ MANDATORY: Read ALL layout frontmatters before selecting any layout.

This step is critical for making informed layout decisions. You must understand what ALL layouts offer before choosing.

Step 2a: Discover all layouts:

Glob: .claude/skills/pptx-generator/cookbook/*.py

Step 2b: Read EVERY layout file (not just one or two):

For each .py file found, read the first 40 lines to extract the # /// layout frontmatter block. Build a mental map of:

• What each layout is for (purpose, best_for)
• What each layout should NOT be used for (avoid_when)
• Limits and constraints (max_*, min_*, *_max_chars)

The frontmatter block looks like this:

# /// layout
# name = "floating-cards-slide"
# purpose = "Feature highlights, process steps, multiple equal items with depth"
# best_for = [
#     "Exactly 3 related features or concepts",
#     "Process with 3 steps",
# ]
# avoid_when = [
#     "More than 3 items - use multi-card-slide instead",
#     "Long card titles (over 15 characters)",
# ]
# max_cards = 3
# card_title_max_chars = 15
# instructions = [
#     "EXACTLY 3 cards required - no more, no less",
#     "Card titles must be SHORT: 1-2 words, max 15 characters",
# ]
# ///

Key frontmatter fields:

Step 2c: Select layouts (only AFTER reading all frontmatters):

Now that you know all available layouts and their constraints:

1. User specifies layout → Use that layout (but verify it fits the content)
2. User describes content → Match to best-fitting best_for criteria
3. Check avoid_when → Don't use a layout in situations it warns against
4. Respect limits → If content exceeds max_*, use a different layout
5. Multiple slides needed → Select appropriate layout for each
6. No good fit → Create a custom layout (see Mode 2)

Example selection process:

• User wants "5 pillars of AI infrastructure"
• You've read all frontmatters and know:
  • floating-cards-slide: max_cards = 3 → Won't work
  • multi-card-slide: max_cards = 5 → Perfect fit
• Select multi-card-slide

Why read ALL frontmatters?

• Layouts reference each other in avoid_when (e.g., "use multi-card-slide instead")
• You can't make the right choice without knowing all options
• Prevents backtracking when a layout doesn't fit

Step 2d: Visual-First Layout Selection (CRITICAL FOR VARIETY)

🎨 DEFAULT TO VISUAL LAYOUTS. Content-slide is the LAST RESORT, not the default.

The Variety Problem

The biggest mistake in presentation generation is defaulting to content-slide (title + bullets) whenever you have information to convey. This creates repetitive, boring presentations.

Common failure pattern:

• 11 out of 30 slides = content-slide (37% repetition)
• User says "this lacks variety"
• You think "but I used 11 different layout types!"
• Reality: Layout variety exists, but distribution is terrible

Variety Enforcement Rules

HARD LIMITS:

1. Never use the same layout more than 2-3 times consecutively
2. Content-slide should be <25% of total slides (not 35-40%)
3. Visual layouts (cards, stats, columns, hero, diagonal) should be 50%+ of slides
4. Section breaks are NOT variety - they're structural (don't count toward variety)

Decision Tree: "Should I Use content-slide?"

Ask these questions IN ORDER before defaulting to content-slide:

Do I have 3-5 equal items?
  YES → Use multi-card-slide (not content-slide)

Do I have 2-4 big numbers/metrics?
  YES → Use stats-slide (not content-slide)

Am I comparing two things?
  YES → Use two-column-slide (not content-slide)

Do I have a central concept with surrounding items?
  YES → Use circular-hero-slide (not content-slide)

Do I have exactly 3 related items?
  YES → Use floating-cards-slide (not content-slide)

Do I have 1-3 words I want to emphasize dramatically?
  YES → Use giant-focus-slide or bold-diagonal-slide (not content-slide)

Do I have a powerful quote or principle?
  YES → Use quote-slide (not content-slide)

Is this the ONLY way to present this information?
  YES → NOW you can use content-slide
  NO → Go back through the decision tree

Transforming Bullets Into Visual Layouts

Example 1: "Validation Patterns"

❌ BAD (content-slide):

Title: Validation Patterns
Bullets:
- Run comprehensive test suites
- Type checking and linting
- Code review by humans and AI
- Deployment previews

✅ GOOD (multi-card-slide):

Title: Validation Patterns
Cards:
1. Testing | Run comprehensive test suites after every change
2. Linting | Type checking and formatting as guardrails
3. Review | Human and AI code review process
4. Preview | Deployment previews for visual regression

Example 2: "Why PIV Works"

❌ BAD (content-slide):

Title: Why PIV Works
Bullets:
- Forces planning before implementation
- Validation catches issues immediately
- Iterative improvements compound
- System gets smarter with every bug

✅ GOOD (floating-cards-slide with 3 cards):

Title: Why PIV Works
Cards:
1. Plan First | Forces architectural thinking before coding
2. Fast Feedback | Validation catches issues immediately
3. Compounds | System improves with every bug

(Note: Reduced from 4 to 3 items to fit floating-cards-slide max_cards limit)

Example 3: "Human-in-the-Loop Strategy"

❌ BAD (content-slide):

Title: Human-in-the-Loop Strategy
Bullets:
- In-the-loop: Human approves before execution
- On-the-loop: Human reviews after completion
- Code review remains critical
- AI generates, humans validate

✅ GOOD (two-column-slide):

Title: Human-in-the-Loop Strategy
Left: In-the-Loop
- Human approves before execution
- Critical for production changes
- Quality gateway

Right: On-the-Loop
- Human reviews after completion
- Faster iteration cycles
- AI generates, human validates

Active Visual Thinking

Before planning any slide, ask yourself:

1. "Can this be more visual?" - The answer is almost always YES
2. "Have I used content-slide in the last 2 slides?" - If yes, use something else
3. "Does this slide look like the previous slide?" - If yes, change the layout
4. "Am I falling into a pattern?" - Break it immediately
5. "Would this be more engaging as cards/columns/stats?" - Usually yes

When content-slide IS Appropriate

Use content-slide ONLY when:

• You've genuinely tried all other layouts and they don't fit
• The information is inherently linear and textual (rare)
• You need a "breather" slide between two complex visuals
• You're at your layout distribution limits (already used all the visual ones recently)

Never use content-slide as your default thinking.

Quick Reference: Content Type → Best Layout

Only use content-slide when:

• None of the above fit
• Information is truly linear
• Need a text-heavy breather between visual slides
• Already hit variety limits

Step 3: Slide Planning (ALWAYS DO THIS)

Before generating ANY slides, create a written plan.

This applies to single slides, batches, and full presentations. Planning prevents:

• Duplicate content across slides
• Wrong layout choices
• Missing key information
• Poor flow and structure

Create a slide plan table:

| # | Layout | Title | Key Content | Notes |
|---|--------|-------|-------------|-------|
| 1 | title-slide | [Title] | [Subtitle, author] | Opening slide |
| 2 | content-slide | [Title] | [3-4 bullet points] | Main concepts |
| 3 | stats-slide | [Title] | [2-3 metrics] | Impact data |
| ... | ... | ... | ... | ... |

For each slide, specify:

• Slide number - Position in presentation
• Layout - Which cookbook layout to use
• Title - Exact title text (check for duplicates!)
• Key content - Bullet points, stats, quotes, etc.
• Notes - Any special considerations

Planning checklist:

• No duplicate titles across slides
• Logical flow from slide to slide
• Appropriate layout for each content type
• Content fits the chosen layout
• Batches are logically grouped (5 slides max each)
• VARIETY CHECK: Content-slide used <25% of total slides
• VARIETY CHECK: No more than 2-3 consecutive slides with same layout
• VARIETY CHECK: Visual layouts (cards, stats, columns, hero) are 50%+ of slides
• VARIETY CHECK: Each content-slide was evaluated against decision tree first

After planning, briefly present the plan before generating.

Example of good variety distribution for 30-slide presentation:

• Content-slide: 6-7 slides (20-23%)
• Section breaks: 5 slides (17%)
• Visual layouts: 15-16 slides (50-53%)
  • Multi-card: 3-4 slides
  • Two-column: 2-3 slides
  • Stats: 1-2 slides
  • Floating-cards: 2-3 slides
  • Circular-hero: 1-2 slides
  • Giant-focus/Bold-diagonal: 2-3 slides
  • Quote: 1 slide
• Title/Closing: 2-3 slides (7-10%)

Step 4: Content Adaptation

For each slide in your plan:

Presentation Text Formatting Rules

IMPORTANT: Follow these rules for ALL slide text.

Avoid:

• Trailing periods on titles, bullets, labels
• Ellipsis (...) in headlines
• Excessive commas in short phrases
• Colons at end of labels/headers
• Semicolons in bullet points

Exception: Full sentence descriptions or quotes may use appropriate punctuation.

Brand Value Mapping

1. Map brand.json values to layout placeholders:

   Layout Placeholder	brand.json Path
   BRAND_BG	colors.background
   BRAND_BG_ALT	colors.background_alt
   BRAND_TEXT	colors.text
   BRAND_TEXT_SECONDARY	colors.text_secondary
   BRAND_ACCENT	colors.accent
   BRAND_ACCENT_SECONDARY	colors.accent_secondary
   BRAND_ACCENT_TERTIARY	colors.accent_tertiary
   BRAND_CODE_BG	colors.code_bg
   BRAND_CARD_BG	colors.card_bg
   BRAND_CARD_BG_ALT	colors.card_bg_alt
   BRAND_HEADING_FONT	fonts.heading
   BRAND_BODY_FONT	fonts.body
   BRAND_CODE_FONT	fonts.code

   Note: All color values in brand.json are hex WITHOUT the # prefix.

2. Write content in brand's voice (from tone-of-voice.md)

3. Preserve layout structure (decorative elements, spacing, hierarchy)

Step 5: Batch Generation (CRITICAL)

MAXIMUM 5 SLIDES PER BATCH. This is a hard limit.

When generating multiple slides:

1. Generate 1-5 slides in a single PPTX file
2. STOP and review the output before generating more
3. Only after validation passes, continue with the next batch
4. Repeat until all slides are generated

Why batching matters:

• Prevents token limit errors
• Allows quality checks between batches
• Catches issues early before they propagate

⚠️ CRITICAL BACKGROUND BUG FIX:

EVERY slide MUST have its background explicitly set. If you don't set slide.background.fill.solid() and slide.background.fill.fore_color.rgb, the slide will use PowerPoint's default WHITE background, making text unreadable on dark-themed brands.

Mandatory for every slide:

slide = prs.slides.add_slide(prs.slide_layouts[6])
slide.background.fill.solid()  # ← REQUIRED
slide.background.fill.fore_color.rgb = hex_to_rgb(BRAND_BG)  # ← REQUIRED

This is especially critical when:

• Generating multiple batches (each batch is a new Presentation object)
• Using helper functions to create slides
• Combining separate PPTX files

Execution:

PREFERRED: Use heredoc (no files created):

uv run --with python-pptx==1.0.2 python << 'EOF'
# [Adapted code with brand values and content]
EOF

IF heredoc fails (Windows issues): Use temp directory:

# Create temp directory if needed
mkdir -p .claude/skills/pptx-generator/.tmp

# Write script to temp directory
# (create file at .claude/skills/pptx-generator/.tmp/gen.py)

# Execute
uv run --with python-pptx==1.0.2 python .claude/skills/pptx-generator/.tmp/gen.py

# MANDATORY: Clean up immediately after execution
rm .claude/skills/pptx-generator/.tmp/gen.py

CRITICAL: Never create Python files in the repository root. Always use heredoc or temp directory within the skill folder.

Step 6: Quality Validation (MANDATORY)

After EVERY batch, validate before continuing:

1. Open the generated PPTX and visually inspect it
2. Check for these common issues:

3. If issues found:

   • Fix the current batch before continuing
   • Note the issue to avoid repeating in future batches

4. If validation passes:

   • Continue to next batch of slides

Step 7: Output

Use the output settings from config.json:

Resolve placeholders:

• {brand} → Brand folder name
• {name} → Presentation name from user request
• {date} → Current date (YYYY-MM-DD)

# Create output directory from config
mkdir -p {resolved-output-directory}

Batched generation workflow:

1. Generate each batch as {name}-part1.pptx, {name}-part2.pptx, etc.
2. Validate each batch before continuing
3. After ALL batches complete, combine into final file (if auto_combine is true)
4. Delete part files (if keep_parts is false)

Step 8: Combine Batches (for multi-batch presentations)

🚨 CRITICAL BUG WARNING: BACKGROUND MUST BE SET WHEN COMBINING 🚨

When combining presentations, add_slide() creates slides with DEFAULT WHITE BACKGROUNDS. Shape copying does NOT copy the slide background property. You MUST explicitly set the background immediately after creating each new slide.

This is the most common source of white slides in combined presentations.

After all batches are validated, combine them into a single PPTX:

uv run --with python-pptx==1.0.2 python << 'SCRIPT'
from pptx import Presentation
from pptx.dml.color import RGBColor
from pathlib import Path
import shutil

def hex_to_rgb(hex_color: str) -> RGBColor:
    h = hex_color.lstrip("#")
    return RGBColor(int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16))

# Brand background color (get from brand.json)
BRAND_BG = "REPLACE_WITH_BRAND_BACKGROUND"  # e.g., "07090F"

# List all part files in order
output_dir = Path("output/{brand-name}")
part_files = sorted(output_dir.glob("{name}-part*.pptx"))

if len(part_files) > 1:
    # Start with first part as base
    combined = Presentation(part_files[0])

    # Add slides from remaining parts
    for part_file in part_files[1:]:
        part_prs = Presentation(part_file)
        for slide in part_prs.slides:
            # Copy slide layout and add to combined
            blank_layout = combined.slide_layouts[6]
            new_slide = combined.slides.add_slide(blank_layout)

            # 🚨 CRITICAL: Set background IMMEDIATELY after creating slide
            # PowerPoint defaults to WHITE background - this MUST be set before copying shapes
            new_slide.background.fill.solid()
            new_slide.background.fill.fore_color.rgb = hex_to_rgb(BRAND_BG)

            # Copy all shapes from source slide
            for shape in slide.shapes:
                # Clone shape to new slide
                el = shape.element
                new_slide.shapes._spTree.insert_element_before(
                    el, 'p:extLst'
                )

    # Save combined file
    combined.save(output_dir / "{name}-final.pptx")
    print(f"Combined {len(part_files)} parts into {name}-final.pptx")

    # MANDATORY: Clean up part files - user should only see final file
    for part_file in part_files:
        part_file.unlink()
        print(f"Deleted {part_file.name}")