Using IronPPT with AI Coding Assistants

Name: IronPPT
Brand: Iron Software
Availability: InStock
Rating: 5 (10 reviews)

Updated: October 19, 2026

IronPPT is Iron Software's PowerPoint library for .NET. It creates, opens and edits PPTX presentations from C# code without Microsoft Office or Interop, and a single package covers every platform that runs .NET Standard 2.0.

A quarterly review deck, a set of course handouts or a property listing all depend on the same few operations, which are adding slides, placing text and images on them, and changing the order before the file is sent. An assistant without IronPPT's documentation has no list of the members that exist, and one of IronPPT's own guide samples compiles and runs but leaves the saved deck unchanged.

The setup process is the same for every assistant. Add the package, assign the key from the environment, provide the assistant with IronPPT's machine-readable documentation, and read every saved deck back before marking the task complete. This applies to adding slides, adding text, managing images, and managing slides.

How to Use IronPPT with an AI Coding Assistant

Download the C# PowerPoint library from NuGet
Assign IronPPT.License.LicenseKey from IRONPPT_LICENSE_KEY at startup
Give the assistant IronPPT's llms.txt index before it writes code
Record the IronPPT rules in the instruction file your assistant loads
Use the slide a new deck already holds, then add the rest in their final order
Check every saved deck's slide XML against the request

Can't My AI Assistant Handle PowerPoint on Its Own?

Without a presentation library, .NET code can write PowerPoint files through the Open XML SDK, which builds a presentation part by part and links the parts through relationships.

IronPPT wraps that package structure in a small object model whose main types are PresentationDocument and Slide.

Three facts apply before the first prompt.

A call with no effect raises no error: only a read of the saved file shows the missing change, and IronPPT performs that read when it opens the deck again from its path.
One name for the package and the namespace: both are IronPPT. Attackers register malicious packages under names that assistants recommend for packages that do not exist, a practice called slopsquatting, so include the exact name in the prompt.
The license is perpetual: an IronPPT license is a one-time purchase with no renewal fees, and the licensing page lists the number of developers each tier allows.

Step 1: Install IronPPT

With the package referenced, the assistant uses the types that IronPPT provides.

Install IronPPT 2026.10.1 from NuGet and restore the project.
Tell me the IronPPT version it references afterwards.

Install IronPPT 2026.10.1 from NuGet and restore the project.
Tell me the IronPPT version it references afterwards.

Text

From a terminal, pin the release explicitly.

dotnet add package IronPPT --version 2026.10.1

dotnet add package IronPPT --version 2026.10.1

SHELL

The package contains no native binaries, and its only dependencies are IronSoftware.Common and IronSoftware.System.Drawing.

Step 2: Apply Your License Key

Without a key, a program can build a deck in memory and open an existing file, but every call to Save fails with IronSoftware.Exceptions.LicensingException and the message Production License Required. The message also mentions seven days of free development use, yet the save failed on the first attempt in the probe for this article. A mistyped key causes License Key Not Recognized instead, and the rest of that message repeats the key. A short key appeared in full, and a full-length key with one character changed appeared as its final 32 characters. Code that logs exception messages therefore writes key material to its log. A free trial key is available below.

Start using IronPPT in your project today with a free trial.

First Step:

Assign the license key once at application startup, before any IronPPT calls. Retrieve it from an environment variable so it is not stored in the repository.

IronPPT.License.LicenseKey = Environment.GetEnvironmentVariable("IRONPPT_LICENSE_KEY");

IronPPT.License.LicenseKey = Environment.GetEnvironmentVariable("IRONPPT_LICENSE_KEY");

IronPPT.License.IsLicensed is set to true after a valid key is assigned, and IronPPT.License.IsValidLicense reports whether a key string is valid. Without the assignment above, IronPPT ignores IRONPPT_LICENSE_KEY. It does read environment variables named IronPPT.LicenseKey and IRONPPT_LICENSEKEY with no code at all.

