Put Generated Images to Work

One good image is an experiment. Twenty related assets are a production system.

A production system begins with decisions: the facts you are allowed to claim, the audience, the visual rules, who approves the output, and where the files go. The API comes later. Automation is useful only after those decisions stop changing every five minutes.

This final part builds on the creation workflow and the editing workflow. It keeps human judgment in charge while removing the copying, renaming, and repeated brief assembly.

First, choose the right surface

GPT Image 2 can sit behind several products. The model may be the same, but the surrounding workflow is not.

Use	Best starting point	Why
Learn, explore, or make a handful of assets	ChatGPT	It combines conversation, image generation, a selection editor, an image library, and follow-up edits in one place.
Compare several image or video models under one subscription	Poe	It makes model-switching easy. Its GPT-Image-2 bot is a narrower wrapper with three aspect ratios, quality controls, attachments, and an optional mask.
Generate or edit one image inside your own product or script	Image API	Your code calls gpt-image-2 directly and controls the prompt, dimensions, quality, format, and file handling.
Build a conversational or multi-step workflow	Responses API	A mainline GPT model can reason, use the image-generation tool, retain conversational state, and continue editing over several turns.

My recommendation is blunt: do the work manually before automating it. If you cannot produce three good assets consistently in ChatGPT, code will produce bad assets faster and at scale.

The six-stage production loop

The smallest useful workflow has six stages:

1. Approve the brief and facts. Lock the audience, purpose, copy, figures, sources, constraints, and required formats.
2. Define the visual system. Choose composition rules, palette, typography treatment, materials, lighting, and what must remain recognisable across assets.
3. Generate drafts cheaply. Create a few distinct directions at low quality before paying and waiting for final renders.
4. Run mechanical checks. Confirm dimensions, filenames, expected text, and required disclosure. These checks catch obvious failures, not aesthetic ones.
5. Get human approval. A named person checks truth, brand fit, rights, weird details, and whether the asset is actually good.
6. Publish and retain the record. Save the approved image with its brief, source material, prompt, model, date, and approver.

The human gate is not ceremonial. An automated check can tell you that a slide contains the string 42%. It cannot tell you that the number is misleading, the visual implies causation, or the person in the background has acquired a sixth finger.

Presentation visuals and infographics: lock the information first

Image models are now good enough at typography and layout to create convincing business visuals. Convincing is the dangerous word.

Use two separate artefacts:

1. An approved content block with exact title, labels, figures, source, and caveats.
2. A visual brief that says how to present that content.

Here is the fictional example from part one:

APPROVED CONTENT — DO NOT ALTER

Title: WHY CUSTOMERS LEAVE
Slow setup: 42%
Unclear value: 31%
Missing integrations: 27%
Footer: Fictional sample data

VISUAL DIRECTION

16:9 executive slide. Warm off-white canvas, charcoal typography,
indigo horizontal bars, one restrained burnt-orange coffee motif.
Do not add statistics, labels, sources, or explanatory copy.

For a real presentation, I would normally recreate the final chart in PowerPoint, Keynote, Figma, or a charting tool. The generated version is excellent for finding an art direction and creating visual ingredients. Editable text and data still belong in a deterministic file.

That boundary also matters for accessibility. Text baked into pixels is harder to update, translate, search, and read with assistive technology. Keep the underlying copy in the slide or page whenever the medium allows it.

Build a visual system before making a batch

Consistency comes from a small set of explicit rules and stable references, not from pasting the same adjectives into twenty prompts.

For the fictional coffee brand, the system could be:

Stable identity:
- hand-thrown burnt-orange espresso cup
- visible glaze irregularities and tactile materials
- charcoal stone, natural linen, muted blue-grey surroundings

Composition:
- one unmistakable hero object
- quiet negative space for copy
- table-height camera and restrained depth of field

Light and mood:
- soft dawn light from the left
- one warm reflection
- calm, editorial, never glossy stock photography

Avoid:
- scattered coffee beans
- generic café clutter
- logos or text inside the generated image
- excessive steam, lens flare, or luxury clichés

Then make a small contact sheet before producing finals: hero image, square crop, vertical story, presentation opener, and one close detail. Review them together. A weak family often contains five individually attractive images that clearly came from five different brands.

Save the approved system prompt and two or three visual references. Give every reference a role: identity, composition, lighting, or texture. If you only say “match these images,” the model has to guess which part of each image matters.

Automate one-shot generation with the Image API

The OpenAI image-generation guide recommends the Image API for direct generations and edits. This minimal JavaScript example generates a landscape WebP draft and saves it locally:

import OpenAI from "openai";
import fs from "fs";

const openai = new OpenAI();

const result = await openai.images.generate({
  model: "gpt-image-2",
  prompt: visualBrief,
  size: "1536x1024",
  quality: "low",
  output_format: "webp",
});

const imageBase64 = result.data[0].b64_json;
fs.writeFileSync(
  "coffee-campaign-draft.webp",
  Buffer.from(imageBase64, "base64")
);

The SDK reads OPENAI_API_KEY from the environment. Never put that key into browser code, a public repository, or the prompt itself. Call the API from a server or trusted automation environment.

GPT Image 2 accepts flexible dimensions within documented limits. OpenAI currently recommends quality: "low" for fast drafts, then medium or high for final assets. PNG is the default; JPEG and WebP are also available, with optional compression. One current limitation is easy to miss: GPT Image 2 in the API does not support transparent backgrounds, so plan to remove the background separately when you need a cut-out.

