How To Create PowerPoint With Claude

PowerPoint can consume hours of desk-based working time, and formatting takes most of those hours. Aligning boxes, resizing text and matching colours carries on long after the content itself is settled. Tools that pair AI and PowerPoint promise to remove that labour, and they do produce decks in minutes. The output rarely matches the brand it is meant to carry, though, so the deck gets rebuilt by hand and the saving disappears.

A different division of labour avoids this, and it needs only two ingredients. The person builds a branded template and writes the design rules once. Claude Code, Anthropic's agentic coding tool, then writes and runs a Python script that fills that template for every new deck.

The sections below cover the one-time setup, the repeatable workflow it enables, and the split between what the person does and what the AI does. They also cover how the method compares with Claude's built-in file creation and Microsoft's PowerPoint Copilot, and where it fails. Everything here comes from the working system behind GenAI Skills Academy lesson, workshop and video decks, in production since January 2026. The vendor claims reflect the documentation as it stood on 26 July 2026.

What this article covers

• Why AI and PowerPoint need a template and a script

• What you need

• The one-time setup

• The repeatable run

• How this compares with the alternatives

• Where the method fails

• Sources

Why AI and PowerPoint need a template and a script

Building a deck combines two different jobs, because deciding what the slides say is writing and analysis, while making them readable and on-brand is design. Large language models handle the writing job well when the source material is decent, and the design job is where generated decks go wrong. Decks generated from a blank prompt come back with text sliding under decorative boxes, dark text on dark backgrounds, and typefaces that change from slide to slide. Each one then needs a manual design pass before anyone can present it.

A template removes the design job from the AI entirely, because the colours, fonts and layouts live in the file itself, and the AI's work reduces to placing content into named boxes. A script makes that placement repeatable, because styling written as code produces the same result on every run.

Corrections accumulate under this method as well, because a fix written into the rules file applies to every future deck, and the checklist that results carries every repair forward into the next build.

What you need

• PowerPoint on the desktop. Used to build the template at the start and to review every finished deck.

• VS Code with Claude Code. Claude Code is Anthropic's agentic coding tool, and it writes and runs every script in this method.

• Python 3 with two libraries. python-pptx writes the slides and lxml handles the animations, both installed with the command below.

• One branded deck. An existing presentation that already looks right, which becomes the raw material for the template.

pip3 install python-pptx lxml

The person running this needs no Python, because Claude Code produces the code, runs it, and fixes it when it breaks.

The one-time setup

The setup consists of five steps, each done once, listed in the order the GenAI Skills Academy system came together. Every deck produced since January 2026 has reused them without repeating any of this work.

Step 1. Build a brand template in PowerPoint

Open an existing presentation that already looks the way it should, then switch to View and Slide Master. Strip the master back to the layouts a deck needs. Ten to fifteen layouts are enough, spanning title, contents, section dividers, content, quote and closing slides. Give each layout a number-prefixed name, because the script addresses layouts by position. The GenAI Skills Academy template carries nineteen, running from 0 Blue Red Main Title to 18 Thank You. Every one of them carries the brand fonts and colours, and the file saves as a .potx template.

Although there are 18 individual slide templates in this master template, any given slide deck may only use perhaps six in a presentation. Some slide template are always used, such as the cover slide, the agenda slide, the above slide, and the thank you slide at the end. The objective is to keep things as simple as possible while getting what you want in the output. Once you provide explicit instructions and guide guidelines than the AI should be able to create what you need based on the template.

PowerPoint Slide Master view with the numbered layout list down the left side.

Step 2. Convert the template for the script

The python-pptx library reads .pptx files and cannot open .potx templates, so the template needs a one-time conversion. The command below unzips the template, patches one content-type string, and rezips it as a working .pptx file. Claude Code runs it when asked.

mkdir -p template_converted && \
unzip -o "your-template.potx" -d template_converted && \
sed -i '' 's/presentationml.template.main+xml/presentationml.presentation.main+xml/g' template_converted/\[Content_Types\].xml && \
cd template_converted && zip -r ../template_fixed.pptx .

Step 3. Ask Claude to map the template

Every template numbers its layouts and placeholders differently, and the script needs those numbers. Asking Claude Code to analyse the converted file produces a map of every layout and placeholder index inside it. The map lives in a reference file, which the script reads on every build. An excerpt from the GenAI Skills Academy map shows the shape of it.

Layout 0   Blue Red Main Title   placeholders 0, 1
Layout 2   Pale Menu             placeholders 0, 1
Layout 13  White Content         placeholders 0, 1, 13
Layout 15  Pale Quote            placeholders 0, 1
Layout 18  Thank You             placeholders 0, 1, 13

A script that writes the title into placeholder 1 when the title lives in placeholder 0 fails on every slide, so mapping the template once removes that whole category of error.

Layout map reference file open in a VS Code editor pane

Step 4. Write the design rules down