Please note: IronPPT License Keys also explains how to set the key in appsettings.json.

Step 3: Point Your Assistant at IronPPT's LLM Documentation

llms.txt contains a one-line entry for each of its 15 pages.
llms-full.txt provides a summary of each of the 16 documentation pages in a single file.
llms-full-catalog.txt extends the index by including blog articles.
The API Reference lists the signature of each member.
Tools that support skill files can use skill.md, which covers setup, licensing, recipes, and common errors.
The AI Product Fact Sheet outlines supported platforms and primary use cases.

Provide the index at the start of every session.

Open https://ironsoftware.com/ppt/csharp/llms.txt before you write more IronPPT code.
Keep to what its linked pages document.

The IronPPT object model works like this:
- PresentationDocument is the deck, and a new one already holds one blank slide.
- AddSlide appends a Slide.
- Slide.AddText, Slide.AddParagraph and Slide.AddImage fill a slide.
- Slide.Remove deletes a slide, and setting Slide.Show to false hides it.
- Save writes the .pptx file, and the constructor that takes a path opens one.

For a member those pages leave out, do this:
1. Search https://ironsoftware.com/ppt/csharp/object-reference/api/ for it.
2. Build once to prove it compiles.
3. If you still can't confirm it, say so instead of guessing.

After that, list the IronPPT calls in this project that the docs don't cover.

Open https://ironsoftware.com/ppt/csharp/llms.txt before you write more IronPPT code.
Keep to what its linked pages document.

The IronPPT object model works like this:
- PresentationDocument is the deck, and a new one already holds one blank slide.
- AddSlide appends a Slide.
- Slide.AddText, Slide.AddParagraph and Slide.AddImage fill a slide.
- Slide.Remove deletes a slide, and setting Slide.Show to false hides it.
- Save writes the .pptx file, and the constructor that takes a path opens one.

For a member those pages leave out, do this:
1. Search https://ironsoftware.com/ppt/csharp/object-reference/api/ for it.
2. Build once to prove it compiles.
3. If you still can't confirm it, say so instead of guessing.

After that, list the IronPPT calls in this project that the docs don't cover.

Text

Permission to answer "not documented" gives the assistant an option other than inventing a method.

Step 4: Add IronPPT Context to Your Project

Store the IronPPT rules in a project instruction file so that every new session can read them. Claude Code reads CLAUDE.md, ChatGPT Codex reads AGENTS.md, GitHub Copilot reads .github/copilot-instructions.md, Cursor reads .mdc files in .cursor/rules/ or AGENTS.md, and Google Antigravity reads AGENTS.md or GEMINI.md. A single block of text is compatible with all, though Cursor rule files also include MDC frontmatter. Begin with the following.

Every deck in this project is built with IronPPT, under these rules:
- `IronPPT` is both the NuGet package name and the namespace.
- Begin with the llms.txt index, https://ironsoftware.com/ppt/csharp/llms.txt.
- Tools that read skill files load https://ironsoftware.com/ppt/csharp/skill.md.
- Set `IronPPT.License.LicenseKey` from IRONPPT_LICENSE_KEY when the app starts.
- The program reads that variable itself and never lists environment variables.
- Keep the key out of output, logs, exception text, and source control.
- A wrong key's `LicensingException` message repeats the key. Log only its first line.
- A new `PresentationDocument` already has one slide. Use `Slides[0]` as the title slide.
- Add text, paragraphs, and images through `Slide` methods.
- Build slides in their final order, or set `Slide.Index` to move one.
- Edits to the `Slides` list do not change the deck.
- Remove a slide with `Slide.Remove()` and hide one with `Show = false`.
- On a deck opened from disk, replace a picture by removing it and adding the new image.
- Do not add the Open XML SDK or another presentation library.
- When IronPPT lacks a feature, report that rather than working around it.

