💻 computer science

Design First, Code Later: Aesthetically Pleasing Template-Free Slides Generation

This paper introduces DeepSlides, a template-free framework that decouples slide design from implementation through a hierarchical workflow, a specialized dataset, and multi-agent reinforcement learning to generate aesthetically pleasing presentation slides that outperform existing template-based or code-emission approaches.

Original authors: Zhiyao Cui, Chenxu Wang, Shuyue Hu, Yiqun Zhang, Wenqi Shao, Qiaosheng Zhang, Zhen Wang

Published 2026-05-27

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Zhiyao Cui, Chenxu Wang, Shuyue Hu, Yiqun Zhang, Wenqi Shao, Qiaosheng Zhang, Zhen Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: The "Cookie Cutter" vs. The "Messy Kitchen"

Imagine you need to make a presentation. Currently, most AI tools do one of two things:

The Cookie Cutter: They force your content into a rigid, pre-made template. It looks neat, but it's boring and doesn't fit your specific story.
The Messy Kitchen: They try to write the code for the slides and design them at the same time. This often leads to "spaghetti code" where the AI gets confused, the text overlaps the images, or the colors clash, resulting in a messy, unprofessional slide.

The authors of this paper argue that to make a truly beautiful presentation, you need to stop trying to do everything at once. You need to separate Designing from Building.

The Solution: DeepSlides (The "Architect and the Builder")

The paper introduces a new system called DeepSlides. Think of it like hiring a team for a house construction project, but for digital slides.

Instead of one robot trying to do everything, DeepSlides uses a hierarchical workflow with two distinct roles:

The Architect (The Designer):
- Role: This agent looks at your topic (e.g., "Urban Heat Island Mitigation") and decides the vibe. It chooses the color palette, the font styles, the layout rhythm, and how the story flows from page to page.
- Analogy: Imagine an architect drawing a blueprint. They decide where the windows go, what the house looks like, and how light enters the room. They don't worry about the specific brand of nails or the exact torque of the screwdriver.
- Key Feature: They create a "Style Guide" and a "Layout Plan" without worrying about the technical code yet.
The Builder (The Coder):
- Role: This agent takes the Architect's blueprint and writes the actual Python code to build the slide.
- Analogy: This is the construction crew. They read the blueprint and hammer the nails, paint the walls, and install the fixtures. They are experts at making sure the code runs and the slide actually appears on the screen.
- Key Feature: They focus purely on execution. If the Architect says "put a blue circle here," the Builder makes sure the blue circle appears exactly there without breaking the code.

The Process: How It Works

The paper describes a step-by-step journey to create a slide deck:

Deep Research: Before making a single slide, the system acts like a detective. It searches the web for information and images related to your topic to build a solid outline.
The "Design First" Phase:
- The Architect decides the overall style (e.g., "Modern, clean, blue tones").
- It then plans each slide individually, deciding where the title goes, where the image goes, and what the background looks like.
The "Code Later" Phase:
- The Builder takes those plans and writes the code to generate the PowerPoint file.
The "Quality Control" Loop:
- Before the slide is finished, a "Checker" looks at it. Did the text overlap the image? Is the color too bright? Is the code broken?
- If there's a problem, the system sends it back to the Architect or Builder to fix it. This is called Iterative Refinement.

The Secret Sauce: Multi-Agent Reinforcement Learning

How did they teach the AI to be this good? They didn't just give it a textbook. They used a training method called Multi-Agent Reinforcement Learning (MARL).

The Analogy: Imagine training a dog and a cat to work together.
- First, they teach them separately (Supervised Fine-Tuning) so the Architect knows how to draw, and the Builder knows how to code.
- Then, they let them work together in a simulation. Every time they make a beautiful slide, they get a "treat" (a reward). If they make a messy slide, they get a "time-out."
- Over time, they learn to communicate perfectly. The Architect learns to draw plans that are easy for the Builder to execute, and the Builder learns to follow the plans precisely.

The Results: Why It Matters

The authors tested DeepSlides against other tools (like Kimi, Manus, and direct AI generation) and found:

Human Preference: When real people looked at the slides, they overwhelmingly preferred DeepSlides. In head-to-head tests, DeepSlides won 76.5% of the time against open-source competitors and 52% against commercial giants.
Visual Quality: The slides were less "dull" and more "creative." They had better color harmony and clearer layouts.
No Templates: Unlike other tools that just swap text into a fixed box, DeepSlides creates unique layouts for every slide based on the content.

The Dataset: "SlideDesign"

To train these AI models, the researchers couldn't just use random internet slides. They built a new dataset called SlideDesign.

What is it? A massive collection of 420 different topics (from science to humanities) where every topic has a full set of: Research notes, a slide outline, a design plan, the final code, and the resulting image.
Why? It teaches the AI the difference between what the slide says and how it should look.

Summary

DeepSlides is a new way to make AI presentations. Instead of asking an AI to "make a slide" and hoping for the best, it splits the job into Designing (the creative part) and Coding (the technical part). By letting a "Designer" agent plan the look and a "Coder" agent build the file, and then training them together to learn from their mistakes, the system creates presentations that are not only informative but also visually stunning and professional—without needing pre-made templates.

Technical Summary: DeepSlides – A Hierarchical, Template-Free Approach to Automated Slide Generation

1. Problem Statement

The automatic generation of presentation slides requires the coordination of narrative structure with page-level graphic design under strict spatial constraints. While Large Language Models (LLMs) have advanced in content generation, existing automated slide generation systems suffer from significant limitations:

Template Dependency: Many systems rely on fixed templates, which restricts creative layout capabilities and results in visually monotonous outputs.
Design Bypass: Approaches that directly emit executable code (e.g., HTML/LaTeX) often bypass the essential slide-page design step, leading to layouts that are compositionally weak, visually dull, and lacking in semantic grounding.
Quality Gap: Current methods fail to produce presentations that are visually coherent and engaging for real-world professional settings, often prioritizing surface-level decoration or content generation over holistic visual design.

2. Methodology: The DeepSlides Framework

The paper proposes DeepSlides, a hierarchical workflow that explicitly decouples slide-page design from implementation. The system operates through a "Design First, Code Later" paradigm, structured into three primary stages:

2.1 User Requirement Simulation & Outline Generation

To mimic the workflow of domain experts, DeepSlides employs a DeepResearch module. This agent:

Conducts structured knowledge acquisition via web search and image retrieval.
Synthesizes a multimodal research report.
Generates a structured, multi-level slide outline, determining sections, allocating slide budgets, and defining core content (titles and bullet points).

2.2 Slides-Level Design (Global Strategy)

Before generating individual pages, the system establishes high-level design guidelines to ensure inter-page coherence and diversity:

Style Definition: The agent determines the global tone, color palette, and typography.
Instruction Formulation: Pages are categorized into Functional Pages (cover, dividers, closing) and Content Pages. Specific design instructions are formulated for each, detailing decorative elements, shapes, and their spatial relationships.
Layout Planning: The system generates slide-specific layout specifications (e.g., "horizontal blocks") to promote structural diversity while maintaining stylistic consistency.

2.3 Page-Level Generation (Iterative Refinement)

For each slide, the system performs a multi-step process:

Content Expansion: For content pages, the agent generates targeted search queries to gather supplementary text and images, distilling them into candidate snippets.
Three-Layer Design: The design is decomposed into:
- Background Layer: Independent decorative elements (textures, images).
- Layout Layer: Structural block arrangement, roles, and spatial positioning.
- Content Layer: Concrete text and visual assets placed within blocks.
Implementation: The design specifications are translated into Python code to programmatically construct editable .pptx files. This choice prioritizes native editability over HTML/LaTeX outputs.
Evaluation & Feedback: An agent evaluates the rendered slide on three dimensions:
- Completeness: Alignment with requirements and outline.
- Compliance: Absence of overlapping blocks or content spillover.
- Aesthetics: Color harmony, visual hierarchy, and balance.
- Refinement: Based on scores, the agent iteratively refines the design and code.

3. Training Paradigm and Dataset

3.1 SlideDesign Dataset

The authors constructed SlideDesign, a multi-disciplinary multimodal dataset derived from 420 topics across the Field of Science (FOS) taxonomy. It includes paired textual and visual resources, design specifications, and executable Python code for slide generation.

3.2 Multi-Agent Reinforcement Learning (MARL)

The authors trained a suite of models, SlideQwens, using a multi-agent reinforcement learning framework inspired by ReMA:

Agents: Two specialized models, Designer and Coder.
Process: The Designer outputs a layout action; the Coder translates this into Python code.
Reward Mechanism:
- Coder Reward ( $R_C$ ): Based on code executability and implementation completeness.
- Designer Reward ( $R_D$ ): A weighted sum of completeness, compliance, and aesthetics (gated by implementation completeness to prevent rewarding beautiful but broken slides).
Training Strategy: A two-stage approach involving Supervised Fine-Tuning (SFT) for initialization, followed by MARL for optimization.

4. Experimental Results

The paper evaluates DeepSlides against baselines including direct LLM generation (Claude Haiku/Sonnet), template-based systems (Auto-Slides), and code-based approaches (EvoPresent), as well as commercial solutions (Kimi, Manus).

Objective Metrics: DeepSlides achieved the highest average VLM-based evaluation score (3.78), outperforming baselines in Layout (3.55), Hierarchy (4.04), and Color Scheme (3.71). While its success rate (95%) was slightly lower than EvoPresent (100%), it demonstrated superior visual quality.
Human Preference: In a blind study with 20 volunteers:
- DeepSlides achieved a 76.5% win rate against open-source baselines, significantly outperforming the second-best method (9.5%).
- Against commercial systems, it achieved a 52.0% win rate, surpassing the strongest commercial baseline by 32.5%.
- It received the highest Top-1 preference share across all tested models.
Human Style Evaluation: DeepSlides scored highly across four dimensions: Clarity, Creativity, Visualization, and Aesthetics.
Model Performance: Training results showed that while the base 0.6B model failed, the SFT-initialized model achieved an 81.4% success rate, which improved to 86.0% with MARL, confirming the necessity of the staged training approach.

5. Significance and Claims

The paper claims that DeepSlides represents a significant advancement in automated slide generation by addressing the "design vs. implementation" gap. Its primary contributions are:

Decoupled Workflow: By separating high-level design reasoning from low-level code implementation, the system avoids the distortion of aesthetic intent by implementation artifacts, allowing for more creative and coherent layouts.
Template-Free Generation: The framework eliminates reliance on fixed templates, enabling dynamic, content-aware layouts that reduce visual fatigue.
Effective Training Paradigm: The combination of the SlideDesign dataset and the Multi-Agent Reinforcement Learning approach successfully trains lightweight models (0.6B parameters) to perform complex, structured multimodal tasks.
Superior Quality: Empirical evidence suggests that this structured, design-first approach produces outputs that are perceived as more visually attractive, creative, and professionally composed by human evaluators compared to existing template-driven or direct-code methods.

The authors acknowledge limitations, including increased inference latency due to the multi-stage pipeline, potential challenges in maintaining strict brand-level styling without explicit references, and the need for rigorous security and ethical safeguards regarding intellectual property and misuse.