The template carries the layouts, and a rules file carries everything else. The GenAI Skills Academy rules specify the typography exactly. Titles run at 28pt in upper case, subtitles at 24pt bold, body text at 22pt and quotes at 36pt italic. Text colour follows the background, so pale slides carry blue text and blue slides carry white. The brand's pink, #CC2157, has a defined job on bullet arrows, hyperlinks and the thin underline beneath every slide title.

White space gets rules of its own, because nothing in a bare template stops a build from overfilling each slide. Four bullets per slide is the ceiling, and each bullet stays within ten to twelve words. Every content slide opens with an intro paragraph of one or two sentences before the bullets begin. The script checks these caps on every build, which keeps a fifty-slide deck consistent from first to last.

Step 5. Turn corrections into permanent rules

No first run is perfect, and the value of the method shows in what happens to the fixes. Each one becomes a line in a checklist that Claude Code loads before every build. The checklist sits in a skill file alongside the layout map and the design rules.

The GenAI Skills Academy checklist is a record of everything that has gone wrong since January 2026. Arrow bullets once rendered as empty squares because the bullet character needed the Wingdings font. Quote slides came out at 24pt until a rule pinned them at 36pt, and fixed slides received duplicate animations. Tables refused to animate at all, and long code boxes ran off the bottom edge until pagination logic arrived in May 2026 to split them across slides. Each of those failures happened once, and the checklist line that followed stopped it recurring.

The repeatable run

With the setup in place, producing a deck becomes a request and a review, and a request looks like this.

Create workshop slides for the 16 January Claude Cowork workshop.
The source content is in outline.md. Save the deck to the workshop folder.

Four decisions stay with the person, and each one shapes the deck more than the script does.

• Choose the deck type. Lessons, workshops and videos each follow a different structure file, and naming the type picks the structure.

• Supply the source content. An outline, a transcript or a brief, and the finished deck can only be as good as this input.

• Review the finished file. Open the deck in PowerPoint, read it as the audience will, and send back corrections.

• Promote recurring fixes. When the same correction comes up twice, ask Claude to write it into the rules.

Claude Code then carries out the same sequence on every build.

• Load the rules. It reads the skill file, the structure reference for the deck type, and the layout map before writing any code.

• Plan the deck. It works out the section count and slide count from the source content.

• Write and run the build script. A Python script populates the template's placeholders with the planned content.

• Check and save. It runs the checklist against the output and saves the file under a dated name in the agreed folder.

Builds run as short, self-contained sessions, and the settings in the Claude Code token usage guide keep them cheap to repeat. Diagrams follow the same principle, because a separate module renders content boxes and flow charts in the house style from a plain description, and the finished image drops straight onto a slide.

Finished content slide with the pink title underline, pink arrow bullets and intro paragraph.

Finished diagram slide produced by the diagrams module in the house style

How this compares with the alternatives

Three alternatives exist as of 26 July 2026, each checked against the vendor's own pages.

• Claude's built-in file creation. Claude creates PowerPoint files directly in claude.ai and the desktop app, on Max, Team and Enterprise plans with Pro to follow. Every deck it makes is a fresh design pass, so the model chooses styling anew each time and has never seen your brand.

• Microsoft 365 Copilot in PowerPoint. Copilot generates presentations from a prompt and can reference an organisation's own templates and brand kit. The feature needs a Microsoft 365 Copilot work licence. Of the three it comes nearest to the method described here, though the generation logic lives in Microsoft's cloud.

• Dedicated generators. Gamma, Beautiful.ai and similar tools produce decks quickly on their own platforms, each with its own subscription and its own storage.

The script route runs on the local machine against local files, with no added subscription and no upload of company material. Its output is a native .pptx file that opens in PowerPoint like any other deck, and the rules file it reads stays yours to edit.

Where the method fails

Vendor pages describe tools at their best, so this section records where the method stops working, in two categories. The first covers what the system cannot do at all, and the second covers what it attempts and gets wrong while the output still looks finished.

Hard limits

• The template format. python-pptx cannot open .potx files, so the conversion step in the setup is unavoidable.

• No eyes on the render. The script places content by coordinates and never sees the finished slide, which is why review in PowerPoint stays mandatory on every deck.

• Fonts travel by name. A machine without Aptos Display or Wingdings installed substitutes its own fonts, and the arrow bullets render as empty squares.

• Animations. These require editing the file's raw XML through the lxml library, and they have caused more breakage than any other part of the system.

What it does badly

• Thin source material. The method formats content and cannot improve it, so a weak outline becomes a weak deck that looks polished, and the polish makes the weakness harder to spot.

• Content without a rule. Long code boxes and file trees ran off the slide edge for months before pagination logic existed. Any new content type carries the same risk until a rule covers it.

• Anything outside the template. A slide type the template lacks sends the AI back to inventing design on the spot. That is the failure the whole method exists to remove.

Setup happens once, and each deck afterwards costs a request and a review, with the formatting labour gone. Everything the script cannot judge stays with the person, meaning the quality of the source material, the sense-check of the finished deck, and the call on which corrections become rules.