Every deck in this project is built with IronPPT, under these rules:
- `IronPPT` is both the NuGet package name and the namespace.
- Begin with the llms.txt index, https://ironsoftware.com/ppt/csharp/llms.txt.
- Tools that read skill files load https://ironsoftware.com/ppt/csharp/skill.md.
- Set `IronPPT.License.LicenseKey` from IRONPPT_LICENSE_KEY when the app starts.
- The program reads that variable itself and never lists environment variables.
- Keep the key out of output, logs, exception text, and source control.
- A wrong key's `LicensingException` message repeats the key. Log only its first line.
- A new `PresentationDocument` already has one slide. Use `Slides[0]` as the title slide.
- Add text, paragraphs, and images through `Slide` methods.
- Build slides in their final order, or set `Slide.Index` to move one.
- Edits to the `Slides` list do not change the deck.
- Remove a slide with `Slide.Remove()` and hide one with `Show = false`.
- On a deck opened from disk, replace a picture by removing it and adding the new image.
- Do not add the Open XML SDK or another presentation library.
- When IronPPT lacks a feature, report that rather than working around it.

Markdown

The skill file names IronPPT 2026.8.1 as the release it was tested against, and its single-file example pins that release. It also describes Slides as a list that can be edited to reorder slides and promises a seven-day development period before Save requires a key. The probes for 2026.10.1 contradicted both statements.

Step 5: One-Shot Setup Prompt

Steps 1 to 4 can be sent together as one message at the start of a project or session.

Set this project up for PowerPoint work with IronPPT, following these rules:
- Reference the IronPPT package at version 2026.10.1.
- Assign IRONPPT_LICENSE_KEY to IronPPT.License.LicenseKey first thing at startup.
- The code reads that variable itself. Don't list environment variables.
- The key never shows up in the console, a log, or a committed file.
- Before coding, go through https://ironsoftware.com/ppt/csharp/llms.txt, then keep to it.
- Look up anything it doesn't cover at https://ironsoftware.com/ppt/csharp/object-reference/api/.
- Compile before relying on a member found there.
- Load https://ironsoftware.com/ppt/csharp/skill.md if the tool accepts skill files.
- When the skill file and the compiler disagree, believe the compiler.
- Put content on slides with Slide methods, not with PresentationDocument.AddText.
- Create the slides in their final order, since editing the Slides list changes nothing.

Save these rules to the instructions file your next sessions read.
Tell me which file you wrote and what else you changed.

Set this project up for PowerPoint work with IronPPT, following these rules:
- Reference the IronPPT package at version 2026.10.1.
- Assign IRONPPT_LICENSE_KEY to IronPPT.License.LicenseKey first thing at startup.
- The code reads that variable itself. Don't list environment variables.
- The key never shows up in the console, a log, or a committed file.
- Before coding, go through https://ironsoftware.com/ppt/csharp/llms.txt, then keep to it.
- Look up anything it doesn't cover at https://ironsoftware.com/ppt/csharp/object-reference/api/.
- Compile before relying on a member found there.
- Load https://ironsoftware.com/ppt/csharp/skill.md if the tool accepts skill files.
- When the skill file and the compiler disagree, believe the compiler.
- Put content on slides with Slide methods, not with PresentationDocument.AddText.
- Create the slides in their final order, since editing the Slides list changes nothing.

Save these rules to the instructions file your next sessions read.
Tell me which file you wrote and what else you changed.

Text

Step 6: Prompt Patterns That Produce Working Code

Specify the slides, their order, and the content of each.

Vague Make a quarterly deck with IronPPT.

Better Use Slides[0] for the title, then add one slide per region in revenue order, each with a bold 32 point heading and three paragraphs, and save quarterly.pptx.

State the IronPPT release and the target framework. Members can change between releases.

Better Use IronPPT 2026.10.1 on .NET 9, and assign the key from IRONPPT_LICENSE_KEY before the first IronPPT call.

Request complete files. A snippet can omit the using IronPPT.Models; directive, which provides Slide, Text, and Image.

