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

The Core Problem with Off-the-Shelf AI Deck Tools

Let’s be honest. Most one-click AI presentation tools are garbage. You give them a topic, and they spit out a dozen slides filled with generic platitudes, terrible stock photos, and a design that looks like a 2008 PowerPoint template. They’re a novelty, not a professional tool. The output is so bland you spend more time fixing it than you would have spent just writing the deck yourself. They completely lack brand voice, specific data, or any real point of view.

The fundamental issue is that these tools are built for mass appeal. They have to be simple, which means they can’t be powerful. They use basic prompts and rigid templates because that’s the only way to guarantee some kind of output for any possible input. This approach prevents them from understanding context, nuance, or your company’s specific style. You can’t feed it your brand guide, your last three blog posts for tone, or a specific data sheet to include. You get what you get.

And you often pay a premium for this mediocrity. Many of these services lock you into subscriptions of $20-$50 per month for something that produces unusable first drafts. I think that’s a terrible value proposition. The goal isn’t just to make slides; it’s to Make.com*your* slides, faster. This guide shows you how to build your own asset that does exactly that. We’ll build an AI slide generator that takes a simple topic and produces a structured, on-brand deck outline and content, ready to be dropped into a template.

What Most Guides Get Wrong About This Workflow

If you search for how to do this, you’ll find a lot of tutorials that rely on a single, massive prompt. They try to get a large language model like GPT-4 to generate an entire presentation—titles, bullet points, speaker notes, and all—in one go. This is a rookie mistake, and it’s why so many self-built systems are fragile and unreliable.

A single prompt is asking the model to do too much at once. It has to manage multiple cognitive tasks: outlining a logical flow, writing concise slide content, expanding on that content for speaker notes, and formatting everything correctly (usually as JSON or Markdown). When a model juggles this many constraints, quality degrades across the board. The structure gets sloppy, the content gets repetitive, and the formatting breaks. It’s inefficient and prone to failure.

A better approach is to think like an assembly line. You break the problem down into smaller, distinct tasks and assign a specialized AI agent to each one. This is the core of a real operator playbook. Instead of one giant prompt, you create a chain of three smaller, more focused prompts:

• The Outliner Agent: Its only job is to take your topic and generate a logical structure for the presentation. It outputs a clean JSON array of slide titles and a one-sentence description for each. Nothing more.
• The Content Agent: This agent receives one slide title and description at a time from the Outliner. Its sole focus is to write the body content (like bullet points or a short paragraph) for that single slide. It does this for every slide in the outline, one by one.
• The Speaker Notes Agent: Following the Content Agent, this one takes the slide title and body content and writes the corresponding speaker notes. Again, it works on one slide at a time.

This multi-agent system is drastically more reliable. Each agent has a simple, well-defined task, which leads to higher-quality output and fewer errors. It’s a proper AI automation blueprint, not a weekend hack.

The Stack: What You’ll Actually Need (And What It Costs)

You don’t need a team of developers for this. You can build the entire system with a few off-the-shelf tools. This is a classic no-code AI project.

• OpenAI API (GPT-4o): This is the brain. You’ll need an API key from OpenAI to make calls to their models. For this task, GPT-4o is the best choice. It’s fast, relatively cheap, and excellent at following structured formatting instructions like producing JSON. Pricing is pay-as-you-go. A 12-slide presentation might cost you about $0.15 in API calls. It’s negligible.
• Make.com: This is the backbone of the operation. Make.com (formerly Integromat) is an automation platform that lets you connect different apps and services. We’ll use it to build the logic for our multi-agent chain, calling the OpenAI API for each step and passing the data along. Their free plan is a joke for any real work, so you’ll need a paid plan. The Core plan at $29/month is plenty to get started and run this workflow hundreds of times.
• Google Slides API: This is how we get the content into an actual presentation. You’ll set up a template slide deck in your Google Drive, and Make.com will use the API to create a copy, then add new slides and populate them with the text generated by the AI. Accessing the API is free, but setting it up is a bit of a pain.

That’s it. For around $29 a month plus pennies per deck, you get a custom, infinitely-tweakable AI slide generator that runs on your own rules.

Step-by-Step: Building the Content Generation Engine in Make.com

This is where the magic happens. We’ll set up a scenario in Make.com that orchestrates our AI agents. The trigger can be a simple webhook, a form submission, or even a new row in a Google Sheet.

The flow looks like this:

1. Trigger: Let’s say we use a Make.com webhook. You send it a JSON payload with your topic: {"topic": "An Introduction to Quantum Computing for Beginners"}.
2. Step 1: The Outliner Agent (OpenAI Module): The first OpenAI module gets the topic from the webhook. Its system prompt defines its role and expected output format. The user prompt is just the topic itself.

