How I Generate Professional PPT Presentations with DeerFlow

Mar 17, 2026

Purpose

I needed to create a professional presentation for a product launch. I tried several AI presentation tools, but the results were disappointing: each slide looked like it came from a different template.

Then I tested DeerFlow’s ppt-generation skill. It uses a different approach: generate slides sequentially, each referencing the previous one for visual consistency.

This post shows how I used the skill and why the reference chain approach produces better results.

The Problem: AI Presentations Look Inconsistent

When I used other AI tools to generate presentations, I got this:

Purple gradient background, sans-serif font, modern look

Blue geometric shapes, serif font, corporate style

Orange minimalist design, different font weight

Each slide was generated independently, so the AI had no memory of what the previous slide looked like. The result looked unprofessional.

What DeerFlow Does Differently

DeerFlow’s ppt-generation skill uses a reference chain:

Slide 1 generated (establishes style)
    |
    v
Slide 2 generated (references Slide 1)
    |
    v
Slide 3 generated (references Slide 2)
    |
    v
Slide 4 generated (references Slide 3)

Each slide prompt includes the previous slide as a reference image. This ensures visual consistency across the entire presentation.

The 8 Available Styles

DeerFlow supports 8 presentation styles. I tested all of them:

Style	Best For	My Experience
glassmorphism	Tech products, AI demos	Modern and eye-catching
dark-premium	Executive presentations	Looks expensive
gradient-modern	Startups, creative agencies	Bold and energetic
neo-brutalist	Edgy brands, Gen-Z targeting	High contrast, distinctive
3d-isometric	Tech explainers, SaaS	Clean and professional
editorial	Annual reports, luxury brands	Magazine-quality
minimal-swiss	Architecture, design firms	Precise and elegant
keynote	Keynotes, product reveals	Apple-inspired

For my product launch, I chose glassmorphism.

Step 1: Create the Presentation Plan

I started by creating a JSON plan that defines the style and slides:

{
  "title": "Introducing Nova AI",
  "style": "glassmorphism",
  "style_guidelines": {
    "color_palette": "Vibrant purple-to-cyan gradient",
    "typography": "SF Pro Display style, bold titles",
    "imagery": "Abstract 3D glass spheres",
    "layout": "Centered frosted glass cards"
  },
  "aspect_ratio": "16:9",
  "slides": [
    {
      "slide_number": 1,
      "type": "title",
      "title": "Introducing Nova AI",
      "subtitle": "Intelligence, Reimagined",
      "visual_description": "Stunning gradient background with frosted glass title card"
    },
    {
      "slide_number": 2,
      "type": "features",
      "title": "Key Features",
      "points": [
        "Natural language understanding",
        "Real-time collaboration",
        "Enterprise security"
      ],
      "visual_description": "Three glass cards floating on gradient background"
    },
    {
      "slide_number": 3,
      "type": "demo",
      "title": "See It In Action",
      "visual_description": "Glass panel showing demo screenshot placeholder"
    },
    {
      "slide_number": 4,
      "type": "closing",
      "title": "Get Started Today",
      "subtitle": "nova.ai/demo",
      "visual_description": "Centered call-to-action with glass button effect"
    }
  ]
}

The style_guidelines field is critical. It tells the image generator exactly what visual language to use.

Step 2: Generate Slide Images Sequentially

This is where DeerFlow differs from other tools. I had to generate slides one at a time, each referencing the previous:

Generate Slide 1 (No Reference)

python /mnt/skills/public/image-generation/scripts/generate.py \
  --prompt-file /mnt/user-data/workspace/slide-01.json \
  --output-file /mnt/user-data/outputs/slide-01.jpg \
  --aspect-ratio 16:9

The prompt for slide 1 included the style guidelines:

{
  "prompt": "Presentation slide for 'Introducing Nova AI' with subtitle 'Intelligence, Reimagined'. Style: glassmorphism with vibrant purple-to-cyan gradient background. Centered frosted glass title card. Abstract 3D glass spheres floating in background. Professional, modern tech presentation.",
  "negative_prompt": "text overlay, watermark, low quality, blurry, distorted",
  "aspect_ratio": "16:9"
}