Better Return the whole Program.cs, with its using directives and the license line, ready to build as is.

Step 7: Verify What You Get Back

Each of the following mistakes is reproducible in 2026.10.1.

Adding the title slide with AddSlide: each new PresentationDocument holds one slide from the start, built on the title layout. A program that adds its own title slide saves a deck that opens on a blank slide. Write the title on Slides[0], or add every slide first and then remove the original, because removing a deck's last slide throws InvalidOperationException.
Adding text through the document: PresentationDocument.AddText attached its text to the final paragraph on the last slide, and PresentationDocument.AddTextBox created a new slide for the text box. Add content through Slide methods.
Styling the result of AddText with a string argument: the returned text has no style object, so setting a property on it throws NullReferenceException. The skill file's styling recipe makes that call. Assign a new TextStyle instead.
Choosing a font with FontFamily: the saved run carried no typeface. LatinFont wrote the typeface into the file.

A deck reopened with IronPPT returns its slide count and text correctly. Read position, size, alignment and color from the slide XML in ppt/slides/slideN.xml. After a reload, IronPPT reported centered text as Left, and a probe read the hex colors #C00000 and #FFC000 back as #00000000. Position, size and font size came back on the EMU scale described under text and image output.

Let the Agent Verify Its Own Work

The assistant can run these checks itself and present the results.

Do a clean Release build and run the app once more.

Then show me the evidence:
- The IronPPT types and members the code calls, each with its documentation page.
- The value of IronPPT.License.IsLicensed.
- Each saved deck's slide count and every slide's first line of text, read back from the file.
- Any hidden slide.
- Every shape's a:off, a:ext, algn and solidFill values, taken from ppt/slides/slideN.xml.
- Any image or text whose position, size, alignment or color differs from what the code set.

Read those four properties from the XML, never from a deck reopened with IronPPT.
End by saying whether each deck matches what the code meant to build.

Do a clean Release build and run the app once more.

Then show me the evidence:
- The IronPPT types and members the code calls, each with its documentation page.
- The value of IronPPT.License.IsLicensed.
- Each saved deck's slide count and every slide's first line of text, read back from the file.
- Any hidden slide.
- Every shape's a:off, a:ext, algn and solidFill values, taken from ppt/slides/slideN.xml.
- Any image or text whose position, size, alignment or color differs from what the code set.

Read those four properties from the XML, never from a deck reopened with IronPPT.
End by saying whether each deck matches what the code meant to build.

Text

Slide editing with IronPPT

Slide order, removal, and image replacement behave differently from what the manage slide guide and the manage image guide show. The probes for this article saved each change and read the PPTX parts back.

PresentationDocument.Slides returns a new list on each call. Remove, Insert, RemoveAt, and Add on that list changed nothing in the saved deck, so the guide's reorder sample leaves the order as it was.
Slide.Remove() deleted the slide, both in memory and after the deck was loaded from a file.
Setting Show to false kept the slide in the file and marked it hidden.
Slide.Clone() threw MissingMethodException, so a slide cannot be duplicated.
Adding a removed slide back with AddSlide produced a blank slide.
Setting Slide.Index moved a slide, both in a new deck and in one opened from disk, and the saved file kept the new order.
Slide.Images holds IImage values, so the guide's Images[0].Replace(image) call binds to the general element Replace method. That call replaced the picture in a deck built in memory and left the old picture in a deck opened from disk.
Casting the picture to Image reaches Image.Replace, which worked in a reopened deck and threw NullReferenceException in an in-memory deck.
Removing the picture and adding the new image with AddImage worked in both cases, though the saved package kept the old image as an unused media part.

Text and image output with IronPPT

The saved slide XML and the Open XML SDK 3.5.1 validator gave the following results.

