How to Test GPT Image 2.5 Textbook-Page Accuracy

What the shared example proves—and what it does not

The supplied X post presents a dense Chinese textbook-style page and describes it as a GPT Image 2.5 result. That is useful inspiration. The post does not provide the exact prompt, model snapshot, request settings, original file metadata, repeated runs, character-by-character review, or comparison method. From that public evidence, we can reasonably say only that the attached composition looks unusually ambitious. We cannot calculate accuracy, failure rate, or model-level reliability.

The valuable Grow AI Skills lesson is therefore not “copy this page prompt.” It is “turn a striking example into a test someone else can rerun and challenge.” That distinction keeps an editorial observation from becoming an unsupported product claim.

What one run can—and cannot—tell us

One retained output is enough for a useful hands-on lesson. It can show whether the requested copy appeared, whether the mathematics still means the same thing, whether labels point to the right objects, and where the generator interpreted instructions instead of following them literally.

It cannot estimate reliability or prove that another run will behave the same way. It also cannot compare Flare and Sunburst when the calling interface does not reveal which image model produced the file. Treat a single run as a worked example; use repeated, pinned API calls only when the question is model performance.

Step 1: freeze the model matrix before looking at results

Model aliases can move over time. A comparison is easier to audit when each row uses the exact model identifier that was requested. The fixture pins these three snapshots:

Three runs are still a tiny sample. They are enough to expose run-to-run variation without turning a tutorial into an expensive evaluation study. Report the nine individual outcomes; do not convert them into a universal percentage.

If your question is broader than textbook pages, compare Flare and Sunburst across wider image-generation workloads. The test here concentrates on Chinese copy, mathematics, and diagram-label accuracy.

Step 2: use an original fixture with an exact answer key

Do not benchmark by reproducing the supplied social-media image. Besides rights and provenance concerns, an unknown source page gives the reviewer no stable answer key. The kit instead uses an original synthetic lesson titled “4.3 Tangent Lines and Linear Approximation,” rendered in Simplified Chinese. It includes a page number, chapter header, Chinese prose, punctuation, Latin variables, a superscript, a limit, two named points, two line labels, and a compact two-column layout.

The reference PNG is drawn deterministically with Pillow. It shows what the fixture requests, but it is not fed to the text-to-image calls and must never be reported as a model result. The machine-readable fixture.json remains the authoritative answer key.

Step 3: freeze one literal prompt

The prompt gives the page hierarchy, exact copy, formulas, diagram labels, palette, and exclusions. Every required visible string is quoted. OpenAI’s image-prompting guidance recommends quoting exact text, asking for readable placement, and checking spelling and legibility after generation. Dense information is also a reason to prefer medium or high quality and to expect iteration.

Create one original portrait Chinese mathematics textbook page at 1024 × 1536.
Render every quoted string exactly as supplied.
Keep all formulas, labels, punctuation, and the requested hierarchy.
Do not add a logo, watermark, signature, citation, English filler, or pseudo-text.
If a required string cannot be rendered accurately, leave its reserved area blank rather than substitute text.
Return one finished page only.

The downloadable benchmark-prompt.txt contains the complete frozen prompt. Its SHA-256 hash is written into every run manifest. Editing even one character creates a different experiment and should start a new fixture version.

One Codex run: strong page design, but not a literal pass

We sent the frozen prompt once through Codex's built-in image generator on September 9, 2026. The returned PNG had the requested 1024 × 1536 dimensions. It was retained without editing and reviewed against the original fixture at full resolution.

For this English-language article, the figure below is a localized reading copy created from that retained PNG. The untouched Chinese source image remains available for verification. The English copy is a presentation edit, not a second benchmark run; the review table still describes the original Chinese file.

The interesting failure is not a garbled Chinese character. Both equations remain mathematically correct, but the generator changed the two slash-form strings into professionally typeset stacked fractions. That makes the page look more like a textbook while violating the instruction to reproduce every visible symbol literally. For a teacher checking mathematical meaning, the output is a strong candidate. For software comparing the rendered page with an exact answer string, it is not a pass.