Generate Slide 2 (References Slide 1)

python /mnt/skills/public/image-generation/scripts/generate.py \
  --prompt-file /mnt/user-data/workspace/slide-02.json \
  --reference-images /mnt/user-data/outputs/slide-01.jpg \
  --output-file /mnt/user-data/outputs/slide-02.jpg \
  --aspect-ratio 16:9

The prompt for slide 2 included a consistency note:

{
  "prompt": "Presentation slide continuing EXACT visual style from reference image. Title 'Key Features' with three bullet points: Natural language understanding, Real-time collaboration, Enterprise security. Three frosted glass cards floating on same gradient background. CRITICAL: Must be visually identical in style to reference image.",
  "reference_image": "/mnt/user-data/outputs/slide-01.jpg",
  "aspect_ratio": "16:9"
}

Generate Slides 3 and 4

I repeated the process for slides 3 and 4, each referencing the previous slide:

# Slide 3 references Slide 2
python /mnt/skills/public/image-generation/scripts/generate.py \
  --prompt-file /mnt/user-data/workspace/slide-03.json \
  --reference-images /mnt/user-data/outputs/slide-02.jpg \
  --output-file /mnt/user-data/outputs/slide-03.jpg \
  --aspect-ratio 16:9

# Slide 4 references Slide 3
python /mnt/skills/public/image-generation/scripts/generate.py \
  --prompt-file /mnt/user-data/workspace/slide-04.json \
  --reference-images /mnt/user-data/outputs/slide-03.jpg \
  --output-file /mnt/user-data/outputs/slide-04.jpg \
  --aspect-ratio 16:9

Step 3: Compose the PPTX File

After generating all slide images, I composed them into a PPTX file:

python /mnt/skills/public/ppt-generation/scripts/generate.py \
  --plan-file /mnt/user-data/workspace/presentation-plan.json \
  --slide-images \
    /mnt/user-data/outputs/slide-01.jpg \
    /mnt/user-data/outputs/slide-02.jpg \
    /mnt/user-data/outputs/slide-03.jpg \
    /mnt/user-data/outputs/slide-04.jpg \
  --output-file /mnt/user-data/outputs/nova-presentation.pptx

The compose script creates a PPTX with each image as a full-slide background. The result: a professional presentation with consistent visuals across all slides.

What I Learned About Visual Consistency

The reference chain approach works because of how image generation models process reference images:

1. Model analyzes reference image (colors, shapes, style)
2. Model encodes visual elements into latent space
3. Model generates new image constrained by reference encoding
4. Result shares visual DNA with reference

Without reference images, each generation starts from random noise. With references, the generation is anchored to a specific visual style.

Trying Different Styles

I also tested the dark-premium style for a different use case:

{
  "style": "dark-premium",
  "style_guidelines": {
    "color_palette": "Deep black #0a0a0a, luminous accents",
    "typography": "Elegant sans-serif, dramatic size contrast",
    "imagery": "Dramatic studio lighting, rim lights",
    "effects": "Subtle ambient glow, vignette"
  }
}

And the keynote style for another project:

{
  "style": "keynote",
  "style_guidelines": {
    "color_palette": "Deep blacks, white text, signature blue accent",
    "typography": "San Francisco Pro, extreme weight contrast",
    "imagery": "Cinematic photography, dramatic lighting",
    "layout": "Maximum negative space, single focal point"
  }
}

Each style produced distinctly different results while maintaining consistency within the presentation.

Complete Automation Example

Here’s a complete script I wrote to automate the process:

import json
import subprocess
from pathlib import Path