Each Slide.AddText call created its own 150 by 100 point text shape and set no position, so the shape inherits its placement from the slide layout.
AddParagraph added its paragraph to the slide's last text shape.
The first slide of a new deck kept empty title and subtitle placeholders beside the text that AddText added.
Image Position, Width, and Height are in points. A 400 by 200 pixel PNG with no resolution set, added with no size, became 300 by 150 points, its pixel size at 96 DPI.
In a reopened deck, the same properties returned the stored EMU figures as points, 12,700 times the values that were set.
FontSize with Point set to 32 wrote a 32 point size, and IsBold wrote bold.
Every run colored through TextStyle.Color failed validation with an invalid child element error, for named and hexadecimal colors alike. Decks without colored text validated with no errors.

A Result You Can Reproduce

The test consists of one prompt, and you write none of the code. Open a new session in an empty folder, paste the prompt, and compare the outcome with the pass criteria.

Please note: The test requires the .NET 9 SDK, a network connection, an assistant that can run terminal commands, and an IronPPT trial or production key in IRONPPT_LICENSE_KEY.

The prompt

Create a .NET 9 console app that builds a quarterly regional deck with IronPPT.
If this directory isn't empty, tell me and stop.
Don't ask questions. Note your choice for each missing detail.
Keep every deliverable in this directory.

Work in this order:
1. Add IronPPT 2026.10.1 from NuGet.
2. Study https://ironsoftware.com/ppt/csharp/llms.txt, its license key page and four how-to guides.
3. Follow these code rules:
- Use only members those pages or the API reference document.
- At startup, the program itself assigns IRONPPT_LICENSE_KEY to IronPPT.License.LicenseKey.
- Never print the key, save it, or list environment variables.
- Stop with a message if IronPPT.License.IsLicensed is false.
- Print only the first line of a licensing error from Save.
4. Before building slides, the code writes qbr-data.json in thousands of dollars:
- Revenue/target: North 1240/1100, South 860/950, East 1410/1300, West 720/900.
- Three commentary lines of your own per region, under 60 characters each.
5. Draw each region's revenue and target as an 800 by 400 pixel PNG bar chart:
- Save charts/<region>.png and a grey background copy, charts/<region>-board.png.
- Encode the PNGs yourself, with no package or imaging library.
6. Build qbr.pptx with these seven slides in order, none blank:
- Title: "Quarterly Business Review" in bold 40 point, "Q3 2026" in 24 point.
- A slide headed "Agenda" listing the four regions.
- One slide per region, highest revenue first.
- A last slide headed "Next steps" with a "South: 90K below target" line per region below target.

Each region slide has:
- Its name as a bold 32 point heading, then one paragraph per commentary line.
- "Revenue 1410K against a target of 1300K" with its figures.
- That line in Color.Green if the target is met, otherwise Color.Red.
- Its chart at x 360, y 140, 320 by 160, all in points.
7. Reopen qbr.pptx from disk and save a board version, qbr-board.pptx, like this:
- Drop the agenda slide.
- Hide "Next steps" without removing it.
- Move the region with the largest shortfall right after the title.
- Swap that region's chart for its -board.png.
- Keep the rest in original order.
- Work around and note any change the save loses.
- As a last resort, rebuild from your data in the new order.
8. Build and run in Release.

The app fills readback.md only from both saved decks, reopened with IronPPT:
- A table per deck of each slide's position, first text line, visibility and image count.
- A section on each step where the guides' approach didn't work.

Its checks give expected, actual and match for both decks:
- Slide count and region order.
- Revenue line color, chart position and size per region slide.
- The board deck's moved region chart against its -board.png, by image bytes.
9. Fix each failed check and rerun, or describe an IronPPT cause nothing gets around and move on.
10. Report the Release build result, checks matched out of total, and your assumptions.

Create a .NET 9 console app that builds a quarterly regional deck with IronPPT.
If this directory isn't empty, tell me and stop.
Don't ask questions. Note your choice for each missing detail.
Keep every deliverable in this directory.