The one-run evidence record preserves the prompt hash, output dimensions, file hash, review decision, and claim boundary. Because the Codex tool did not expose its image-model identifier, this example must not be used as evidence that a named GPT Image 2.5 API snapshot passed or failed.

Step 4: extend the test when you need model-level evidence

A one-run example should stay a one-run example. To compare named GPT Image 2.5 snapshots, the runner uses the OpenAI Image API generation endpoint, requests a 1024 by 1536 high-quality PNG, and saves three files for each model. It deliberately refuses to run unless the operator supplies an API key, adds --acknowledge-cost, and starts with an empty output directory. That protects against accidental paid calls and mixed reruns.

cd gpt-image-2-5-textbook-benchmark

# No network action; inspect the exact nine-call plan.
python3 run-benchmark.py --dry-run

# Paid execution: requires OPENAI_API_KEY and explicit acknowledgement.
python3 run-benchmark.py --acknowledge-cost

Keep failed or unattractive images. Deleting a bad run and silently rerunning selects for success. If the API rejects a snapshot identifier or request parameter, record that failure and update the benchmark as a new version instead of swapping models mid-matrix.

Step 5: review five accuracy dimensions separately

A page can look coherent at thumbnail size while containing a wrong formula. Score what the reader sees at the final delivery dimensions, then zoom in for exact comparison.

Then answer two yes-or-no questions: is the page legible at delivery size, and is the requested layout complete? Keep these separate from error counts. A perfectly spelled line can still be too small to read.

Step 6: require complete evidence before a pass

The gate checks that all nine run IDs exist once, each uses its assigned snapshot, the prompt hash matches, every PNG exists, every file hash matches, and every manual-review field is complete. A file can receive PASS_FOR_FIXTURE only when all five error counts are zero and both visual checks are yes.

# Demonstrate that the gate itself fails closed.
python3 benchmark-gate.py --self-test

# After nine real calls and human review, evaluate the retained run directory.
python3 benchmark-gate.py

The published self-test passed its synthetic positive control and rejected ten mutations: a missing run, duplicate ID, unapproved model, prompt-hash mismatch, file-hash mismatch, blank formula review, false pass with an error, extra review row, review left on hold, and missing reviewer. This proves the selected evidence rules are enforced. It does not prove that any image model can render the page.

Step 7: report counts, not a winner-shaped headline

A useful result table has one row per retained file. Include the snapshot, run number, five error counts, two visual checks, publication state, reviewer, time, filename, and hash. A model summary may say “two of three retained files passed this fixture” if that is what the completed sheet shows. It should not say “98% accurate,” “production ready,” or “best for textbooks” without a larger, preregistered evaluation that supports those claims.

If the nine-run gate passes, the maximum conclusion is still narrow: the retained matrix is complete, and the stated files received their recorded fixture-level outcomes. If the gate holds, publish the protocol and the hold state—not a guessed result.

Step 8: keep textbook text editable in production

Even a passing bitmap is a poor sole source for a real textbook page. W3C accessibility guidance recommends actual text rather than images of text when the same presentation can be achieved with text. Real text supports zoom, reflow, selection, translation, search, screen readers, corrections, and responsive layout.

Use image generation for illustration, texture, compositional exploration, or an editable design draft. Rebuild final body text, formulas, captions, and critical labels as HTML, SVG, a document layout, or another editable format. Keep the approved copy beside the artwork and rerun accessibility and proofreading checks after export.

What this one run changes

The generated page is better than the source prompt at visual typesetting and worse than it at literal compliance. That is precisely why visual quality and exact-string fidelity need separate review fields. A human still has to decide which requirement matters for the intended use.

Final rule: one retained image can support one concrete observation. Repetition is required only when the claim expands from “this file did this” to “this model behaves this way.”