def generate_presentation(plan_path: str, output_dir: str):
    """Generate a complete presentation from a plan file."""

    # Load the plan
    with open(plan_path) as f:
        plan = json.load(f)

    slides = plan["slides"]
    slide_images = []

    for i, slide in enumerate(slides, 1):
        # Create prompt file
        prompt = {
            "prompt": build_prompt(slide, plan["style_guidelines"]),
            "aspect_ratio": plan.get("aspect_ratio", "16:9")
        }

        # Add reference for slides after the first
        if i > 1:
            prompt["reference_image"] = slide_images[-1]
            prompt["prompt"] += " CRITICAL: Must be visually identical in style to reference image."

        prompt_path = Path(output_dir) / f"slide-{i:02d}.json"
        output_path = Path(output_dir) / f"slide-{i:02d}.jpg"

        with open(prompt_path, "w") as f:
            json.dump(prompt, f, indent=2)

        # Generate the image
        cmd = [
            "python", "/mnt/skills/public/image-generation/scripts/generate.py",
            "--prompt-file", str(prompt_path),
            "--output-file", str(output_path),
            "--aspect-ratio", plan.get("aspect_ratio", "16:9")
        ]

        if i > 1:
            cmd.extend(["--reference-images", slide_images[-1]])

        subprocess.run(cmd, check=True)
        slide_images.append(str(output_path))

        print(f"Generated slide {i}/{len(slides)}")

    # Compose PPTX
    output_pptx = Path(output_dir) / f"{plan['title'].replace(' ', '-').lower()}.pptx"

    cmd = [
        "python", "/mnt/skills/public/ppt-generation/scripts/generate.py",
        "--plan-file", plan_path,
        "--output-file", str(output_pptx),
        *slide_images
    ]

    subprocess.run(cmd, check=True)
    print(f"Created: {output_pptx}")

    return str(output_pptx)

def build_prompt(slide: dict, style_guidelines: dict) -> str:
    """Build the image generation prompt for a slide."""
    parts = [
        f"Presentation slide for '{slide.get('title', '')}'",
        f"Style: {style_guidelines.get('color_palette', '')}",
        f"Typography: {style_guidelines.get('typography', '')}",
        slide.get('visual_description', '')
    ]
    return ". ".join(filter(None, parts))

if __name__ == "__main__":
    generate_presentation(
        "/mnt/user-data/workspace/nova-plan.json",
        "/mnt/user-data/outputs"
    )

Comparison: Reference Chain vs Independent Generation

I ran a comparison test with 5 slides:

                        Reference Chain    Independent Generation
Color consistency       Consistent         Varied across slides
Typography              Same fonts         Different fonts
Overall feel            Professional       Generic template
Perceived quality       High               Medium

The reference chain took longer (sequential generation) but produced a cohesive presentation. Independent generation was faster but looked like a random collection of slides.

Issues I Encountered

The process wasn’t without problems:

Time: Sequential generation is slow. A 10-slide presentation took 15 minutes.
Reference drift: After 5+ slides, some style drift occurred. I found it helps to occasionally reference an earlier slide instead of just the previous one.
Text rendering: AI-generated text on slides is unreliable. I ended up adding text in PowerPoint after generating the images.
Prompt engineering: The consistency notes in prompts matter. Without explicit “must match reference” language, the model sometimes deviated.

When This Approach Works Best

Based on my testing, the reference chain approach is ideal for:

Product launches: When visual quality matters more than speed
Investor decks: Professional appearance is critical
Conference keynotes: Distinctive style sets you apart
Brand presentations: Consistency with brand guidelines

It’s less suitable for:

Quick internal updates: Too slow for routine presentations
Data-heavy decks: AI-generated visuals don’t handle charts well
Frequent revisions: Each change requires regenerating images

My Recommendation

If you need professional presentations and have 15-30 minutes to spare, DeerFlow’s approach is worth it. The visual consistency is something I couldn’t achieve with other AI tools.

Best practices I learned:

Spend time on style_guidelines—this determines everything
Use explicit consistency notes in every prompt after slide 1
Keep text out of generated images—add it in PowerPoint
Choose your style before starting—switching mid-process wastes work

Summary

DeerFlow’s ppt-generation skill creates professional presentations by generating slides sequentially with reference images. This ensures visual consistency across the entire deck—a problem that plagued other AI presentation tools I tried.

The skill supports 8 styles (glassmorphism, dark-premium, gradient-modern, neo-brutalist, 3d-isometric, editorial, minimal-swiss, keynote) and outputs PPTX files. The main trade-off is time: sequential generation is slower than parallel generation, but the quality difference is significant.

For presentations where visual quality matters, the reference chain approach is the best solution I’ve found.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!