Work in this order:
1. Add IronPPT 2026.10.1 from NuGet.
2. Study https://ironsoftware.com/ppt/csharp/llms.txt, its license key page and four how-to guides.
3. Follow these code rules:
- Use only members those pages or the API reference document.
- At startup, the program itself assigns IRONPPT_LICENSE_KEY to IronPPT.License.LicenseKey.
- Never print the key, save it, or list environment variables.
- Stop with a message if IronPPT.License.IsLicensed is false.
- Print only the first line of a licensing error from Save.
4. Before building slides, the code writes qbr-data.json in thousands of dollars:
- Revenue/target: North 1240/1100, South 860/950, East 1410/1300, West 720/900.
- Three commentary lines of your own per region, under 60 characters each.
5. Draw each region's revenue and target as an 800 by 400 pixel PNG bar chart:
- Save charts/<region>.png and a grey background copy, charts/<region>-board.png.
- Encode the PNGs yourself, with no package or imaging library.
6. Build qbr.pptx with these seven slides in order, none blank:
- Title: "Quarterly Business Review" in bold 40 point, "Q3 2026" in 24 point.
- A slide headed "Agenda" listing the four regions.
- One slide per region, highest revenue first.
- A last slide headed "Next steps" with a "South: 90K below target" line per region below target.

Each region slide has:
- Its name as a bold 32 point heading, then one paragraph per commentary line.
- "Revenue 1410K against a target of 1300K" with its figures.
- That line in Color.Green if the target is met, otherwise Color.Red.
- Its chart at x 360, y 140, 320 by 160, all in points.
7. Reopen qbr.pptx from disk and save a board version, qbr-board.pptx, like this:
- Drop the agenda slide.
- Hide "Next steps" without removing it.
- Move the region with the largest shortfall right after the title.
- Swap that region's chart for its -board.png.
- Keep the rest in original order.
- Work around and note any change the save loses.
- As a last resort, rebuild from your data in the new order.
8. Build and run in Release.

The app fills readback.md only from both saved decks, reopened with IronPPT:
- A table per deck of each slide's position, first text line, visibility and image count.
- A section on each step where the guides' approach didn't work.

Its checks give expected, actual and match for both decks:
- Slide count and region order.
- Revenue line color, chart position and size per region slide.
- The board deck's moved region chart against its -board.png, by image bytes.
9. Fix each failed check and rerun, or describe an IronPPT cause nothing gets around and move on.
10. Report the Release build result, checks matched out of total, and your assumptions.

Text

Output

The app's unedited readback.md lists its slide tables and checks, and both decks are available as the app saved them, qbr.pptx and qbr-board.pptx. The figures below come from an independent reading of the saved PPTX parts.

Bar chart of West region revenue against target, drawn by the generated app

The grey board version of the West chart, as the app drew it with its own PNG encoder and placed it in qbr-board.pptx, unedited.

A Release build for net9.0 completed with no warnings and no errors.
qbr.pptx held seven slides in the requested order, and none of them was blank.
The app removed the slide a new deck starts with by calling Remove on it, after the guide's list call had no effect.
Every region heading was bold at 32 points.
The revenue lines were green for North and East and red for South and West.
All eight region slides in the two decks placed the chart at x 360 and y 140 points, sized 320 by 160 points.
qbr-board.pptx held six slides, with West, 180K below target, directly after the title.
Only the Next steps slide was hidden in the board deck.
The app built the board deck from qbr.pptx as opened from disk and moved West by setting the Index property of its slide.
The West slide in the board deck carried the exact bytes of the chart PNG that the app wrote.
The app's readback matched 22 of 22 checks.
The independent reading matched all 60 of its checks.
The Open XML SDK validator reported six errors in each deck, one for each colored run.
No file in the project folder, its Git history or the Claude Code session files contained the license key.
The setup prompt wrote its eleven rules to a new CLAUDE.md and installed skill.md as a project skill.
Some steps ran differently from the page. The Step 1, 3, 5, and 7 prompts ran after the acceptance prompt in the same session.

