LLM-Based PPT Generation: Technical Architecture and Production Practices

    Why do opinions diverge so sharply on whether large language models can generate PPTs well? This article builds an evaluation framework for LLM-based presentation generation, breaks down a complete production pipeline from requirement understanding to rendering and verification, and shows how a structured intermediate representation makes output editable and exportable. It then treats aesthetics as reproducible engineering rules, explains incremental regeneration and the cost structure of a full generation, and outlines a local post-editing workflow. It closes with key risks and role-specific recommendations, helping readers balance cost against quality and design an effective human–AI division of labor.

    Debate around “one-click PPT generation with large language models” has clearly picked up lately. Some say the results look great, while others feel that token usage burns through too fast and doesn’t last across multiple rounds of edits. Why does the same capability draw such sharply divided opinions?

    The answer lies deep in the generation pipeline. This article first establishes an evaluation framework, then breaks down a complete production pipeline, and finally offers engineering practices that balance cost and quality.

    1. Before You Evaluate: The Capability Tiers of “Automated PPT Generation”

    Before deciding whether a tool is good, it is worth distinguishing “generating a PPT” from “making a good PPT.” Based on how deeply the system intervenes in content production, capabilities can be roughly split into three tiers:

    Capability tier Typical approach Strength Weakness
    Text segmentation Split the script into sections and fill preset layouts Fast, almost no extra inference Content organization is entirely the user’s job
    Template filling Place copy and images into a fixed template Consistent style Templates easily disconnect from content; limited personalization
    End-to-end production line System orchestrates research, content, layout, rendering, and export More substantial content, more unified style High per-run cost; edit cost tied to generation cost

    There is also a commonly confused phenomenon: the cloud service and local client of the same product may run different capability versions, with the local built-in capability often lagging by a version. In addition, the prompt templates and workflow rules used to constrain generation behavior are usually among a platform’s most valuable assets and are not shipped with the client.

    So, to judge whether a solution is “good,” look at at least four gates:

    1. Content gate: Is the information accurate, and does the structure follow reporting logic?
    2. Layout gate: Does text overflow, do images and text overlap, and are pages consistent with one another?
    3. Editability gate: Can the export continue to be edited in common office software?
    4. Economic gate: From first generation to final version, how much time and quota was spent in total?

    Fail any one gate, and the experience suffers significantly.

    2. Breaking Down the Pipeline: How a High-Quality Presentation Is Generated

    A relatively mature generation system usually includes the following stages:

    1. Requirement understanding: Clarify topic, audience, occasion, and length, then produce a slide-level outline;
    2. Research: Search, filter, and distill material around each point, keeping sources where necessary. This is the often-mentioned “research first, build later”;
    3. Content drafting: Write titles, key points, and speaker notes page by page, controlling the information density of each slide;
    4. Structural arrangement: Plan the narrative rhythm, such as background, problem, solution, argument, and conclusion;
    5. Layout decisions: Match each page with a template, layout, and color scheme, and adapt the amount of text to the layout;
    6. Rendering: Produce a previewable web view and an editable pptx file;
    7. Verification and revision: Automatically detect issues such as overflow and overlap, escalating to the model or a human for review when needed.

    The point most worth emphasizing is this: the more you put “research and content” first, the more substantial the output becomes. A solution that only assembles layouts essentially leaves the “thinking things through” work to the user.

    3. Structured Intermediate Representation: The Foundation of Editability and Export

    Why not just have the model generate Office XML directly? Because the Office Open XML (OOXML) format has deep nesting and complex relationships, with presentations, layouts, themes, and relationship tables intertwined. When a model generates it directly, structural errors easily occur, leaving the file unable to open. A more reliable approach is to define a concise intermediate representation (IR), then compile it into the final file with a deterministic program.

    Below is an illustrative YAML description (element coordinates use a top-left origin, in pixels):

    1. deck:
    2. meta:
    3. title: "Distributed Consensus: Starting from Raft"
    4. theme: "tech-dark"
    5. theme: # Defined once; all pages reference the same tokens
    6. colors: { bg: "#0F1729", fg: "#F5F7FA", accent: "#4F8DFD" }
    7. type:
    8. display: { size: 72, line: 1.2 }
    9. body: { size: 28, line: 1.6 }
    10. grid: { columns: 12, gutter: 24, margin: 96 }
    11. slides:
    12. - id: p01
    13. layout: cover
    14. elements:
    15. - { id: t1, type: text, box: [96, 420, 960, 160], text: "Distributed Consensus: Starting from Raft", style: "display" }
    16. - { id: t2, type: text, box: [96, 620, 960, 48], text: "Tech Talk · 2025", style: "body" }
    17. - id: p02
    18. layout: three_column
    19. elements:
    20. - { id: t3, type: text, box: [96, 96, 900, 80], text: "Three typical replicated state machines" }
    21. - { id: c1, type: card, box: [96, 240, 560, 520], title: "Primary–replica", bullets: ["Writes concentrated on the primary", "Failover depends on external arbitration"] }
    22. - { id: c2, type: card, box: [680, 240, 560, 520], title: "Paxos", bullets: ["Theoretically complete", "Complex engineering implementation"] }
    23. - { id: c3, type: card, box: [1264, 240, 560, 520], title: "Raft", bullets: ["Leader election + log replication", "Easy to understand and implement"] }

    The model is only responsible for producing this kind of “declarative” structure. The compilation layer then converts it into two sets of products:

    • Preview product: a web view (HTML/CSS or SVG). Renders fast, is visually precise, and is easy to share;
    • Editable product: generate the pptx using a mature open-source office document library.
    OOXML component Main role Note during generation
    Presentation main document Slide list and dimensions Slide IDs unique, order correct
    Layouts and master Page skeleton and placeholders Prefer placing elements in layout placeholders for easier theme switching later
    Theme Global color scheme, fonts, effects Theme colors consistent with tokens in the intermediate representation
    Slide parts Shapes and text boxes per page Shape tree structure correct, text boxes with autofit enabled
    Relationship files Links between pages and layouts, images Relationship ID references complete, otherwise an error appears on open

    In addition, CJK typesetting has some easily overlooked details:

    • Line height is usually 1.5–1.7× the font size, noticeably larger than Latin-text typesetting conventions;
    • Text boxes need enough vertical padding to avoid the first and last lines being clipped;
    • Add appropriate spaces before and after Latin text and numbers to avoid CJK and Latin characters running together.

    Whether output is truly “editable” can be judged with an acceptance checklist: Can each text box be selected and edited individually? Can PowerPoint theme colors and fonts be applied? Can pages be added or removed directly? After export, can other office software open it and still edit it normally?

    4. Engineering Aesthetics: Turning “Good-Looking” into Reproducible Rules

    “Good-looking” sounds subjective, but in engineering it can be broken down into a set of executable rules.

    1. Design tokens. Unify colors, font sizes, line heights, and spacing into tokens, with all pages sharing the same set. For example, follow a 60-30-10 color ratio (background, primary, accent), form a font-size scale with a 1.25 or 1.5 modulus, use spacing in multiples of 8, and place elements on a 12-column grid.
    2. Asset and style libraries. Built-in libraries of icons, images, charts, styles, and templates, complemented by web search for up-to-date material. The model “calls out” assets from the library during generation instead of describing an image out of thin air.
    3. Industry templates and workflow guidance. Different scenarios expect different things from a presentation—for example, technical proposals emphasize architecture and trade-offs, while business plans emphasize market and finance. Industry templates and built-in standard operating procedures (SOPs) turn “what to cover in which occasion” into executable steps.
    4. Layout decisions as constrained optimization. Based on the amount of text, number of key points, and whether charts are included, pick the most suitable layout for each page. For example, 3 key points use a three-column card layout, a 5-step process uses a flowchart, and two sets of data use a comparison chart.
    5. Visual review loop. After rendering to an image, a vision model or rules check alignment, whitespace, and hierarchy, fixing any issues found.

    Combine these together, and you get what is called “aesthetic capability.” It is not about adding a “please make it look good” instruction to the model, but about decomposing aesthetic judgment into constraints and assets so that results can be reliably reproduced.

    5. Incremental Regeneration: From “Re-Running Everything Each Round” to “Recomputing on Demand”

    In end-to-end production-line solutions, a common problem is that every edit request triggers a full re-run of the entire pipeline. Even if you change just one sentence on page 8, research, content, and layout all start over, and the revised result may not preserve the layout style of previous rounds.

    The engineering solution is progressive across three layers:

    • Layer 1, reuse cache: directly reuse last round’s results for unchanged pages and assets;
    • Layer 2, impact analysis: identify which pages and elements this edit affects, and recompute only the affected parts;
    • Layer 3, object-level patches: a local edit issues only a single patch object, such as “replace text,” “adjust position,” or “swap image,” applied by a deterministic program.

    Illustrative implementation:

    1. def regenerate(prev_deck, edit):
    2. """Incremental regeneration: recompute by impact, not a full re-run"""
    3. plan = analyze_edit(prev_deck, edit) # Impact analysis: which pages/elements need recomputation
    4. pages = []
    5. for page in prev_deck.slides:
    6. if page.id in plan.changed_pages:
    7. # Call the model only for affected pages; reuse cache for the rest
    8. pages.append(rebuild_page(page, plan.context_for(page)))
    9. else:
    10. pages.append(page)
    11. return finalize_deck(pages) # Update global elements like page numbers and TOC

    This mechanism also significantly improves the “sense of uncontrollability” in the experience: change one page and only that page changes, making it easier for users to understand the system’s behavior and to accept the result.

    6. Cost Structure: What Actually Makes a “Full Generation” Expensive

    End-to-end generation is a typical long-chain inference task with multiple model calls, where later steps often depend on the output of earlier ones. Its cost is roughly determined by the following factors:

    • Number of pages: the main cost multiplier;
    • Context accumulation: research material and already-generated content must be passed with each request, so context grows longer toward the end;
    • Multi-stage calls: outline, research, content, layout, and verification are each one or more calls;
    • Regeneration: whether each round of edits starts from scratch.

    These stages can be broken down as follows:

    Stage Input Output Parallelizable Reusable
    Outline planning Requirement description Slide outline No Cacheable, as a basis for later stages
    Research Outline Key points and sources per page Yes, in parallel by page Cache by topic
    Content drafting Outline + material Copy per page Yes, in parallel by page Reusable when a page is unchanged
    Layout rendering Copy + template Structured description Partial Reusable once layout is fixed
    Verification Render result Issues and revisions Yes, can spot-check Rules can be fixed and reused

    Since cost mainly comes from pipeline length and repetition, optimization should center on these two:

    1. Cheap first, expensive later: use a lightweight model at the outline stage, then move to research and layout after confirmation;
    2. Parallel by page: pages have no dependencies among them, so process them in parallel to shorten time;
    3. Route local edits to incremental: whatever can be changed locally, never regenerate the whole deck;
    4. Do not spend backend quota on what the frontend can edit: adjustments like font size, color, and a single sentence of copy should be done in the UI editor first;
    5. Batching and caching: common templates and material can be cached, and repetitive tasks can be batch-scheduled.

    Below is an illustrative estimate for easier discussion; it does not correspond to any specific product’s billing rules. Assume a single full generation:

    • Outline stage: about 3,000 tokens;
    • 20 pages of content, averaging about 9,000 tokens per page (including research summaries and layout descriptions);
    • Verification and review: about 1,000 tokens.

    Then a single generation is about 184,000 tokens, of which the content stage accounts for about 98%. This means that reducing per-page cost and avoiding unnecessary regeneration matter more than saving elsewhere.

    1. # Illustrative: rough estimate of token usage for one full generation (values only show the order of magnitude)
    2. outline_tokens = 3_000
    3. per_slide_tokens = 9_000
    4. pages = 20
    5. review_tokens = 1_000
    6. total = outline_tokens + per_slide_tokens * pages + review_tokens # 184,000
    7. # If page 8 needs a rewrite, recompute only that page
    8. patch_tokens = per_slide_tokens # 9,000
    9. saving = 1 - patch_tokens / total # ≈ 95%

    When choosing a solution, do the math first: estimate total cost by “expected number of edit rounds × cost per round,” then compare it against the target solution’s per-run quota and add-on pricing. Comparing only single-run prices easily underestimates the true cost.

    7. Local Secondary Editing: A More Economical, More Controllable Finalization Path

    Compared with full office software, online editors still fall short in complex layouts, master adjustments, animations, and chart linking. For users seeking fine control, a more pragmatic approach is to position the system as “the first half of the production line”:

    1. Preparation stage: organize core points, key data, asset links, a glossary, and style preferences into a structured outline;
    2. Generation stage: issue the complete requirements at once and let the system handle research, drafting, and layout;
    3. Finalization stage: export the pptx locally and hand it to a general-purpose coding agent or a human for further refinement.

    When collaborating with a general-purpose coding agent, hand the “read files, edit files, run verification” loop to the agent and give it clear constraints:

    1. You are a presentation refinement assistant. Follow these rules:
    2. 1. Only modify what is explicitly listed in the task; do not change copy or layout on other pages;
    3. 2. Keep the master's theme colors and fonts unchanged; new elements must fall within the 12-column grid;
    4. 3. Title font size no smaller than 28pt, body no smaller than 16pt, body line height no less than 1.5x;
    5. 4. No more than 6 key points per page, each no more than 20 characters;
    6. 5. After editing, run the check script to confirm no text overflow and no elements out of bounds;
    7. 6. Output a change list explaining what changed and why, item by item.

    A more reliable approach is to make layout validation a repeatable script, giving the agent objective grounds for every edit:

    1. # Illustrative: layout rule checks, shared by the generation side and the local refinement side
    2. def check_deck(deck, theme):
    3. issues = []
    4. W, H = 1920, 1080
    5. for slide in deck.slides:
    6. boxes = []
    7. for el in slide.elements:
    8. x, y, w, h = el.box
    9. if x < 0 or y < 0 or x + w > W or y + h > H:
    10. issues.append(f"{slide.id}/{el.id}: element out of bounds")
    11. if el.type == "text":
    12. if estimated_text_height(el, theme) > h:
    13. issues.append(f"{slide.id}/{el.id}: text overflow")
    14. if el.style == "body" and theme.type.body.size < 16:
    15. issues.append(f"{slide.id}/{el.id}: body font too small")
    16. boxes.append((el.id, el.box))
    17. for i in range(len(boxes)):
    18. for j in range(i + 1, len(boxes)):
    19. if has_overlap(boxes[i][1], boxes[j][1]):
    20. issues.append(f"{slide.id}: {boxes[i][0]} overlaps {boxes[j][0]}")
    21. return issues

    The online and local paths each have their strengths, and combining them is usually safer than betting on a single entry point:

    Dimension Online generation & editing Local refinement after export
    Generation quality System’s built-in research and aesthetics; high starting point Depends on the local solution’s capability
    Edit granularity Supports full-page or even whole-deck regeneration Precise down to a single shape and text box
    Marginal cost Tied to the full generation pipeline Usually only consumes local compute
    Controllability Affected by platform version and policy Rules, templates, and scripts fully self-controlled
    Suitable stage From 0 to 0.8, fast drafting From 0.8 to 1.0, fine polishing

    8. Risks and Pitfalls: What to Watch Beyond the Results

    • Content authenticity: generated content must go through fact-checking. Pages involving data and citations should keep their sources; if using retrieval-augmented generation, also guard against malicious instructions embedded in web pages interfering with the generation process (that is, “prompt injection”).
    • Copyright and compliance: confirm the licensing scope of images, fonts, and templates one by one, and ideally run a copyright and compliance review before publishing results externally.
    • Version and data boundaries: when cloud and local capabilities differ, go by the version actually available; for sensitive internal material, prefer solutions where data does not leave your domain.
    • Measure, don’t feel: it is worth tracking metrics such as end-to-end latency, first-pass success rate, manual rework time, and average cost per page, using data to judge whether a solution fits your team.

    9. Conclusion and Recommendations

    There is no single answer to “is LLM-based PPT any good”—it depends on what you use it for:

    • When you need a fast first draft that is structurally complete, visually unified, and backed by some research, end-to-end production-line solutions can indeed deliver “good-looking” results today;
    • When you need repeated edits, precise targeting of a specific text box, or complex masters and animations, its marginal cost rises quickly.

    Recommendations for different roles:

    • Individual users: prepare outlines and assets in advance, produce in one pass, and leave refinement to local tools;
    • Developers: prioritize building a structured intermediate representation, template and asset libraries, incremental regeneration, and layout validation, and avoid treating “regeneration” as the only means of editing;
    • Enterprise teams: position cloud generation as a “content first-draft engine,” paired with content security review, access management, and log auditing, to form a closed loop of “AI generation + human review + local finalization.” Such capabilities can be built on general cloud services—such as object storage, content moderation, and logging and monitoring—offered by platforms like Baidu AI Cloud.

    Essentially, an AI-generated PPT is more like an efficient “first-draft engine” than a “designer” that understands every edit intent. Understanding its capability boundaries and designing a good human–AI division of labor is the key to using such tools well.