How to Build a Slide Generator AI That Doesn't Suck

The Core Stack: LLM, API Glue, and a Templating Engine

You’ve seen the demos. Type a topic, and a full presentation appears. Magic. Except the output is usually a generic, soulless mess that you have to rewrite completely. The problem isn’t the AI; it’s the workflow. A good slide generator ai isn’t one magic box. It’s a system of components working together.

You need three things:

• A Large Language Model (LLM): This is the brain. Your only real choices for this kind of structured work are OpenAI’s GPT-4 series or Anthropic’s Claude 3 family. I find Claude 3 Opus is slightly more reliable for forcing valid JSON output, but GPT-4o is faster and more widely available in automation tools. We’ll use GPT-4o for this example.
• API Glue: This is the nervous system connecting the parts. You need a tool to make API calls without writing code. Make.com or Zapier automations are the main players. I build almost everything on Make.com. Its visual, flowchart-style interface is far better for debugging the multi-step chains required for this kind of AI automation blueprint.
• A Templating Engine: This is where the slides actually get made. Google Slides is the easiest to automate and it’s free. You could also use Pitch or even generate Markdown for a tool like Marp, but the Google Slides API is well-supported by no-code tools.

That’s it. An LLM, an automation platform, and a slide tool. The magic is in how you chain them together.

What Most Guides Get Wrong

Here’s the fatal flaw in 99% of AI presentation tutorials: they use a single, massive prompt. They ask the LLM to write an entire presentation in one go. This is lazy, and it produces terrible, unpredictable results.

You get rambling text, inconsistent formatting, and a structure that makes no sense. The AI hallucinates slide numbers and loses track of the narrative arc. It’s a mess.

The correct approach is to break the problem down. Think like a manager delegating tasks, not a wizard casting a spell. This is the core of a modern ai agent framework. You create a chain of specialized AI agents, each with one specific job.

• Agent 1 (The Outliner): Takes the main topic and generates only the high-level structure of the deck—the title and a list of slide titles and their core bullet points. Its output is clean, structured JSON.
• Agent 2 (The Writer): For each slide defined by the Outliner, this agent takes the title and bullets and expands them into polished, concise slide content.
• Agent 3 (The Coach): For each finished slide, this agent writes the speaker notes. Its job is to add context, stories, and transition phrases.
• Agent 4 (The Art Director): For each slide, this agent generates a descriptive prompt for an image generation model like DALL-E 3 or Midjourney.

By breaking it down, you get control. Each step is simpler, more predictable, and easier to debug. You’re not hoping for a miracle; you’re engineering a reliable process.

Step-by-Step: Building the Outline Agent in Make.com

Let’s build the first and most important part: the agent that creates the presentation’s structure. This is the foundation for everything else.

The goal is to take a topic from a Google Sheet and have OpenAI return a JSON object that defines the entire presentation structure. Here’s how.

1. The Trigger: Create a new scenario in Make.com. The trigger module will be ‘Watch New Rows’ in Google Sheets. Create a simple sheet with one column header: `Topic`.
2. The Prompt Module: Add an ‘Create a Completion’ module from the OpenAI app. Connect it to your account. Select the `gpt-4o` model.
3. The Magic Prompt: This is the most critical piece. You need to tell the AI exactly what you want, including the precise JSON format. Don’t be polite; be a demanding engineer. Copy this into the ‘Messages’ content field.

You are an expert presentation designer. Your sole job is to create a logical, structured outline for a presentation based on a user's topic. The topic is: '{{1.Topic}}'.

Generate between 5 and 8 slides. Ensure the flow is logical from introduction to conclusion.

This prompt does several key things: it assigns a role, it ingests our topic from the Google Sheet (`{{1.Topic}}`), it strictly defines the output format, and it explicitly forbids any extra conversational text. This level of instruction is non-negotiable for reliable automation.

How Do You Get from JSON to Actual Slides?

This is where the ‘glue’ part of your no code ai stack comes in. Your OpenAI module just returned a big block of text that happens to be JSON. Now you need to turn it into a real presentation.