Use the direct API when the task is already well specified: generate a thumbnail from an approved brief, edit a supplied image, create three required formats, or render a queued batch. Keep the input, output, request ID, model snapshot if used, and approval state together. Without that record, debugging a bad asset becomes archaeology.

Use the Responses API for a workflow that can think and continue

The Responses API is a better fit when the job needs reasoning or several conversational turns: inspect a brief, identify conflicts, generate an image, receive feedback, then revise it in context.

import OpenAI from "openai";
import fs from "fs";

const openai = new OpenAI();

const first = await openai.responses.create({
  model: "gpt-5.6",
  input: `Review this approved visual brief, then generate the first draft:\n\n${visualBrief}`,
  tools: [{ type: "image_generation" }],
});

const imageData = first.output
  .filter((item) => item.type === "image_generation_call")
  .map((item) => item.result);

if (imageData.length > 0) {
  fs.writeFileSync("draft.png", Buffer.from(imageData[0], "base64"));
}

const revision = await openai.responses.create({
  model: "gpt-5.6",
  previous_response_id: first.id,
  input: "Keep the visual system. Move the cup farther right and change nothing else.",
  tools: [{ type: "image_generation" }],
});

The exact mainline model will change over time, so check the current model documentation before shipping code. The important distinction is stable: the Image API calls the image model directly; the Responses API gives a reasoning model an image-generation tool and conversational state.

Do not confuse more autonomy with more authority. The workflow can decide how to satisfy a brief. It should not decide that unapproved claims, confidential inputs, or a real person’s likeness are acceptable to publish.

What to check automatically, and what not to pretend you checked

Useful automated checks include:

• expected width, height, format, and file size
• filename and destination
• whether required text is present, using OCR as a warning rather than proof
• whether an asset has the required source note or disclosure beside it
• whether the prompt used an approved brief version
• whether the output has a recorded human approver

Human review still needs to cover:

• factual meaning, not just matching characters
• visual quality and brand fit
• distorted objects, anatomy, reflections, shadows, and perspective
• product and character identity
• accidental trademarks or misleading resemblance
• consent, licensing, and appropriate disclosure

Never build an automation that turns “the file exists” into “the asset is approved.” Those are different states with different owners.

Watermarks and provenance: the visible mark is not the whole story

OpenAI says images generated by ChatGPT, Codex, and its API include C2PA metadata and an invisible SynthID watermark. C2PA metadata can be removed by screenshots or platforms that strip metadata. The invisible signal is intended to survive common transformations better.

Poe’s GPT-Image-2 page confirms that its bot uses an OpenAI-managed server, but Poe does not publicly document whether the file you download preserves OpenAI’s C2PA metadata. I would not infer “unwatermarked” from the absence of a visible badge. The safe statement is narrower: the visible output may look the same, while provenance handling by the wrapper is undocumented.

Google’s approach illustrates the same distinction. Its Gemini image documentation says generated images carry invisible SynthID, while Google’s Nano Banana Pro announcement explains that the visible Gemini sparkle depends on the product and subscription tier. A visible mark can disappear while an invisible one remains.

For internal workflows, retain your own provenance record regardless of embedded metadata: source inputs, prompt, model, date, edits, and approver. Embedded signals help. They are not a substitute for governance you control.

Privacy, rights, and commercial use

The product boundary matters again here. OpenAI’s Data Controls FAQ explains how consumer ChatGPT users can turn off model improvement or use Temporary Chat. OpenAI says Business, Enterprise, and API inputs and outputs are not used to improve models by default. Poe has its own terms and data handling. Your organisation’s policy may rule out one surface even when the underlying model is identical.

Before uploading client material, unreleased products, patient information, employee data, or confidential strategy, check the contract and the exact product plan. In healthcare, “the vendor uses OpenAI” is nowhere near enough. You need to know which vendor is the processor, where data goes, what is retained, which agreement applies, and whether the use is allowed at all.

OpenAI’s terms say that, as between you and OpenAI and to the extent permitted by law, you own the output. They also warn that output may not be unique and that you are responsible for having the necessary rights to the input. That is not a guarantee that your generated logo clears trademark law, that a reference image was licensed, or that an edited likeness is lawful.

For real people, get express consent for the intended use. For brand identity, run a trademark check before commitment. For material copyright or data-protection exposure, get proper legal advice before publication, not after the campaign is live.

A sensible implementation ladder

Do not start with a fully autonomous creative pipeline. Build the smallest version that earns the next step:

1. Manual: One approved brief, three ChatGPT drafts, one human choice.
2. Templated: Reuse a visual-system block and a consistent file-naming scheme.
3. Assisted: A script sends approved briefs to the Image API and stores drafts in a review folder.
4. Checked: Add dimensions, format, OCR warnings, prompt version, and cost logging.
5. Integrated: Connect the approved output to your presentation, CMS, or campaign workflow.

Stop wherever the economics stop improving. A monthly campaign with six images may need a good template, not an API. A product generating thousands of personalised visuals needs queues, rate limits, retries, monitoring, abuse controls, and a serious approval model.

GPT Image 2 adds a new way to direct, create, reconstruct, and scale visual material alongside photography, illustration, design, and Photoshop. The quality ceiling rises when your judgment becomes more explicit. Removing the human would lower it.