Beamer

Beamer Slide Generator

Generate an original Beamer presentation from source content (structured notes, summaries, or raw material). This skill handles the full cycle: structure and register triage, outline checkpoint, code-first figure generation, design, authoring the .tex file, compilation, and verification through multi-agent review.

Six additions from Scott Cunningham's beautiful_deck approach are integrated: code-first figures (matplotlib), an outline checkpoint, structure-aware rhetoric, Devil's Advocate slides, code blocks, and transition slides.

Beyond generating a new deck, the skill also works on an existing one through three additional modes (edit, audit, and convert-to-PPTX); see Mode Selection below. Edit mode auto-activates when the current working directory already contains a *_build/slides.tex.

Input

This skill expects one or more of:

• A notes.md file with structured extraction from a deep reading (for example, from ../split-pdf/SKILL.md)
• A summary.md file with a structured summary
• Raw content, pasted text, or other source material

Two optional parameters tune the deck. structure= selects a domain pattern from domain_patterns.md: mba (the default), teaching, faculty, professional, consulting, or working. register= selects the language level: business (the default) translates or glosses the source's domain jargon for a non-specialist reader; technical keeps the source vocabulary intact. The legacy audience= parameter is accepted as a deprecated alias for structure= with the same value set.

If invoked standalone, ask the user what content to build slides from. If invoked as part of a slides workflow, notes and summary files will already exist in the working subdirectory.

Working Directory

Save all output files in the current working subdirectory. If no subdirectory has been established, create one named after the source material (for example, slides_smith_2024/).

If figures are extracted from the source PDF, save them to figures/ inside the working subdirectory, with original full-page renders in figures/originals/.

---

Mode Selection

Default mode: generate (build a new deck from source content). This skill also supports three additional modes for working with an existing deck. Generate-mode behavior is unchanged whether or not callers pass a mode= argument.

Edit mode activates when ANY of the following is true:

• The invocation includes mode=edit.
• The user invoked via an edit, revise, or fix trigger ("edit beamer", "revise beamer", "fix beamer slides", "update beamer deck").
• The current working directory contains a *_build/slides.tex and no mode=generate was passed.

Audit mode (mode=audit, or an audit trigger) re-runs the Quality Audit pass against an existing compiled deck. No content edits beyond audit-fix remediation. Use when revisiting a deck after a long pause, or to confirm a previously generated deck still passes the checklist.

PPTX mode (mode=pptx, or a "convert to pptx" trigger) runs only the PPTX conversion block against an existing compiled deck. No audit, no edits.

| Mode | When it runs | What it does | |---|---|---| | generate | Default; new content provided | Full pipeline (Step 0 to Output). Unchanged from prior behavior. | | edit | Edit trigger, mode=edit, or CWD auto-detect | Locate existing deck, load context, present menu, apply edits, run Compilation Cycle, iteration prompt | | audit | mode=audit or audit trigger | Locate existing deck, load PDF and .tex, run Compilation Cycle Step 3 (Quality Audit) then Step 4 (Fix), report | | pptx | mode=pptx or "convert to pptx" trigger | Locate existing deck, run the Output PPTX conversion block |

In any non-generate mode: skip everything from Step 0.1 through Figure Extraction (Step 0.1 Pre-flight Deliverable Check, Step 0.5 Structure and Register Triage, Step 0.6 Citation Strategy, Step 0.7 Outline Checkpoint, Step 0.8 Code-First Figure Generation, Design Requirements, Content Requirements, Visual Mechanism Selection, Number Formatting, Acronyms and Abbreviations, Quality Standards, Figure Extraction). All of these are generate-time prep that does not apply to a previously generated deck. Jump from Step 0 (LaTeX verification) directly into the Edit Mode section below for the locate and load-context steps, then dispatch per the chosen mode. The Edit Mode E2 step is the entry-point backup counterpart to Step 0.1; running both would produce duplicate timestamped backups.

In generate mode: proceed with every step as usual. There is no behavior change for workflows that call this skill in generate mode.

structure= and register= in non-generate modes: both parameters only take effect in generate mode (via Step 0.5 Structure and Register Triage). In edit, audit, or pptx mode, both are silently ignored; the deck's structure and register were set at generate time and are not reconfigurable mid-flight. To use a different structure, regenerate the deck from scratch with mode=generate. (audience= is the deprecated alias for structure= and is ignored here too.)

Auto-detection ambiguity: if the CWD contains multiple *_build/slides.tex subdirectories, auto-detection still fires (edit mode is chosen), and Step E1 below prompts the user to pick which deck.

