Skip to content
Back to search

gpt-image-skill

Generate GPT images from Codex or Claude Code using a ChatGPT subscription, without the Images API.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/genexis-ai--gpt-image-skill/badge.svg)](/listings/genexis-ai--gpt-image-skill)

HTML

<a href="/listings/genexis-ai--gpt-image-skill"><img src="/api/listings/genexis-ai--gpt-image-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Paste this into Codex, Claude Code, Google Antigravity, or another local coding agent:

Install and verify GPT Image Skill for the current user from:

https://github.com/GENEXIS-AI/gpt-image-skill

For this task, I authorize read-only environment checks; a persistent clone or safe fast-forward update;
user-level installation of missing Git, a supported Node.js 22+ LTS, and Codex CLI;
creation of the gpt-image links for Codex, Claude Code, and Google Antigravity; and starting Sign in with ChatGPT device authorization.

Read AGENT_INSTALL.md at the repository root and follow it as the one-time installation contract.
Do not use the Images API, OPENAI_API_KEY, or API-key login. Do not generate a live image yet.
Pause only if administrator privileges are required, an unrelated existing path would be changed,
local changes would be discarded, or existing Codex authentication would need to be replaced.
Otherwise, install the required components, run bootstrap --target all --yes --json,
and continue until bootstrap's consolidated readiness report shows best_practice_pass=true.
Do not add a separate doctor, plan, inspect, or no-image generation check when bootstrap passes.
Finally, report the persistent clone path, all three installed skill paths, and ChatGPT-auth evidence.
Then give me the brief getting_started guide in my language: common aspect ratios,
quality phrases, one creation example, one reference or revision example, and one transparent-background example.
Do not use unexplained jargon such as "dry-run"; call it a setup check that does not create an image.

This prompt authorizes ordinary user-level setup without authorizing administrator elevation, destructive changes, replacement of existing authentication, a live generation, or a GitHub Star. The full boundary is in [AGENT_INSTALL.md](./AGENT_INSTALL.md).