System Prompt: You are an expert presentation outliner. Given a topic, create a logical slide structure. Your output MUST be a valid JSON array of objects. Each object should have two keys: 'title' (a string) and 'description' (a one-sentence string explaining the slide's purpose). Do not include any other text or explanation.

3. Step 2: Parse JSON: Make.com has a built-in JSON parser. You feed the text response from the OpenAI module into this to convert it into a structured array that the next steps can loop through.
4. Step 3: Iterator: Use Make.com’s Iterator tool to process the array from the JSON parser. This will run the subsequent steps once for each slide object in the outline.
5. Step 4: The Content Agent (OpenAI Module): Inside the iterator, another OpenAI module gets the `title` and `description` for a single slide. Its job is to generate the body text.

System Prompt: You are a concise content Writer.com. Given a slide title and description, write the body content for the slide. Use 3-4 short bullet points. Start each bullet point with a dash.

6. Step 5: The Speaker Notes Agent (OpenAI Module): A third OpenAI module takes the same `title` and `description` (and optionally the bullet points from the previous step) to generate speaker notes.

System Prompt: You are a presentation coach. Given a slide title and its content, write 100-150 words of speaker notes. The tone should be conversational and engaging.

After the iterator finishes, you’ll have a complete set of data: slide titles, body content, and speaker notes, all neatly organized and ready for the final step.

Why Does My AI Slide Generator Produce Generic Content?

So you’ve built the system, but the output still feels a bit… bland. This is a common problem. The reason is that you haven’t given the AI enough context or constraints. A generic prompt yields a generic result. To get sharp, on-brand content, you need to inject your point of view directly into the prompts.

This is my favorite part of building custom AI systems. You can bake your brand directly into the machine. Here’s how:

• Enhance the System Prompts: Don’t just tell the agent *what* to do; tell it *how*. Add details about your company’s tone of voice. For example, change the Content Agent’s system prompt to: `You are a content writer for Acme Corp. Our tone is witty, direct, and slightly skeptical of industry jargon. Write 3-4 bullet points…`
• Provide Few-Shot Examples: LLMs are great at pattern recognition. You can include a high-quality example directly in the prompt to show the model exactly what you want. This is called few-shot prompting. In your prompt to the Content Agent, you could add: `Here is a good example. For the title ‘The Problem’, a good output would be: ‘- Most solutions are overpriced… – They lack customization… – Onboarding is a nightmare.’ Now, generate content for the title: [current slide title].`
• Create a ‘Brand Context’ Variable: Instead of hardcoding brand info in every prompt, create a global variable or text block in your Make.com scenario that contains your brand guide: key messages, target audience, specific terms to use or avoid. Then, append this context block to every prompt you send to the OpenAI API. This makes it easy to update your brand voice in one place.

Getting this right is an iterative process. You’ll run the generator, review the output, tweak a prompt, and run it again. But after a few cycles, you’ll have an AI agent framework that speaks your language.

Connecting to the Google Slides API: The Annoying Part

Getting the generated content into a Google Slides presentation is the final step, and honestly, it can be the most frustrating. It’s not the logic, but the setup.

My main gripe is with Google Cloud Platform’s interface for creating API credentials. It’s a confusing labyrinth of menus and jargon. You’ll need to create a project, enable the Google Slides API and Google Drive API, create an OAuth 2.0 consent screen, and then generate service account credentials. It’s a dozen steps, and the documentation is dense — and good luck finding clear docs for this —. It feels like it was designed by engineers for other engineers, with no thought given to a regular operator just trying to connect a service.

However, here’s the part I love: once you get through that authentication nightmare and plug the credentials into Make.com’s Google Slides module, the API itself is beautifully straightforward. The actions are logical: ‘Create a Presentation from a Template’, ‘Create a Slide’, ‘Insert Text’. You point the module to your template presentation (which should have your branding, fonts, and layouts), and it handles the rest. You map the data from your AI agents—`title` goes here, `body` goes there—and it just works.

This is a one-time pain for a long-term gain. Endure the GCP setup once, and you have a reliable production system forever.

How to Debug When This Breaks

Automation is great until it isn’t. This system has three main points of failure you’ll eventually encounter.

First, the OpenAI API might return invalid JSON. Even with strict instructions, models can sometimes add extra text or mess up a bracket. The ‘Parse JSON’ module in Make.com will throw an error. The fix is to add error handling. Make.com lets you add an ‘error handler’ route to your modules. On an error, you can have it try the OpenAI call again, or send you a notification so you can see the malformed output and adjust your prompt.

Second, you’ll hit API rate limits if you try to process a huge deck or run many jobs at once. Both OpenAI and Google have limits on how many requests you can make per minute. The solution in Make.com is to add a ‘Sleep’ module inside your iterator. A simple 1-2 second delay between each slide generation is usually enough to keep you under the free-tier limits.

Finally, your Google API authentication can expire. If you set up OAuth, the token might need to be manually refreshed every few months. Using a service account is more stable. If you suddenly start getting ‘permission denied’ errors from the Google Slides module, it’s almost always an authentication issue. Re-authorizing the connection in Make.com usually fixes it.

Building your own tools means you’re also the support team. Learning these common failure modes will save you hours of frustration.

For more on this exact angle, 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 pre-built AI automation blueprint. You can find it at deepusecase.com/vault.