What passes

A Release build completes without any manual edits.
qbr.pptx has seven slides in the order that step 6 sets, none of them blank, when you read the file yourself.
Each region slide holds its heading, three commentary paragraphs, the revenue line, and one chart at the requested position and size.
qbr-board.pptx has six slides, with the region that missed its target by the most right after the title and the Next steps slide hidden.
readback.md takes every actual value from the saved decks and names each step that needed a different approach.
A search of the project folder finds no file that contains the license key.

Please note: To test a different release, edit the version in step 1 and review the IronPPT changelog for changes.

The run record

All runs used one Windows 11 x64 desktop with a Core i9-14900KF and 64 GB of memory.
This guide's project targets net9.0 and pins IronPPT 2026.10.1.
A guide's duration is the sum of the logged times for the prompts on its page, and this guide's row counts only the acceptance prompt.
Last tested October 16, 2026, for every guide in the table.

Guide	Assistant and version	Model	Duration (minutes)
This guide	Claude Code 2.1.277, one session, permission prompts off	Claude Opus 5	18.2
Claude Code	Claude Code 2.1.277, prompt 3 in plan mode	Sonnet 5 with Opus 5 planning	33.3
ChatGPT Codex	Codex CLI 0.160.0	GPT-6 Luna	22.2
GitHub Copilot	Copilot CLI 1.0.98, prompt 3 in plan mode, the issue body and the review in their own sessions	GPT-6 Luna, picked by Auto	16.1
Cursor	Cursor CLI 2026.10.14, headless, prompt 3 in Plan Mode, which stayed on for prompts 5 to 7	Composer 2.5	15.4
Google Antigravity	Antigravity CLI 1.4.0, permission prompts skipped	Gemini 4 Argon (Medium)	47.4

Agent-Specific Guides

Each guide below applies these steps to one tool and one presentation task.

Use IronPPT with Claude Code for training course handouts with styled text
Use IronPPT with ChatGPT Codex for a weekly sales deck assembled from a template
Use IronPPT with GitHub Copilot for a property listing deck with photos
Use IronPPT with Cursor for porting a school's Open XML SDK report deck generator to IronPPT
Use IronPPT with Google Antigravity for a web app that builds a project status deck for download

Troubleshooting

IronPPT License Keys if Save throws a licensing exception
Engineering Support Request if a saved deck differs from the code and the slide editing section does not explain why
Manage Images if a picture is not where the code placed it

Questions?

If you have any questions, reach out to support@ironsoftware.com

Curtis Chau

Technical Writer

Chat with engineering team now

Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.

Customer Highlight:

Developer Spotlight:

Webinars:

Start Free 30 Day Trial

Using IronPPT with AI Coding Assistants

How to Use IronPPT with an AI Coding Assistant

Can't My AI Assistant Handle PowerPoint on Its Own?

Step 1: Install IronPPT

Step 2: Apply Your License Key

Step 3: Point Your Assistant at IronPPT's LLM Documentation

Step 4: Add IronPPT Context to Your Project

Step 5: One-Shot Setup Prompt

Step 6: Prompt Patterns That Produce Working Code

Step 7: Verify What You Get Back

Let the Agent Verify Its Own Work

Slide editing with IronPPT

Text and image output with IronPPT

A Result You Can Reproduce

The prompt

Output

What passes

The run record

Agent-Specific Guides

Troubleshooting

Questions?

Ready to Get Started?

Product Links

Iron Support Team

Want to deploy Iron Suite
to a live project for FREE?

What’s included?

Get your free 30-day Trial Key instantly

Complete Your Trial Key Signup

Your license key has been delivered to your inbox

Book a Free Live Demo

Your demo request is in.

Trusted by Millions of Engineers Worldwide

Now you've installed with Nuget

Your browser is now downloading

Next step: Start free 30-day Trial

Thank You