This is where most people give up.

But in Make.com, it’s surprisingly straightforward. First, add a ‘Parse JSON’ module right after your OpenAI module. Point it to the text response from the AI. This turns the text into a structured object that Make can understand, with a `presentation_title` and an array of `slides`.

Next, you need to loop through that `slides` array. Add an ‘Iterator’ flow control module. For the ‘Array’ field, map the `slides[]` array from your parsed JSON object. The iterator will now run its own little sequence of actions, once for each slide in your outline.

Inside the iterator, you add the Google Slides modules.

1. First, add a ‘Create a Presentation’ module. Use the `presentation_title` from the JSON for the title. This only needs to run once, so you might place it before the iterator.
2. Inside the iterator, add a ‘Create a Slide’ module. It will ask for the Presentation ID (which you get from the previous step) and the content. Map the `slide_title` and `bullet_points` from the iterator to the title and body placeholders in the module.

My one big gripe here: the Google Slides API is terrible with text formatting. It will dump your text into a default text box, and it often looks bad. The best solution is to create a master Google Slides template with a pre-formatted slide layout you like, and then use the ‘Create a Slide from Template’ action instead. It’s an extra step, but it saves you from making ugly decks.

Expanding the Chain: Speaker Notes and Image Prompts

Once you have the basic structure working, expanding it is easy. Your iterator is already processing one slide at a time. You just add more steps inside it.

Want speaker notes? After the ‘Create a Slide’ module, add another OpenAI module. Feed it the title and bullets for the *current* slide in the loop.

The prompt could be: `You are a presentation coach. For a slide with the title “{{iterator.slide_title}}” and the following points: “{{iterator.bullet_points}}”, write 150 words of engaging speaker notes. Speak directly to the audience.` Then, take that output and use the ‘Update a Slide’s Speaker Notes’ module in Google Slides.

Want image suggestions? Same pattern. Add another OpenAI module. Prompt: `You are an art director. Describe a simple, clean, professional photo or abstract graphic for a slide titled “{{iterator.slide_title}}”. Output only the image description.` You can then log these descriptions to a Google Sheet or even pipe them directly into an image generation API.

This is the real power of an operator playbook. You build a system, not a single prompt. My favorite part is seeing a completely new, structured, and annotated deck pop into my Google Drive five minutes after I type a single topic into a spreadsheet. It’s not magic; it’s just a well-designed process that saves hours of mind-numbing work.

How to Debug When This Breaks

This system will fail. Not if, but when. Production automation is about anticipating failure. Here are the two most common break points and how to fix them.

Failure #1: Malformed JSON from the LLM.

Sometimes, despite your careful prompting, the LLM adds a comment, forgets a comma, or wraps the output in markdown. This will crash your ‘Parse JSON’ module. The fix is to make your prompt even more aggressive. Add phrases like “Your entire response must be ONLY the JSON object. Any other text will be rejected.” If it keeps failing, you can even create a second LLM call that acts as a ‘JSON fixer’ agent, whose only job is to take in broken text and return valid JSON (which, yes, is annoying but sometimes necessary).

Failure #2: API Rate Limits and Timeouts.

When you’re iterating and making multiple API calls to OpenAI and Google Slides in a rapid loop, you can easily hit a rate limit. The scenario will stop with an error. The simple fix is to add a ‘Sleep’ module inside your iterator. A delay of just 1 or 2 seconds between each slide creation is usually enough to keep the APIs happy.

Thinking about cost is also key. Make.com’s free plan is a joke for this kind of work; you’ll burn through your monthly operations in one test run. The Core plan, at $9/month as of early 2026, is the real entry point. Honestly, it’s a bargain for the time it saves.

Building a reliable slide generator ai is less about AI wizardry and more about solid automation architecture. It’s about breaking a big problem into small, manageable steps and then creating a resilient system to execute them.

If you want the deep cut on this, deeper coverage of AI agent platforms.

If you’d rather skip the build and deploy a working version in an afternoon, we’ve packaged this entire workflow as a deployable AI automation blueprint at deepusecase.com/vault.