How to Use Codex to Generate Slide Decks From Research

Codex is most useful for slide decks when the input is structured. Not "make me a PowerPoint," but a folder holding research notes, competitor analysis, product positioning, screenshots, and an existing brand template, turned into a deck that follows the same rules every time.

OpenAI documents this directly: Codex can manipulate .pptx files, generate visuals, apply repeatable layout rules, update existing decks, and build new ones, using the Slides skill for PowerPoint editing and the ImageGen skill for illustrations and cover art^[1].

Learning how to use Codex to generate slides is mostly about one discipline: making it propose the outline before it writes a single slide, and telling it which text it is not allowed to rewrite.

TL;DR

• Start from an existing brand deck, and make Codex summarize the visual rules before generating anything^[1].
• Demand an outline first. Slide-by-slide title, core message, source evidence, recommended visual, presenter note. Approve it before any PPTX gets written.
• Pin the claims it must not touch. Approved messaging, pricing language, legal claims. Tell it to mark gaps as "needs verification" rather than fill them in.
• Keep text editable and charts native. Do not let it rasterize slides.
• Render and inspect before delivery. A deck can be content-correct and visually broken.
• Use ImageGen for cover art and concepts, never for product UI, real logos, or data charts.

The seven-step workflow

1. Collect structured inputs

Codex works from source material, so the quality of the deck tracks the organization of the folder. Product brief, research notes, brand template, screenshots, competitor notes, interview summaries, campaign metrics, messaging framework, approved claims, logo assets.

2. Start from a brand template

OpenAI's guidance is to start from an existing deck where possible^[1]. Make the model read it first:

First inspect the existing brand deck. Identify the slide size, title style,
body-text style, color palette, logo placement, image treatment, chart style,
and spacing rules. Summarize these rules before generating new slides.

3. Get the outline before the deck

This is the step people skip, and it is the one that decides whether the deck argues anything.

Before creating the deck, propose a slide-by-slide outline. For each slide,
include the title, core message, source evidence, recommended visual, and
presenter note. Do not generate the PPTX until I approve the outline.

Narrative flow is not generic. A market research deck, a launch deck, and a sales deck should not share a structure, and you find out whether the model understood that at the outline stage, not after it has rendered forty slides.

4. Pin the claims it may not rewrite

Decks carry approved messaging, legal claims, and pricing language. A model that paraphrases those has created a compliance problem, not a draft.

Preserve all approved product claims exactly as written. Do not invent customer
quotes, pricing, performance numbers, or competitor claims. If evidence is
missing, mark it as needs verification instead of filling it in.

The instruction that does the work is the last clause. Given a gap, a model will fill it plausibly unless told what to do instead.

5. Generate editable slides with native charts

Create the deck as an editable PPTX. Keep text as editable PowerPoint text.
Use native charts for simple bar, line, pie, and histogram visuals when
practical. Do not rasterize full slides. Use image assets only for screenshots,
illustrations, and complex visuals.

Teams revise wording many times. A rasterized slide is a dead end.

6. Use ImageGen deliberately

Define one visual direction and reuse it, rather than letting each slide drift.

Define a consistent visual direction for this deck. Use clean SaaS-style
illustrations, realistic product context, and a polished B2B visual tone.
Save the image prompts so future slides can match the same direction.

Generate: cover slides, product-concept illustrations, market-trend visuals, customer-journey diagrams, section dividers.

Do not generate: exact product UI screenshots, legal or compliance claims, real customer logos, or data charts that should stay native and editable.

7. Render and validate

Render the deck to slide images. Review every slide for clipped text, overlap,
inconsistent spacing, unreadable screenshots, font substitution, layout drift,
and visual-style mismatch. Fix all issues before saving the final PPTX.

A deck can be entirely correct and still look broken. Rendering to images is how the model sees what you would see.

Deck types this works well for

The pattern fits any deck whose structure is stable while the content changes^[1].

Market research. Market overview, growth drivers, customer segments, buyer pain points, competitor landscape, pricing patterns, adoption barriers, opportunity areas, recommendations.

Product launch. Product overview, customer problem, target audience, positioning statement, key features, differentiation, launch narrative, messaging pillars, campaign plan, timeline, call to action.

Product demo. Demo objective, user problem, workflow overview, step-by-step screenshots, feature highlights, before-and-after, customer value, next steps.

Competitive analysis. Competitor overview, feature comparison, pricing comparison, messaging comparison, strengths and weaknesses, positioning map, differentiation strategy, recommended talk tracks.