Trigger vs CWD-auto-detect precedence: if the user invokes via an explicit generate trigger ("create beamer slides", "generate beamer deck", "make latex slides", "beamer presentation from this") AND new source content is provided in the same turn, run generate mode even if the CWD contains a *_build/slides.tex. Auto-detect only fires when the invocation is ambiguous (no explicit trigger family, or no source content). Rationale: a user who explicitly asks to create new slides in a directory that happens to already contain a deck is starting a second deck, not editing the first.

---

Edit Mode

This section runs when the skill is invoked in edit, audit, or pptx mode (per Mode Selection above). It performs the locate-and-load steps, presents the menu when in edit mode, and dispatches into the relevant Compilation Cycle and Output blocks. Skip this entire section in generate mode.

E1: Locate the Output and Build Subdirectories

The base directory is the current working directory at the time the skill is invoked.

If the user specifies a file or folder name:

• If the user provides a source file name (for example, smith_2024.pdf), look for the matching output subdirectory (for example, smith_2024/) and its build subdirectory (for example, smith_2024/smith_2024_build/).
• If the user provides a subdirectory name directly (for example, smith_2024), use that as the output subdirectory and look for _build/ inside it.

If no name is provided: list the subdirectories in the current working directory that contain a *_build/slides.tex file. If exactly one is found, use it. If multiple are found, present the list and ask the user to pick. If none are found, report the error and stop.

Validation: confirm that slides.tex exists in the build subdirectory. If it does not, report the error and stop.

E2: Pre-flight Deliverable Check (entry-point version snapshot)

Before loading context or applying any edits, preserve the deck being edited as a version snapshot. This start-of-round capture fires here at entry and again at each E8 loop-back (once per edit round).

1. Version-snapshot the deck. The deck about to be edited is the current compiled deck /slides.pdf, paired with its source /slides.tex. If it exists, preserve it as the next milestone:

• Glob existing _slides v*.pdf in the output subdirectory. Next N = highest existing vNN + 1, zero-padded to two digits; if none exist, N = 01. Generation writes no vNN, so the first edit creates v01, the backup of the generated deck.
• Snapshot suffix:
• v01 (no prior vNN): the deck being preserved is the generated baseline. Suffix = v01 structure- register-, where `/ are the structure and register the deck was generated with, read from the deck's generate-time entry in the project session log (CLAUDE.local.md if you keep one). If no record exists, use structure-mba register-business` and say so in the report.
• v02+: suffix = v0N , a 1-3 word descriptor of the change that defined the version being preserved. For an in-conversation E8 loop-back, derive the label from the edits just applied in that round.
• Copy the PDF: cp "/slides.pdf" "/_slides .pdf". (Fallback: if /slides.pdf is absent but the output deliverable exists, copy /_slides.pdf.)
• Copy its source, paired: cp "/slides.tex" "/slides .tex", so the version recompiles and diffs, not only views. The .tex must be taken now, before this round's edits overwrite it in place.

1. Version-snapshot the PPTX (if present), per Output's "PPTX version snapshots (vNN)": if .pptx exists and is not already byte-identical to the newest v*.pptx (cmp -s), snapshot it as the next vNN. If it is already preserved as the latest vNN, do nothing.

Report: "Snapshotted the deck being edited as _slides .pdf (+ source slides .tex)."

One snapshot per edit round (one batch of changes the user reviews): here at entry, and again at each E8 loop-back. Intra-round audit-fix recompiles do not snapshot. This is the safety net: every delivered version is preserved before the next round overwrites it.

Convention recap: _slides.pdf is always the latest; the vNN files are the preserved version history beneath it, each paired with its slides vNN ....tex source in _build/. v01 is the backup of the generated deck (made at the first edit), tagged with the deck's structure and register; later versions carry change-labels. After N edit rounds there are N vNN files; a count short of the rounds applied means a snapshot was skipped.

If no deck exists yet (no /slides.pdf and no deliverable), proceed silently.

E3: Load Context

Read the following files (silently skip any that do not exist):

From the build subdirectory (_build/):

1. notes.md: deep-reading extraction notes
2. slides.tex: the current Beamer source
3. figures/: if this directory exists, note it silently. The existing figures are available for reference in the .tex source; do not move or rename them. If the user's edits require adding new figures from the source PDF, follow the Figure Extraction protocol later in this skill (pdftoppm at 300 DPI, PIL crop, save to figures/, originals to figures/originals/).

From the output subdirectory:

1. _summary.md: structured summary (filename matches the output subdirectory name)

