Baoyu Slide Deck

Baoyu Slide Deck is a community skill for generating presentation slide decks from structured content, covering slide layout generation, theme application, content-to-slide mapping, speaker notes creation, and export to presentation formats for automated deck production.

What Is This?

Overview

Baoyu Slide Deck provides patterns for transforming text content into formatted presentation decks. It covers slide layout generation that selects appropriate layouts like title, content, two-column, and image slides based on content type, theme application that applies consistent color schemes, fonts, and backgrounds across all slides, content-to-slide mapping that distributes paragraphs, bullet points, and data into individual slides, speaker notes creation that generates presenter notes from supplementary context, and export that renders the final deck to PPTX or HTML formats. The skill enables automated presentation generation from structured input.

Who Should Use This

This skill serves teams generating presentations from reports, meeting notes, or planning documents, educators building lecture slides from course outlines, and developers integrating slide generation into content management systems.

Why Use It?

Problems It Solves

Building presentations manually from written content is repetitive and time-consuming. Maintaining consistent visual styling across slides requires design attention. Adapting the same content for different audiences needs separate deck versions. Extracting key points from long documents for slide content requires careful summarization.

Core Highlights

Layout selector matches content types to appropriate slide templates. Theme engine applies brand colors, fonts, and backgrounds uniformly. Content mapper splits text into slide-sized segments with proper hierarchy. Export renderer produces PPTX files compatible with PowerPoint and Google Slides.

How to Use It?

Basic Usage

from pptx import Presentation
from pptx.util import Inches,\
  Pt
from pptx.dml.color\
  import RGBColor

class DeckBuilder:
  def __init__(
    self,
    width: float = 13.33,
    height: float = 7.5,
    accent: str = '#2563eb'
  ):
    self.prs = Presentation()
    self.prs.slide_width =\
      Inches(width)
    self.prs.slide_height =\
      Inches(height)
    r, g, b = (
      int(accent[i:i+2], 16)
      for i in (1, 3, 5))
    self.accent = RGBColor(
      r, g, b)

  def add_title_slide(
    self,
    title: str,
    subtitle: str = ''
  ):
    layout = self.prs\
      .slide_layouts[0]
    slide = self.prs.slides\
      .add_slide(layout)
    slide.shapes.title\
      .text = title
    if subtitle:
      slide.placeholders[1]\
        .text = subtitle

  def add_content_slide(
    self,
    title: str,
    bullets: list[str],
    notes: str = ''
  ):
    layout = self.prs\
      .slide_layouts[1]
    slide = self.prs.slides\
      .add_slide(layout)
    slide.shapes.title\
      .text = title
    body = slide\
      .placeholders[1]\
      .text_frame
    for i, bullet\
        in enumerate(
          bullets):
      if i == 0:
        body.text = bullet
      else:
        body.add_paragraph()\
          .text = bullet
    if notes:
      slide.notes_slide\
        .notes_text_frame\
        .text = notes

  def save(
    self, path: str
  ):
    self.prs.save(path)

Real-World Examples

import re

def content_to_deck(
  markdown: str,
  output: str,
  accent: str = '#2563eb'
) -> int:
  builder = DeckBuilder(
    accent=accent)
  sections = re.split(
    r'\n## ', markdown)

  # First section is title
  title_match = re.match(
    r'# (.+)', sections[0])
  title = title_match\
    .group(1)\
    if title_match\
    else 'Untitled'
  builder.add_title_slide(
    title)

  for section\
      in sections[1:]:
    lines = section\
      .strip().split('\n')
    heading = lines[0]
    bullets = [
      l.lstrip('- ')
      for l in lines[1:]
      if l.strip()]
    builder\
      .add_content_slide(
        heading,
        bullets[:6])

  builder.save(output)
  return len(
    builder.prs.slides)

Advanced Tips

Limit each slide to six bullet points or fewer to maintain readability and audience focus. Generate speaker notes from the full paragraph content that was condensed into bullets for the slides. Use slide master layouts to apply brand templates that persist across programmatic updates.

When to Use It?

Use Cases

Generate a quarterly report presentation from performance data and narrative sections. Convert a project proposal document into a pitch deck with consistent formatting. Build an automated pipeline that creates weekly status presentations from structured project updates.

Related Topics

Presentation generation, slide design, python-pptx, content automation, and document conversion.

Important Notes

Requirements

python-pptx library for PPTX generation and manipulation. Slide master template files for branded output. Structured input content with headings and bullet points.

Usage Recommendations

Do: use slide master templates for consistent branding across generated decks. Limit bullet points per slide to maintain audience readability. Include speaker notes for context that does not fit on the slide.

Don't: pack more than six bullets on a single slide which reduces readability. Use small font sizes to fit extra content on slides. Embed large images without compression which increases file size.

Limitations

Programmatic slide layouts lack the visual refinement of manually designed presentations. Complex layouts with overlapping elements are difficult to generate reliably. Animations and transitions require direct PPTX XML manipulation beyond the python-pptx API.