Sales enablement. Buyer persona, pain points, discovery questions, value proposition, objection handling, competitor responses, proof points, demo flow, closing talk track.

A complete worked prompt

Use the Slides and ImageGen skills to generate a 12-slide market research deck.

Inputs:
- the attached brand PowerPoint template
- market research notes
- competitor analysis
- customer interview summaries
- product screenshots

First inspect the brand template and summarize the visual rules.
Then propose a slide-by-slide outline before generating the deck.
Include market overview, customer segments, pain points, competitor landscape,
positioning gaps, product opportunity, and recommendations.

Preserve approved claims exactly. Mark any missing evidence as needs
verification rather than filling it in. Keep all text editable and use native
charts. Render to images and fix layout issues before saving the final PPTX.

Every clause in that prompt maps to a failure this workflow is designed to prevent.

Where the approach breaks down

Worth stating plainly, because the failure modes are predictable.

It will not invent a strategy. Codex arranges and renders the argument you supply. Given thin inputs it produces a well-formatted deck that says nothing, which is harder to spot than an ugly one.

Unverified numbers are the main risk. A model asked for a market-size slide without a source will produce a confident figure. The "mark as needs verification" instruction is the mitigation, and it only works if you actually read for those markers.

Visual consistency degrades across long decks unless you pin the direction once and reference it, which is what step 6 is for.

Brand nuance stays human. The model can match a palette and a type scale. Whether the deck sounds like your company is a judgment call.

Building this into your own product

The workflow above runs inside Codex, on your machine, against your folder. That is the right shape when the deck is yours.

It is the wrong shape for a different job: putting deck generation inside software you ship. A tool that turns a customer's report into slides, an internal service that assembles weekly reviews, a feature that drafts sales collateral from a CRM record. None of those are a developer running a CLI.

That job needs the models directly. The reasoning that plans the outline and the image model that produces the cover art are both API calls, and reAPI exposes both behind one key:

from openai import OpenAI

client = OpenAI(api_key="YOUR_REAPI_KEY", base_url="https://api.reapi.ai/v1")

outline = client.chat.completions.create(
    model="gpt-5.6-terra",
    messages=[{"role": "user", "content": "Propose a 12-slide outline from this research. Mark unsupported claims."}],
    max_tokens=16000,
)

Cover art and section visuals come from the image side of the same account, at reapi.ai/models/gpt-image-2, which handles in-image text well enough for titles and labels. The full catalog is at reapi.ai/models.

Use Codex for your own decks. Use the API when the deck belongs to someone else.

FAQ

Can Codex edit an existing PowerPoint file?

Yes. OpenAI documents Codex manipulating .pptx files directly, updating existing presentations as well as building new ones, through the Slides skill^[1].

How do I keep Codex from inventing statistics?

Instruct it to preserve approved claims verbatim and to mark missing evidence as needing verification rather than filling it in. Then read for those markers before the deck ships.

Should I let Codex generate charts?

Use native PowerPoint charts for simple bar, line, pie, and histogram visuals so they stay editable. Reserve generated images for illustrations and complex visuals^[1].

Why ask for an outline first?

Because narrative structure is where decks fail, and fixing it at the outline stage costs one message instead of a full regeneration.

What should ImageGen not be used for?

Exact product UI, legal or compliance claims, real customer logos without permission, and data charts that should remain native and editable.

Does this work for non-marketing decks?

Yes. The workflow is structure-driven, so it applies to any deck type whose format is stable while the content changes.

How do I build slide generation into my own application?

Call the models through an API rather than the CLI. Outline planning is a chat completion; cover art and diagrams are image generations.

Making the outline the checkpoint

The temptation with a capable agent is to describe the deck and accept what comes back. That produces a plausible artifact whose argument nobody chose.

The discipline that makes this workflow reliable is small: read the brand rules back before generating, approve an outline before rendering, pin the sentences that cannot change, and look at rendered images before calling it done. Learning how to use Codex to generate slides is mostly learning to put a human checkpoint at the outline, where changing your mind is still cheap.

References

1. OpenAI. Platform documentation — Codex, skills, and model capabilities. Retrieved July 2026 from platform.openai.com/docs
2. OpenAI. Codex — open-source repository and usage documentation. Retrieved July 2026 from github.com/openai/codex

Further reading

• reAPI. How to use GPT Image 2. reapi.ai/blog/how-to-use-gpt-image-2
• reAPI. How to use GPT-5.6. reapi.ai/blog/how-to-use-gpt-5-6
• reAPI. Model catalog. reapi.ai/models