Do not load the PDF at this stage. The compiled PDF is only needed for the quality audit. If the dispatched path requires it (audit mode, or edit-mode menu option 2), load it then, gated to the four-page rule: if the compiled deck is 4 pages or fewer, read it directly in the main thread; if it is more than 4 pages, do not read it in the main thread. The Compilation Cycle Step 3 audit agent reads the full compiled PDF itself inside a subagent, so the main thread does not need the page images at all; hand off to Step 3 without a main-thread read. For all other paths, slides.tex is sufficient.

E4: Mode Dispatch

Branch on the active mode:

• mode=audit: jump directly to Compilation Cycle Step 3 (Quality Audit), which loads the full compiled PDF itself inside its audit subagent; no main-thread PDF read is needed here. After Step 4 (Fix and Recompile) completes, proceed to Output. Skip the menu in E5.
• mode=pptx: jump directly to the Output section's PPTX conversion block. Skip the menu in E5.
• mode=edit: continue to E5.

E5: Present Menu (edit mode only)

After loading context, pause and present this menu to the user:

> "Loaded slides for [title]. The deck has [N] slides. > Available context: [list which of notes.md, summary.md, slides.pdf were loaded] > > What would you like to do? > 1. Edit the slides: make content, layout, or style changes and recompile > 2. Run the quality audit: read the compiled PDF slide-by-slide and report visual or formatting issues > 3. Convert to PPTX: convert the existing compiled PDF to a styled PowerPoint file > 4. Something else: describe what you need"

Wait for user response. Then route:

| Choice | Action | |--------|--------| | 1. Edit | Continue to E6 (Response Discipline), then apply edits in E7, then proceed to Compilation Cycle Step 1. E8 iteration prompt fires after Step 4. | | 2. Quality audit | Jump to Compilation Cycle Step 3, whose audit agent loads the full compiled PDF itself inside a subagent; no main-thread PDF read is needed. Treat the rest of the flow as audit mode for E8 purposes; do not return to E8 after Step 4. The user picked audit-only and expects to land at Output, not back at the iteration menu. | | 3. PPTX | Jump to the Output section's PPTX conversion block. Skips Compilation Cycle entirely; E8 does not fire. | | 4. Something else | Clarify with the user, then proceed accordingly. If the clarification resolves to one of choices 1 to 3, follow that choice's E8 rule. |

E6: Response Discipline (edit mode only)

When the user reports a visual problem, defect, or issue with the slides:

1. Read the relevant slides in the compiled PDF to verify the problem, gated to the four-page rule. If the compiled deck is 4 pages or fewer, read it directly in the main thread. If it is more than 4 pages, do not read it in the main thread: split it into 4-page chunks with the split-pdf skill and launch a subagent to read the chunk(s) covering the reported slide(s). Instruct the subagent to return slide-level detail (for each slide in scope: the slide title, the verbatim text, numbers, and labels involved, and a concrete visual description of the defect, namely what overlaps, clips, overflows, or is mispositioned, and where on the slide), not a one-line summary. You need enough fidelity to locate and fix the exact element in slides.tex.
2. Describe what you found and propose a specific fix.
3. End with a question: "Should I apply this fix?" or "How would you like to handle this?"
4. Do not edit slides.tex in the same response. Wait for the user's approval before making any file changes.

This applies whether the problem was reported via screenshots, verbal description, or discovered during the quality audit. The user may want to handle the fix differently, redirect to a different priority, or provide additional context that changes the approach.

E7: Apply Edits (edit mode only)

Apply the user's requested edits to slides.tex in the build subdirectory. Follow the Beamer style guide at ../../style-guides/beamer/style-guide.md for all design decisions. Read it before making any edits if not already loaded. Use the loaded notes.md (from build) and _summary.md (from output) as source material when the user asks to add, expand, or rework content.

Edit types (handle any combination):

• Content changes: add, remove, reorder, or reword slides or bullet points
• Figure or chart changes: modify TikZ diagrams, pgfplots charts, data values, labels, colors
• Layout changes: split dense slides, merge sparse slides, change column widths
• Style changes: adjust colors, fonts, spacing (within the style guide)
• Structural changes: add new slides, remove slides, change slide order

After edits are written, proceed to Compilation Cycle Step 1.

E8: Iteration Prompt (edit mode only)

After Compilation Cycle Step 4 completes in edit mode, before proceeding to Output, ask: > "Edits applied and recompiled. Would you like to make further changes, or are you done?"

• If the user requests more edits (or an audit, or any further change to the deck): this

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: AI-Business-Tools
• Source: AI-Business-Tools/claude-code
• License: MIT

Install and usage instructions live in the source repository linked above.