How to Build a Slides AI Generator That Actually Works

You Need a Presentation in an Hour. Now What?

The client meeting is booked. The topic is set. You have nothing. The old way was to stare at a blank PowerPoint, drink bitter coffee, and slowly assemble a deck over three hours. The new way, supposedly, is to use a dedicated slides AI generator. The problem is, most of them are toys. They produce generic, fluffy content that looks like it was written by a marketing intern from 2019. They’re fine for a book report, but not for a client who pays your bills.

This is an operator playbook for building your own presentation engine. A system that takes a single topic and outputs a complete, custom, and useful slide deck in Google Slides—speaker notes and all. No fluff. We’ll use no-code tools, so you don’t need to be a developer. After reading this, you’ll understand the actual logic required to make this work reliably.

The Core Logic: From Topic to Structured JSON

This isn’t about one magic prompt. That’s the biggest lie in AI automation. A single prompt is too fragile and produces inconsistent results. The foundation of a real slides ai generator is a chain of smaller, specialized API calls orchestrated by a workflow tool. The goal isn’t to get a finished slide deck from the AI in one go. The goal is to get perfectly structured JSON that a dumber, non-AI module can use to build the deck.

The flow looks like this:

1. You provide a topic: e.g., “A pitch for using thermal cameras to monitor warehouse efficiency.”
2. LLM Call #1 (The Architect): This AI’s only job is to create an outline. It doesn’t write content. It just decides the structure and returns it as a JSON array.
3. Looping LLM Call #2 (The Writer): For each point in the outline, a second AI call writes the actual slide content. Its prompt is hyper-focused: “Write the body content for a slide titled ‘{Slide Title}’. The overall topic is ‘{Original Topic}’. Be concise. Use bullet points.”
4. API Call to Google Slides (The Builder): A non-AI module reads the structured JSON and creates the slides one by one using the Google Slides API.

The key is that structured data—JSON—is passed between each step. The AI’s creative, messy job is separated from the mechanical job of building the presentation. This separation is what makes the system reliable.

What Most Guides Get Wrong

Most tutorials you find will show you a single, massive prompt. Something like: “You are a presentation expert. Create a 10-slide presentation about warehouse efficiency using thermal cameras. Include a title, body, and speaker notes for each slide. Format it perfectly.”

This will fail. I guarantee it.

The model will forget instructions halfway through, mix up slide content, or return a big wall of text that isn’t machine-readable. It’s not a reliable process for an automation. You’re asking one generalist AI to be an expert outline creator, a compelling copywriter, and a perfect data formatter all at once. It can’t do it.

The correct approach is to treat it like an assembly line. An AI agent framework, even a simple one, is the way to go. Each step has one job. The Architect agent only builds the blueprint (the outline). The Writer agent only lays the bricks (the content for each slide). This modularity means you can swap out models, tweak prompts for one part without breaking the others, and debug the system effectively. If the outlines are weak, you only need to fix the Architect’s prompt. If the content is rambling, you only tune the Writer. It’s a proper system, not a hopeful magic trick.

Is the No-Code Stack Actually Usable?

Yes, but you have to pick the right tools and know their limits. For the orchestration layer, I use Make.com. It’s more visual and, in my opinion, better for complex branching logic than Zapier. The free tier is a joke for anything serious, but the Core plan at $9/month is honestly a bargain for what it lets you do. It’s more than enough for this kind of workflow.

For the intelligence, the OpenAI API is the standard choice. You’ll want to use a model that’s good at following instructions and outputting JSON, like GPT-4o. The cost is negligible for this use case—we’re talking pennies per presentation.

The final piece is the Google Slides API. And this is my concrete gripe: the authentication is a pain. Setting up a service account, getting the right OAuth2 scopes, and generating a key file is not intuitive. It’s a full afternoon of frustration, toggling between the Google Cloud Console and Stack Overflow—and good luck finding clear docs. Once it’s set up, it’s rock-solid, but the initial hurdle is steep for a non-developer.

So, is it usable? Absolutely. It’s a powerful no-code AI stack. Just be prepared to wrestle with Google’s permissions for a bit.

Handling Images and Layouts

This is where the dream of a fully automated designer hits a wall. You can’t just tell the AI to “make it look good.” Layouts have to be predefined.

My method is to create a master template in Google Slides. This template has a few pre-designed slide layouts: ‘Title Slide’, ‘Title and Content’, ‘Section Header’, ‘Image Left, Text Right’. In your Make.com scenario, the Architect LLM’s job includes suggesting a layout for each slide in its JSON output.

{ "slides": [ { "title": "The Problem: Hidden Inefficiencies", "layout": "Title and Content", "image_prompt": null }, { "title": "Our Solution: Thermal Vision", "layout": "Image Left, Text Right", "image_prompt": "A futuristic thermal camera view of a busy warehouse with color-coded heat signatures." } ] }

Then, the automation can pipe the `image_prompt` to an image generation API like one from Midjourney or Stability AI. The generated image URL is then passed to the Google Slides API along with the chosen layout. It works, but it’s not perfect. The layouts are rigid. You won’t get a beautiful, bespoke design every time. You’ll get a consistent, branded, and *fast* presentation. For most internal drafts or quick client updates, that’s a massive win.

How to Debug When This Breaks

And it will break. Your slides ai generator is a chain of services, and any link can fail. Here are the three most common failures and how to fix them.

1. The LLM Returns Bad JSON: Sometimes, despite your best prompting, the AI will return a malformed JSON string (a missing comma, an extra bracket). Your workflow will halt. The fix in Make.com is to add an ‘Error Handler’ route to your OpenAI module. If the JSON parsing fails, the error handler sends the broken output back to the LLM with a simple prompt: “Fix the following broken JSON. Only return the corrected JSON object. Do not add any commentary. Here is the broken JSON: {output}”. This works surprisingly often.
2. Google API Authentication Fails: Your access token will expire. It’s inevitable. In Make.com, the Google Slides module will throw a specific authentication error. The best practice is to build a separate, scheduled scenario that runs once a week to refresh the token automatically, storing the new one in a Data Store that your main scenario can access.
3. Image Generation Times Out: Image models can be slow. If your workflow doesn’t wait long enough, it will fail. Increase the timeout limit in your HTTP module settings in Make.com to at least 120 seconds. Also, add an error path that either retries the generation once or simply proceeds to create the slide without an image, logging the failure so you can fix it manually.

My Favorite Part: The Speaker Notes Generator

This was the addition that made the whole system click for me. After the slide content (the title and body) is finalized for a single slide, I added one more LLM call. It’s a tiny, specialized agent I call The Coach.

Its prompt is simple: “You are a presentation coach. Given the slide title ‘{Slide Title}’ and its content ‘{Slide Content}’, write detailed speaker notes. Include a key talking point, a potential audience question, and a brief anecdote or statistic to make the point memorable.”

This is my concrete love for this system. It takes maybe five extra seconds per slide, but the output is incredible. It transforms a simple deck into a fully-prepped presentation. It forces me to think through the narrative and anticipates audience reactions. It’s the difference between a collection of facts and a real story. This single step saves me an hour of prep time for every single deck I generate.

This is the power of building your own AI systems. You can add these small, high-value touches that off-the-shelf products would never think of.

You can absolutely build this entire workflow yourself using the components and logic I’ve laid out. It’s a fantastic project for anyone looking to go beyond basic ChatGPT prompts and build a real AI automation blueprint.

Adjacent reading: 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 production-ready blueprint at deepusecase.com/vault.