After setup, invoke `$gpt-image` in Codex, `/gpt-image` in Claude Code, or mention `gpt-image` in an Antigravity request. Antigravity discovers the global skill automatically from its official skill directory. The host loads the concise skill only for image tasks; it does not need to reread this README on every request.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 518 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # GPT Image Skill
  2. [![Validate skill](https://github.com/GENEXIS-AI/gpt-image-skill/actions/workflows/validate.yml/badge.svg)](https://github.com/GENEXIS-AI/gpt-image-skill/actions/workflows/validate.yml)
  3. Generate and edit GPT images from Codex, Claude Code, Google Antigravity, or another compatible local agent through the user's **ChatGPT subscription**. Direct prompts stay unchanged; when the user delegates several different designs, the agent develops a distinct image-ready prompt for each concept. Real reference files pass into generation, bridge-produced transparent PNGs are checked for alpha/transparency support, results stay in the active project, and ready outputs run with bounded parallelism.
  4. ```text
  5. install skill → Sign in with ChatGPT → direct prompt or delegated concept prompts + local image inputs
  6. → single generate or bounded parallel batch
  7. → built-in $imagegen → <project>/generated-images/*.png
  8. ```
  9. > This repository does not call the OpenAI Images API and does not create a separately billed Images API request. Built-in image generation still consumes included ChatGPT/Codex usage and remains subject to plan and workspace limits. OpenAI currently states that Codex image generation is **not available on the Free plan** and that supported-plan image generations use included limits 3–5× faster on average than similar non-image turns, depending on quality and size. This skill does not bypass that boundary.
  10. ![GPT Image Skill smoke test](./generated-images/subscription-workflow-smoke.png)
  11. ![GPT Image Skill reference edit smoke test](./generated-images/reference-edit-smoke.png)
  12. ## Install by pasting one prompt into an agent
  13. Paste this into Codex, Claude Code, Google Antigravity, or another local coding agent:
  14. ```text
  15. Install and verify GPT Image Skill for the current user from:
  16. https://github.com/GENEXIS-AI/gpt-image-skill
  17. For this task, I authorize read-only environment checks; a persistent clone or safe fast-forward update;
  18. user-level installation of missing Git, a supported Node.js 22+ LTS, and Codex CLI;
  19. creation of the gpt-image links for Codex, Claude Code, and Google Antigravity; and starting Sign in with ChatGPT device authorization.
  20. Read AGENT_INSTALL.md at the repository root and follow it as the one-time installation contract.
  21. Do not use the Images API, OPENAI_API_KEY, or API-key login. Do not generate a live image yet.
  22. Pause only if administrator privileges are required, an unrelated existing path would be changed,
  23. local changes would be discarded, or existing Codex authentication would need to be replaced.
  24. Otherwise, install the required components, run bootstrap --target all --yes --json,
  25. and continue until bootstrap's consolidated readiness report shows best_practice_pass=true.
  26. Do not add a separate doctor, plan, inspect, or no-image generation check when bootstrap passes.
  27. Finally, report the persistent clone path, all three installed skill paths, and ChatGPT-auth evidence.
  28. Then give me the brief getting_started guide in my language: common aspect ratios,
  29. quality phrases, one creation example, one reference or revision example, and one transparent-background example.
  30. Do not use unexplained jargon such as "dry-run"; call it a setup check that does not create an image.
  31. ```
  32. This prompt authorizes ordinary user-level setup without authorizing administrator elevation, destructive changes, replacement of existing authentication, a live generation, or a GitHub Star. The full boundary is in [AGENT_INSTALL.md](./AGENT_INSTALL.md).
  33. After setup, invoke `$gpt-image` in Codex, `/gpt-image` in Claude Code, or mention `gpt-image` in an Antigravity request. Antigravity discovers the global skill automatically from its official skill directory. The host loads the concise skill only for image tasks; it does not need to reread this README on every request.
  34. ## What the agent shows after installation
  35. The installing agent should end with a small guide like this, translated into the user's language:
  36. ```text
  37. GPT Image Skill is ready. No image was generated during setup.
  38. Common aspect-ratio requests: 1:1, 16:9, 9:16, 4:3, 3:4
  39. Quality phrases: draft, high quality, high detail / final quality
  40. Try:
  41. $gpt-image Create a cozy reading room at sunset, 16:9, high quality.
  42. /gpt-image Use @references/character.png as the character reference and place it in a rainy city, 9:16, high quality.
  43. Use the gpt-image skill to create a flat blue robot app icon with a transparent background, 1:1, high quality.
  44. CLI model policy: no model ID is pinned; Codex selects a current account-available model at Low reasoning.
  45. Plan note: setup verifies sign-in, not image entitlement. Current Codex pricing excludes image generation from Free.
  46. ```
  47. These are common natural-language requests, not a fixed API size list. Other framing or dimension requests can be written normally, and exact pixel dimensions may vary with built-in image generation. The guide appears once after installation rather than after every image.
  48. ## Design principles
  49. ### 1. The prompt is authoritative—and so is delegated creative intent
  50. For one direct image or edit, the skill forwards the user's image request unchanged. It does not “improve” a short prompt with unsolicited details. A request such as “make five different poster designs” is different: it explicitly asks the agent to develop five creative concepts. The agent preserves the shared subject, references, brand, text, ratio, and other constraints, then sends one complete, meaningfully different image prompt per output. Job numbers remain in IDs and filenames, never in image prompts.
  51. ### 2. References are files, not descriptions
  52. The bridge requires a readable local PNG, JPEG, or WebP path for each reference. It passes those files into the actual `$imagegen` call. It never replaces an unresolved reference with a text description and continues anyway.
  53. In Claude Code or Antigravity:
  54. - Prefer `@path/to/image.png` or an explicit filesystem path.
  55. - A pasted or dragged image visible in the conversation is not automatically inherited by a nested `codex exec` process.
  56. - If the host exposes an exact readable temporary attachment path, the agent copies that exact file into `<project>/generated-images/inputs/` and uses the copy.
  57. - If the host exposes no path, save the image inside the project and provide that path before generation.
  58. - The skill does not guess from `~/.claude/image-cache`; choosing “the newest image” could select the wrong or private file.
  59. ### 3. Revisions always edit the latest result
  60. Each bridge invocation is ephemeral. For “change the result you just made,” the agent must use the previous generated output as the next `--edit-target` and reattach every still-needed reference. Reusing the original source is a different operation and loses the prior edit.
  61. ### 4. Normal generation stays light
  62. The default path is:
  63. ```text
  64. quick ChatGPT-auth check → current account-available Codex model at Low reasoning
  65. → built-in image generation → minimal PNG sanity check
  66. → PATH + inline Markdown
  67. ```
  68. Planning, the setup check that does not create an image (`--dry-run`), `capabilities --json`, `inspect --input`, and detailed JSON remain available for troubleshooting. They are not required before a normal image request.
  69. ### 5. The model stays current; reasoning stays light
  70. Codex model names and availability change over time. The default CLI bridge therefore does **not** pin Luna, Sol, Terra, or any other model ID and does not embed a model catalog. Codex selects a current model available to the signed-in account, while the runner requests **Low** reasoning—the CLI name for **Light** in the ChatGPT app. The selected Codex model receives a finalized, tightly scoped instruction and calls `$imagegen`.
  71. The image renderer is not pinned either. OpenAI currently documents Codex's built-in renderer as `gpt-image-2`, but this repository invokes the built-in image-generation capability by name so OpenAI can update the underlying renderer without a skill release. The outer Codex model can affect tool routing and instruction following, but it does not replace the built-in renderer or directly set its visual rendering quality.
  72. The default `auto` policy is intentionally small:
  73. 1. Let Codex select a current model available to the signed-in account.
  74. 2. Request Low reasoning for the deterministic bridge task.
  75. 3. Run no model-discovery preflight, fallback turn, or automatic image-generation retry.
  76. `--orchestrator-model account-default` removes even the Low override and leaves both model and reasoning to Codex. A current model ID can still be pinned as an advanced, explicit user choice; the runner accepts the ID without maintaining its own allowlist.
  77. This policy lowers bridge overhead on supported plans, but it cannot make image generation available on ChatGPT Free. Codex itself is included in Free, while the official pricing page separately says image generation is unavailable there. See [Codex models](https://learn.chatgpt.com/docs/models), [Codex image generation](https://learn.chatgpt.com/docs/image-generation), and [Codex pricing](https://learn.chatgpt.com/docs/pricing).
  78. ### 6. Parallelism is explicit and bounded
  79. `generate` remains the one-image happy path. For two or more outputs, the skill automatically batches every job whose inputs already exist. Different design concepts run independently; same-design variants may run together while reading one shared edit target or design reference. Only an output-to-input dependency creates another stage. The batch checks ChatGPT auth once and uses default concurrency 2, maximum 4, with no Doctor, planning, inspection, model-discovery preflight, fallback turn, or image-generation retry per job.
  80. ## Features
  81. - Uses Codex's built-in `$imagegen` under **Sign in with ChatGPT**
  82. - Uses a host-native OpenAI/Codex `image_gen` tool directly only when it is backed by included ChatGPT/Codex usage
  83. - Blocks `OPENAI_API_KEY`, API-key Codex login, and Images API fallback
  84. - Leaves the default Codex model unpinned and requests Low reasoning for the deterministic CLI bridge
  85. - Installs the same `gpt-image` skill for Codex, Claude Code, and Google Antigravity
  86. - Preserves direct prompts verbatim and honors delegated multi-concept design work
  87. - Supports one or multiple references with deterministic attachment order
  88. - Supports existing-image edits, follow-up revisions, variations, compositing, transparency, exact text, and dense-layout drafts
  89. - Supports bounded parallel generation for independent concepts and shared-anchor variations
  90. - Saves only inside the active workspace and avoids overwrite by default
  91. - Returns `PATH=...` and absolute `MARKDOWN=...` after normal generation
  92. - Supports macOS, Linux, native Windows, and WSL2
  93. ## Workflow map
  94. | Intent | Bridge arguments |
  95. | --- | --- |
  96. | Text-to-image | `--mode generate` |
  97. | New image guided by a reference | `--mode generate --reference PATH` |
  98. | Multiple references | Repeat `--reference`; add matching `--reference-role` only for explicit roles |
  99. | Change an existing image | `--mode edit --edit-target PATH` |
  100. | Change the last generated image | Use the last returned path as the new `--edit-target` |
  101. | Variation | `--mode variation --edit-target PATH` |
  102. | Transparent output | Use `--background transparent` only when requested |
  103. | Same design, different styles | Repeat `--mode variation --edit-target SAME_PATH` in a batch |
  104. | Same identity, different scenes | Repeat `--mode generate --reference SAME_PATH` in a batch |
  105. | Different designs in parallel | Give each batch job its own prompt and references |
  106. | CLI model routing | Default `auto` = current account-available Codex model at Low reasoning |
  107. The edit target is Image 1. Supporting references follow in command-line order.
  108. ## Requirements and environments
  109. - Node.js 22 or newer; the [current supported LTS](https://nodejs.org/en/download) is recommended.
  110. - Git when installing from GitHub.
  111. - Codex CLI signed in with ChatGPT, unless the calling host provides subscription-native OpenAI/Codex `image_gen`.
  112. - A ChatGPT/Codex plan and workspace that permit image generation. The current official pricing page excludes image generation from the Free plan.
  113. | Environment | Status | Keep together |
  114. | --- | --- | --- |
  115. | macOS | Supported | macOS Node.js, Codex, clone, and workspace |
  116. | Linux | Supported | Linux Node.js, Codex, clone, and workspace |
  117. | Native Windows | Supported | Windows Node.js, Codex, junctions, and workspace |
  118. | WSL2 | Supported | Keep the complete toolchain on the Linux side |
  119. | WSL1 | Unsupported | Move to WSL2 or native Windows |
  120. ## Manual installation
  121. Use a persistent clone because the installed skill links point to it.
  122. ### macOS, Linux, and WSL2
  123. ```bash
  124. REPOSITORY_URL="https://github.com/GENEXIS-AI/gpt-image-skill"
  125. INSTALL_DIR="${XDG_DATA_HOME:-$HOME/.local/share}/gpt-image-skill"
  126. git clone "$REPOSITORY_URL" "$INSTALL_DIR"
  127. cd "$INSTALL_DIR"
  128. node ./gpt-image/scripts/validate_skill.mjs
  129. node ./gpt-image/scripts/gpt_image.mjs bootstrap --target all --yes --json
  130. ```
  131. Keep WSL2 clones under the Linux home directory, not `/mnt/c`.
  132. ### Native Windows PowerShell
  133. ```powershell
  134. $RepositoryUrl = "https://github.com/GENEXIS-AI/gpt-image-skill"
  135. $InstallDir = Join-Path $env:LOCALAPPDATA "gpt-image-skill"
  136. git clone $RepositoryUrl $InstallDir
  137. Set-Location $InstallDir
  138. node .\gpt-image\scripts\validate_skill.mjs
  139. node .\gpt-image\scripts\gpt_image.mjs bootstrap --target all --yes --json
  140. ```
  141. Installed locations:
  142. - Codex: `~/.agents/skills/gpt-image`
  143. - Claude Code: `~/.claude/skills/gpt-image`
  144. - Google Antigravity: `~/.gemini/config/skills/gpt-image`
  145. - Native Windows: `$env:USERPROFILE\.agents\skills\gpt-image`, `$env:USERPROFILE\.claude\skills\gpt-image`, and `$env:USERPROFILE\.gemini\config\skills\gpt-image`
  146. macOS, Linux, and WSL2 use symlinks. Native Windows uses directory junctions. Existing unrelated paths are never replaced.
  147. The Antigravity target is the current global skill location documented for the Antigravity app. For the Antigravity SDK, `skills_paths` may instead point directly to the repository's `gpt-image` directory. Image generation still runs through the ChatGPT-authenticated Codex bridge; the skill deliberately does not substitute Antigravity's provider-native `generate_image` tool.
  148. A successful bootstrap includes:
  149. ```json
  150. {
  151. "ok": true,
  152. "status": "ready",
  153. "doctor": {
  154. "platform_supported": true,
  155. "node_supported": true,
  156. "codex_available": true,
  157. "chatgpt_subscription_login": true,
  158. "api_environment_forwarded": false,
  159. "codex_skill_installed": true,
  160. "claude_skill_installed": true,
  161. "antigravity_skill_installed": true,
  162. "best_practice_pass": true
  163. },
  164. "getting_started": {
  165. "present_in_user_language": true,
  166. "common_aspect_ratios": [
  167. { "ratio": "1:1" },
  168. { "ratio": "16:9" },
  169. { "ratio": "9:16" },
  170. { "ratio": "4:3" },
  171. { "ratio": "3:4" }
  172. ]
  173. }
  174. }
  175. ```
  176. The user completes browser or device authorization personally. The skill never requests or reads a password, token, API key, or `~/.codex/auth.json`.
  177. ## Usage
  178. Codex:
  179. ```text
  180. $gpt-image A cobalt-blue glass robot on a warm off-white background.
  181. ```
  182. Claude Code:
  183. ```text
  184. /gpt-image A cobalt-blue glass robot on a warm off-white background.
  185. ```
  186. Google Antigravity:
  187. ```text
  188. Use the gpt-image skill to create a cobalt-blue glass robot on a warm off-white background.
  189. ```
  190. Direct runner:
  191. ```bash
  192. node ./gpt-image/scripts/gpt_image.mjs generate \
  193. --prompt "A cobalt-blue glass robot on a warm off-white background." \
  194. --out "generated-images/glass-robot.png"
  195. ```
  196. The command above uses the default `auto` policy: Codex selects a current model available to the signed-in account, while the runner requests Low reasoning. No model catalog, model discovery, fallback, or extra diagnostic turn is involved. To leave both the model and reasoning effort entirely at Codex defaults:
  197. ```bash
  198. node ./gpt-image/scripts/gpt_image.mjs generate \
  199. --prompt "A cobalt-blue glass robot on a warm off-white background." \
  200. --orchestrator-model account-default \
  201. --out "generated-images/glass-robot.png"
  202. ```
  203. An advanced caller can explicitly pin any current Codex orchestrator and reasoning effort. The runner deliberately has no model-ID allowlist because the catalog changes. This changes the agent that routes `$imagegen`, not the built-in renderer:
  204. ```bash
  205. node ./gpt-image/scripts/gpt_image.mjs generate \
  206. --prompt "A cobalt-blue glass robot on a warm off-white background." \
  207. --orchestrator-model "<current-codex-model-id>" \
  208. --orchestrator-effort medium \
  209. --out "generated-images/glass-robot.png"
  210. ```
  211. ### Transparent background
  212. Ask for transparency naturally in any supported host:
  213. ```text
  214. Use the gpt-image skill to create a flat cobalt-blue robot app icon with a transparent background, 1:1, high quality.
  215. ```
  216. The agent keeps the creative prompt authoritative and routes transparency separately. With the bridge, the explicit runner form is:
  217. ```bash
  218. node ./gpt-image/scripts/gpt_image.mjs generate \
  219. --prompt "Create a flat cobalt-blue robot app icon, 1:1, high quality." \
  220. --background transparent \
  221. --out "generated-images/robot-icon-transparent.png"
  222. ```
  223. Transparent output must be a PNG with an alpha channel or PNG transparency chunk. When `--background transparent` is requested, the runner rejects a PNG that has neither; this verifies transparency support without pretending to be a visual-quality review. A checkerboard pattern, white canvas, or solid-color background is not a valid substitute for transparency. If a subscription-native host tool has no real background control, the skill uses the bridge when available instead of claiming transparency it cannot verify.
  224. ### Reference-guided generation
  225. In Claude Code, give the skill a stable path:
  226. ```text
  227. /gpt-image Use @references/robot.png as the character reference. Draw it riding a bicycle.
  228. ```
  229. In Antigravity, use an explicit readable workspace path:
  230. ```text
  231. Use the gpt-image skill with references/robot.png as the character reference. Draw it riding a bicycle.
  232. ```
  233. Direct runner:
  234. ```bash
  235. node ./gpt-image/scripts/gpt_image.mjs generate \
  236. --mode generate \
  237. --prompt "Draw this character riding a bicycle." \
  238. --reference "/absolute/path/robot.png" \
  239. --out "generated-images/robot-bicycle.png"
  240. ```
  241. ### Edit and continue editing
  242. First edit:
  243. ```bash
  244. node ./gpt-image/scripts/gpt_image.mjs generate \
  245. --mode edit \
  246. --prompt "Replace the bicycle basket with a small wooden crate." \
  247. --edit-target "generated-images/robot-bicycle.png" \
  248. --out "generated-images/robot-bicycle-crate.png"
  249. ```
  250. Follow-up edit—use the edited result, not the original:
  251. ```bash
  252. node ./gpt-image/scripts/gpt_image.mjs generate \
  253. --mode edit \
  254. --prompt "Make the wooden crate dark green." \
  255. --edit-target "generated-images/robot-bicycle-crate.png" \
  256. --out "generated-images/robot-bicycle-green-crate.png"
  257. ```
  258. ### Multiple references
  259. ```bash
  260. node ./gpt-image/scripts/gpt_image.mjs generate \
  261. --prompt "Use Image 1 for the character and Image 2 for the bicycle design." \
  262. --reference "/absolute/path/character.png" \
  263. --reference-role "character" \
  264. --reference "/absolute/path/bicycle.png" \
  265. --reference-role "bicycle design" \
  266. --out "generated-images/combined.png"
  267. ```
  268. ### Parallel multiple images
  269. The skill chooses one of three structures without asking the user to know the CLI:
  270. - **Shared-anchor variations:** every job reads the same existing design. Use `variation` for the same composition in different styles, or use the design as the first reference when identity moves into different scenes or layouts.
  271. - **Delegated concepts:** “different designs,” “concepts,” “directions,” “options,” or “alternatives” asks the agent to develop one complete creative prompt per output while preserving shared constraints and references.
  272. - **Repeated renders:** a count without requested differences—or an explicit request to use the same prompt—reuses the exact image prompt.
  273. For shared-anchor style variations, create a workspace-local manifest such as `image-jobs.json`:
  274. ```json
  275. {
  276. "version": 1,
  277. "jobs": [
  278. {
  279. "id": "watercolor",
  280. "mode": "variation",
  281. "prompt": "Keep the same design and render it in watercolor style.",
  282. "edit_target": "references/base-design.png",
  283. "references": ["references/watercolor-style.png"],
  284. "reference_roles": ["style reference for this output"],
  285. "out": "generated-images/design-watercolor.png"
  286. },
  287. {
  288. "id": "clay",
  289. "mode": "variation",
  290. "prompt": "Keep the same design and render it in clay style.",
  291. "edit_target": "references/base-design.png",
  292. "references": ["references/clay-style.png"],
  293. "reference_roles": ["style reference for this output"],
  294. "out": "generated-images/design-clay.png"
  295. }
  296. ]
  297. }
  298. ```
  299. Then run:
  300. ```bash
  301. node ./gpt-image/scripts/gpt_image.mjs batch \
  302. --manifest "image-jobs.json" \
  303. --concurrency 2
  304. ```
  305. Several jobs may read the same anchor safely. Attach only the style reference relevant to that output after the shared design anchor; do not attach every style reference to every job. For different design concepts, omit the shared `edit_target` and give each job its own standalone creative prompt and relevant references. Do not append “this is the Nth option”; `id` and `out` already carry that metadata.
  306. If no common design image exists, generate the first requested output and use its returned path as the anchor for the remaining parallel variants. The skill does not generate an extra hidden anchor that consumes additional subscription usage. A batch output cannot feed another job in that same batch; mixed workflows run ready jobs in stages.
  307. Each job returns its own `PATH[id]` and `MARKDOWN[id]`. The runner does not retry a failed image generation, run a model fallback, or switch to the Images API when a subscription limit is reached. See [Image and reference workflows](./gpt-image/references/image-workflows.md#multi-image-workflows) for independent-concept and mixed-dependency examples.
  308. ### Optional troubleshooting
  309. ```bash
  310. node ./gpt-image/scripts/gpt_image.mjs doctor --json
  311. node ./gpt-image/scripts/gpt_image.mjs guide
  312. node ./gpt-image/scripts/gpt_image.mjs capabilities --json
  313. node ./gpt-image/scripts/gpt_image.mjs inspect --input "generated-images/combined.png" --json
  314. node ./gpt-image/scripts/gpt_image.mjs plan --prompt "test" --reference "/path/reference.png" --out "generated-images/test.png" --json
  315. # Check sign-in and paths without creating an image:
  316. node ./gpt-image/scripts/gpt_image.mjs generate --prompt "test" --out "generated-images/test.png" --dry-run --json
  317. # Check a batch manifest and scheduling without sign-in or image generation:
  318. node ./gpt-image/scripts/gpt_image.mjs batch --manifest "image-jobs.json" --check-only --json
  319. ```
  320. ## Why generated images no longer have SHA receipts
  321. SHA-256 identifies exact bytes. It is useful for proving that a downloaded installer is the same file that was inspected, but it does not tell whether a generated image followed the prompt or used a reference correctly. Requiring hashes on every input and output added work and receipt noise without improving the normal user result.
  322. Generated images now receive only lightweight file/signature checks. `verify-installers` still reports SHA-256 because installer integrity is a meaningful security use:
  323. ```bash
  324. node ./gpt-image/scripts/gpt_image.mjs verify-installers --json
  325. ```
  326. ## Subscription and privacy safeguards
  327. - Removes `OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_ORG_ID`, `OPENAI_PROJECT_ID`, and `CODEX_ACCESS_TOKEN` from Codex child processes.
  328. - Blocks generation unless redacted diagnostics establish ChatGPT authentication.
  329. - Calls `codex login status` once on the normal generation path; Codex Doctor is used only for explicit or ambiguous diagnosis.
  330. - Leaves the Codex model and built-in renderer unpinned; default `auto` requests only CLI Low reasoning from the current account-available model.
  331. - Checks authentication once for a live batch, not once per job; no diagnostic command runs per job.
  332. - Contains no OpenAI Images API endpoint or `/v1/images` request.
  333. - Never reads auth files and never writes the generated image outside the active workspace.
  334. - Never overwrites an existing image unless `--overwrite` is explicit.
  335. ## Skill best-practice checks
  336. - [x] One focused job: subscription-backed GPT image generation, workspace save, and inline preview
  337. - [x] Concise `SKILL.md` with task-specific references loaded only when needed
  338. - [x] Exact prompt fidelity with no inferred art direction
  339. - [x] Stable-path and actual-attachment contract for Claude Code references
  340. - [x] Google Antigravity global discovery with the ChatGPT-authenticated Codex bridge, not provider substitution
  341. - [x] Transparent-background routing plus PNG alpha/transparency validation on the bridge path
  342. - [x] Last-output-as-edit-target contract for follow-up revisions
  343. - [x] Direct generation by default; planning, no-image setup checks, and detailed receipts are optional
  344. - [x] Unpinned, runtime-selected Codex model with Low bridge reasoning, no embedded model catalog, and no Free-plan bypass
  345. - [x] Shared-anchor variations and independent concepts use bounded parallel batches; one auth check and zero diagnostic gates per job
  346. - [x] One-time, user-language getting-started guide with ratio and quality examples
  347. - [x] Minimal output validation without generated-image hashes
  348. - [x] Node.js 22+, macOS, Linux, native Windows, and WSL2 setup guidance
  349. - [x] Ubuntu, macOS, and Windows CI on Node.js 22 and 24
  350. - [x] A GitHub Star is opt-in and never automatic
  351. ## Update
  352. ```bash
  353. INSTALL_DIR="${XDG_DATA_HOME:-$HOME/.local/share}/gpt-image-skill"
  354. git -C "$INSTALL_DIR" pull --ff-only
  355. node "$INSTALL_DIR/gpt-image/scripts/gpt_image.mjs" bootstrap --target all --yes --json
  356. ```
  357. Native Windows PowerShell:
  358. ```powershell
  359. $InstallDir = Join-Path $env:LOCALAPPDATA "gpt-image-skill"
  360. git -C $InstallDir pull --ff-only
  361. node "$InstallDir\gpt-image\scripts\gpt_image.mjs" bootstrap --target all --yes --json
  362. ```
  363. ## Project structure
  364. ```text
  365. .
  366. ├── AGENT_INSTALL.md
  367. ├── README.md
  368. ├── generated-images/
  369. └── gpt-image/
  370. ├── SKILL.md
  371. ├── agents/openai.yaml
  372. ├── references/
  373. │ ├── image-workflows.md
  374. │ ├── platform-setup.md
  375. │ └── subscription-runtime.md
  376. └── scripts/
  377. ├── gpt_image.mjs
  378. └── validate_skill.mjs
  379. ```
  380. Official references:
  381. - [OpenAI: Image generation](https://learn.chatgpt.com/docs/image-generation)
  382. - [OpenAI: Image inputs](https://learn.chatgpt.com/docs/image-inputs)
  383. - [OpenAI: Build skills](https://learn.chatgpt.com/docs/build-skills)
  384. - [Claude Code: Work with images](https://code.claude.com/docs/en/tutorials)
  385. - [Google Antigravity: Agent Skills](https://antigravity.google/docs/skills/)
  386. - [Google Antigravity SDK: Tools and skills](https://antigravity.google/docs/sdk/tools/)
  387. ## Star the project
  388. If GPT Image Skill worked well for you, consider [starring the repository](https://github.com/GENEXIS-AI/gpt-image-skill). It helps others discover the project and supports future improvements. An agent may suggest this after a successful setup or image, but it must never click Star without an explicit user request.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.