Deck Builder

Turn any document into a branded slide deck. The skill reads source material, selects a deck structure, writes slide-by-slide content with speaker notes, and either generates a .pptx file (Claude Code) or produces structured markdown mapped to your template layouts (Cowork).

When to use this skill

Turning a blog post, white paper, brief, or case study into a presentation
Creating a pitch deck, conference talk, or internal review deck from scratch or from notes
When someone says "make me a deck about X" or "turn this into slides"
When someone needs a presentation that follows the team's branded Google Slides template

When NOT to use this skill

Creating HTML reports or dashboards (use ghost-paper)
Writing long-form content like blog posts or articles (use brand-voice-writer)
Reviewing existing slide content for brand consistency (use content-reviewer)

Step 0: No Fly List check

If Tiger Den is available, fetch the No Fly List before generating any content:

get_marketing_reference(slug: "no-fly-list")

If Tiger Den is not available, warn the user: "No Fly List check skipped — Tiger Den is not connected. Verify manually that no restricted customers are referenced in the deck before sharing." Then proceed.

If Tiger Den is available, load the returned names as a hard constraint: never include any No Fly List customer in any slide content — not as named examples, proof points, customer quotes, or case study references. If the source document references a No Fly List customer, omit those references from all outputs.

Instructions

1. Load context

Read the local reference files in this skill's references/ directory:

Slide Writing Guide — presentation-specific writing rules, density limits, layout decision tree
Deck Structures — skeleton structures for common deck types

Template layout map: Read Template Layout Map for the team's slide template layouts and placeholder details. If this file contains only the example/placeholder content (not real template data), the template has not been set up yet. Jump to the Template setup section at the end of this skill before proceeding.

2. Read the source document

Read the full input document. If the user pasted content, read it in full. If they provided a URL or file path, fetch and read it.

Analyze the source and identify:

Document type: blog post, white paper, brief, case study, meeting notes, raw ideas
Core argument/thesis: the single main point
Key supporting points: 3-7 major ideas that support the thesis
Data points and metrics: numbers, benchmarks, comparisons
Quotes: customer quotes, expert opinions, notable statements
Logical sections: natural content groupings

Summarize the source in 2-3 sentences and present it to the user for confirmation before proceeding. This prevents building a deck from a misread document.

3. Choose a deck structure and build the deck plan

3a. Audit content types. Before choosing a structure or assigning layouts, classify every distinct piece of information from the source into content types:

Metric — a number worth highlighting (revenue, speed, percentage)
Comparison — A vs B, before/after, us vs them
List — capabilities, features, steps in a process
Quote — customer quote, testimonial, notable statement
Process/Timeline — sequential phases, roadmap stages
Visual — architecture diagram, screenshot, workflow
Narrative — context-setting, argument, analysis

Present the audit as a short inventory. This inventory drives layout selection in 3c — each content type maps to a different layout via the decision tree. If most items land in "List," challenge yourself: can any be reframed as metrics, comparisons, or timelines? A bullet that says "10-20x faster ingest" is a metric, not a list item. A set of 4-6 short features is a grid, not a bullet list.

3b. Choose a structure. Based on the document type and the user's stated purpose, select a structure from the Deck Structures reference.

If the user specifies a purpose ("this is for a conference talk"), use that
If they do not, infer from the document type and ask for confirmation
If no existing structure fits, propose a custom one

3c. Build the deck plan. For each slide in the chosen structure, assign a layout and generation strategy. Use the content audit from 3a and the layout decision tree in the slide writing guide to match content type to layout, then look up the strategy and clone source in the Quick Reference table in the template layout map.

Layout diversity rule: No single layout may be used for more than 30% of the deck's slides (rounded up). No more than 2 consecutive slides may use the same layout. If the plan violates either rule, reassign layouts using the content audit — a "list" slide with a standout metric should become a big number slide; a list of 4-6 items should become a grid; a before/after comparison should become a two-column or comparison slide.

Present the deck plan as a table for user approval:

#	Title	Layout	Strategy	Clone source	Notes summary
1	[Headline title]	Layout 1 (dark title)	Placeholder	—	Opening remarks...
2	[Headline title]	Layout 9 (bullets)	Clone	idx 22	Problem context...
3	[Headline title]	Layout 7 (grid)	Clone	idx 5	Feature overview...

Content overflow: If a slide's source content exceeds the density limits in the slide writing guide (e.g., 8 bullets when the max is 5, or 7 grid items when the max is 6), split across multiple slides. Note split slides as "4a" and "4b" in the plan. Split at natural thematic breaks, not arbitrarily.

Grid categories (Layout 7): The feature grid's column headers are category labels, not individual item names. Group items into exactly 2 categories. Choose categories by the strongest shared attribute among subsets: functional area (writing vs. analysis), workflow stage (create vs. review), or user benefit (speed vs. quality). State the proposed grouping in the deck plan so the user can adjust.

Before presenting the deck plan, verify it passes the layout diversity rule. If it doesn't, fix it first.

Wait for user approval of the deck plan before proceeding to step 4.

4. Write the slides

For each slide in the approved structure:

Use the layout from the deck plan — already assigned in step 3b
Write the title — concise, headline-style, under the character limit for that layout
Write the body content — follow the density rules from the slide writing guide. Respect the placeholder constraints from the template layout map (max characters, max bullets)
Write speaker notes — the full argument and supporting detail goes here. Speaker notes hold everything the slide doesn't. Include data sources, context, and transition cues
Apply voice rules — follow the voice rules in the slide writing guide: WABL aggressively, no em dashes, active voice, one message per slide, no AI filler

Speaker notes are mandatory on every slide, including title slides and section dividers. Notes should be 50-150 words per the slide writing guide. For title/closing slides, write the opening or closing remarks. For content slides, write the full argument behind the headline with data sources and transition cues. Never leave notes blank. If the source material does not provide enough detail, synthesize appropriate talking points from the document's thesis and supporting arguments.

Image handling: Cloned slides carry over all images from the source template slide (logos, screenshots, product icons). In the .pptx output, leave these as template defaults. After generation, report which slides contain template images that may need replacement. In Cowork markdown output, note images as [IMAGE: description of what goes here].

5. Self-check

Before generating output, review all slides against:

6. Generate output

Detect the runtime and generate the appropriate output.

Claude Code: Generate .pptx

Write a single Python generation script that does all of the following. Copy the helper functions from the "Programmatic Generation Strategy" section in the template layout map and define them inline at the top of the script. Do not import them from an external file.

Install python-pptx if not already available:

pip install python-pptx 2>/dev/null || pip3 install python-pptx 2>/dev/null

Locate the template. (Claude Code only — Cowork skips this step.) Check for deck-template.pptx in the skill directory (skills/deck-builder/deck-template.pptx relative to plugin root). If not found, stop and tell the user: "The deck template file is missing. Download deck-template.pptx from the team's Google Drive (Tiger Data Templates folder) and save it to: plugins/tiger-marketing-skills/skills/deck-builder/deck-template.pptx". Do not proceed until the file is in place.

Load the template and record the original slide count:

prs = Presentation(template_path)
original_count = len(prs.slides)
template_slides = list(prs.slides)  # snapshot before appending

Define helper functions inline: duplicate_slide, replace_shape_text, replace_bullet_list, find_body_shape, find_text_shapes_by_position, delete_shape, delete_slide, trim_table, set_cell_text. Copy these verbatim from the template layout map reference.
Generate each slide from the deck plan — clone every slide, including placeholder layouts:
- duplicate_slide(prs, template_slides[clone_source_idx]) → find shapes by role using the Clone Source Slides section → replace text with replace_shape_text() or replace_bullet_list()
- For placeholder shapes: replace_shape_text(slide.placeholders[idx], "text") — never use placeholder.text = directly, as this strips bodyPr, paragraph, and run formatting
- Set speaker notes on every slide: slide.notes_slide.notes_text_frame.text = notes
Delete original template slides by iterating in reverse from original_count - 1 down to 0: delete_slide(prs, i)
Save and report: File path, total slide count, any slides that fell back to speaker-notes mode, and which slides contain template images that may need manual replacement.

Fallback: If cloning fails for any slide, create a slide from the layout and put body content in speaker notes with [REPLACE: Body] markers. Report which slides need manual touch-up.

Cowork: Structured markdown output

Produce slide-by-slide markdown in the conversation. Format each slide as:

---

## Slide [N]: [Title]
**Layout:** [Cowork description from template layout map]

**Title:** [Title text]

**Body:**
[Body content — bullets, paragraphs, or key metric as appropriate for the layout]

**Speaker notes:**
[Full speaker notes]

---

For the Layout field: use the Cowork description from the layout's entry in the template layout map — a short visual description of what the layout looks like (e.g., "Dark centered title slide" or "Title + content area"). Do not use layout index numbers or slide numbers.

Include a preamble at the top:

How to build this deck in Google Slides: Open your template. For each slide below, right-click a slide in the panel → Change layout and pick the layout matching the Layout field. Or find a slide in the template that visually matches the description, duplicate it, and replace the text. Paste title and body content directly into each shape. Speaker notes go in the notes panel (View → Show speaker notes).

7. Optional: Tiger Den content enrichment

If the search_content tool is available, search for related existing content (blog posts, case studies, benchmarks) that could strengthen specific slides. Use the published_after parameter to filter to content from the last 18 months. Add relevant links to speaker notes as supporting material.

8. Optional: Voice profiles

If the user mentions who will present the deck and the get_voice_profile tool is available, load that person's voice profile to adjust the speaker notes tone. The slide content itself stays brand-voiced; the voice profile influences speaker notes only.

Template setup (first-time)

If the template layout map has not been configured, guide the user through setup:

What you need

The team's Google Slides template — the canonical branded template
A .pptx export — File > Download > Microsoft PowerPoint (.pptx) from Google Slides
Upload to Google Drive — place the .pptx in the shared references folder as deck-template.pptx

Auto-generate the layout map (Claude Code)

In Claude Code, inspect the .pptx programmatically to auto-generate the template layout map:

from pptx import Presentation
from pptx.util import Inches, Pt

prs = Presentation('/tmp/deck-template.pptx')

for i, layout in enumerate(prs.slide_layouts):
    print(f"### Layout {i}: {layout.name}")
    print(f"**Placeholders:**")
    print(f"| idx | name | type | width | height |")
    print(f"|-----|------|------|-------|--------|")
    for ph in layout.placeholders:
        print(f"| {ph.placeholder_format.idx} | {ph.name} | {ph.placeholder_format.type} | {ph.width} | {ph.height} |")
    print()

Run this script, review the output, and save it to references/template-layout-map.md in this skill's directory. Add semantic roles and content constraints for each layout based on what you see.

Manual setup (Cowork)

If in Cowork, ask the user to describe each slide layout in their template:

Layout name (as shown in the slide master)
What it looks like (title only, title + bullets, two columns, big number, etc.)
What content goes where

Write the template layout map based on their description.

Dependencies

Required: Template layout map (references/template-layout-map.md) — must be configured before first use
Claude Code only: python-pptx Python package (auto-installed), deck-template.pptx in Google Drive
Optional: Tiger Den MCP for content search and voice profiles

deck-builder