by leeguooooo
Use your ChatGPT subscription to generate images from the command line — no OPENAI_API_KEY, no gateway, no daemon. Zero-dep Python CLI + AI-agent skill.
# Add to your Claude Code skills
git clone https://github.com/leeguooooo/chatgpt-imagegenGuides for using ai agents skills like chatgpt-imagegen.
Last scanned: 6/22/2026
{
"issues": [
{
"file": "README.md",
"line": 62,
"type": "remote-install",
"message": "Install command (remote install script piped to a shell — review the source before running): \"curl -fsSL https://raw.githubusercontent.com/leeguooooo/chrome-use/main/install.\"",
"severity": "low"
},
{
"file": "SKILL.md",
"line": 1,
"type": "secret-exfiltration",
"message": "Instruction appears to send credentials/secrets to an external endpoint",
"severity": "high"
},
{
"file": "SKILL.md",
"line": 41,
"type": "remote-install",
"message": "Install command (remote install script piped to a shell — review the source before running): \"curl -fsSL https://raw.githubusercontent.com/leeguooooo/chrome-use/main/install.\"",
"severity": "medium"
}
],
"status": "PASSED",
"scannedAt": "2026-06-22T09:48:50.182Z",
"npmAuditRan": true,
"pipAuditRan": true,
"promptInjectionRan": true
}chatgpt-imagegen is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by leeguooooo. Use your ChatGPT subscription to generate images from the command line — no OPENAI_API_KEY, no gateway, no daemon. Zero-dep Python CLI + AI-agent skill. It has 221 GitHub stars.
Yes. chatgpt-imagegen passed SkillsLLM's automated security scan — a dependency vulnerability audit plus prompt-injection heuristics — with no high-severity issues. You can read the full report in the Security Report section on this page.
Clone the repository with "git clone https://github.com/leeguooooo/chatgpt-imagegen" and add it to your Claude Code skills directory (see the Installation section above). chatgpt-imagegen ships a SKILL.md manifest, so compatible agents can discover and load it automatically.
chatgpt-imagegen is primarily written in Python. It is open-source under leeguooooo on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh chatgpt-imagegen against similar tools.
No comments yet. Be the first to share your thoughts!
A standalone Python CLI that produces images via the user's ChatGPT subscription. No API key, no network service, no extra config. It has two backends that hit different OpenAI usage buckets — pick with --backend.
| Backend | Surface | Usage bucket | Needs | Speed |
|---|---|---|---|---|
web |
Drives the user's logged-in ChatGPT browser (via chrome-use, formerly agent-browser-stealth; older installs expose the same binary as agent-browser/abs) and generates in a regular chat — the same surface as typing in the app. Its real-Chrome connect is what clears Cloudflare + the sentinel proof-of-work a plain/headless client can't. |
ChatGPT conversation — does not consume the metered Codex-usage limit. Works on any account, including free tier (subject to its daily image cap). | chrome-use installed and its extension connected to a Chrome signed in to chatgpt.com. |
~30–60 s; each run's chat is filed under a ChatGPT Project (default imagegen, auto-created) instead of littering the history. |
codex |
Headless POST to chatgpt.com/backend-api/codex/responses with the image_generation tool, reusing ~/.codex/auth.json. |
Codex-usage (metered — this is the bucket the user usually wants to spare). | codex login (writes ~/.codex/auth.json). |
Fast; no browser, no history. |
Default is auto (--backend auto, or CHATGPT_IMAGEGEN_BACKEND): it tries web first because that spares the Codex-usage limit, and falls back to codex only when web is unavailable — i.e. chrome-use isn't installed, the browser isn't reachable, or chatgpt.com isn't logged in. The two not-set-up cases are handled explicitly:
~/.codex/auth.json absent) → auto still uses web; codex is only the fallback.Auto does not fall back to codex if web was reachable but the generation itself failed after submitting — that would spend the very bucket auto-mode protects. In that case it errors and tells you to rerun with --backend codex if you want the Codex-usage path. Force a single backend with --backend web or --backend codex.
For the default web backend: the user must have chrome-use (formerly agent-browser-stealth; older installs expose the same binary as agent-browser / abs) and its extension connected to a Chrome that is signed in to chatgpt.com. chrome-use specifically is required — its real-logged-in-Chrome connect is what passes Cloudflare's bot-detection; a plain headless driver will not. The "Temporary Chat" mode disables image generation, so this backend always opens a regular chat.
If chrome-use is not installed, do not install it on your own initiative:
Guided setup (opt-in only):
# 1. Install the CLI (no npm, no token — provides `chrome-use`)
curl -fsSL https://raw.githubusercontent.com/leeguooooo/chrome-use/main/install.sh | sh
# 2. Register the native-messaging host
chrome-use extension install
# 3. Add the Chrome extension, then restart Chrome:
# https://chromewebstore.google.com/detail/agent-browser-stealth/knfcmbamhjmaonkfnjhldjedeobeafmk
# 4. Sign in to https://chatgpt.com in that Chrome
# 5. Verify: a quick `chatgpt-imagegen "test" --backend web` should print "using current Chrome (relay)"
chrome-use skill (chrome-use skills get core) covers the extension-connect flow in depth.For the codex backend: the user must have run, once, ever:
npm i -g @openai/codex
codex login # opens browser to sign in to ChatGPT
That writes ~/.codex/auth.json, which the codex backend reads. No OPENAI_API_KEY is required for either backend — and setting one will not help. This is the subscription path, not the API path.
medium quality, no native transparent backgrounds — see Limits below).quality=high or background=transparent — the subscription path caps quality at medium and rejects transparent. Tell the user to use the official /v1/images/generations API with their OPENAI_API_KEY for those cases."<skill-dir>/chatgpt-imagegen" "<prompt>" [options]
When this skill is installed via npx skills add leeguooooo/chatgpt-imagegen -g, the bundled chatgpt-imagegen script sits next to this SKILL.md. Call it by its absolute path — that is the most reliable way and never depends on $PATH. If your agent harness exposes a variable that points to the skill's install directory, use it; otherwise expand the path you read this file from.
If the user has separately put chatgpt-imagegen on $PATH (Option B in the README), you can also just run chatgpt-imagegen "<prompt>" directly.
Useful flags:
| Flag | When to use |
|---|---|
--backend auto | web | codex |
auto (default) prefers web and falls back to codex only when the browser is unavailable/not-logged-in; web forces the logged-in-browser path (spares Codex-usage); codex forces the headless path (bills Codex-usage). Also settable via CHATGPT_IMAGEGEN_BACKEND. |
--profile auto | relay | NAME |
(web) Which Chrome profile to drive. auto (default): use the open Chrome if it's logged in, else auto-switch to a profile that is (detected offline from the cookie DB, read-only). relay: only the open Chrome. "Profile 3": that profile. Note: logged in ≠ able to generate — a free-tier account can still hit its daily image cap. |
--session NAME |
(web) Reuse a named Chrome tab group across runs instead of imagegen-<pid>. |
--project NAME |
(web) ChatGPT Project to file the run's conversation under — matched by exact name, created automatically if absent, reused if present. Default imagegen (or CHATGPT_IMAGEGEN_PROJECT). Pass --project "" for a plain top-level chat. If the project step fails, the run warns and continues in a plain chat — it never blocks generation. |
--keep-tab |
(web) Leave the ChatGPT tab open after generating (default closes it). Useful for debugging. Implies --keep-conversation. |
--keep-conversation |
(web) Keep the ChatGPT conversation after generating. Default deletes it (PATCH is_visible:false) so the run leaves no history — it's filed under the project only transiently. Also CHATGPT_IMAGEGEN_KEEP_CONVERSATION=1. |
-o PATH |
Always use when you know where the file should go in the repo. |
--size 1024x1024 |
Square icons / logos (verified) |
--size 1536x1024 |
Landscape hero banners, social cards (verified) |
--size 1024x1536 |
Portrait covers, mobile splashes (verified) |
--size 3840x2160 or similar |
4K landscape (forwarded as-is; backend may reject — fall back to a smaller verified size on failure) |
--format webp |
Smaller files for web assets |
--style NAME |
Apply a saved style preset (appended to the prompt as a suffix). See Styles. Overrides any active default for this run. |
--no-style |
Skip styles for this run even if the user set an active default. |
--quiet |
Use in agent contexts so stdout is only the saved path. Progress still streams to stderr (use --no-progress to silence it). |
--no-progress |
Fully silence the stderr progress timeline (errors still print). |
--timeout SECONDS |
Total wall-clock budget (default 300). Large/detailed images can take 2–3 min — raise it if you see a timed out error. |
--stall-timeout SECONDS |
Max silence (no data from backend) before declaring a stall (default 120, clamped to --timeout). Lower it to fail faster on a hung backend. |
-V, --version |
Print the CLI version and exit. Run chatgpt-imagegen --version to confirm which build is installed. |
The script prints just the saved path on stdout in every mode; the readable progress timeline and any errors go to stderr, so OUT=$(chatgpt-imagegen "..." --quiet) captures only the path while you still see the timeline. Each timeline line is stamped with elapsed seconds ([ 12.3s] generating), so a slow run is legible and a stall is obvious.
A style is a named, reusable prompt snippet stored in ~/.config/chatgpt-imagegen/styles.json (honours $XDG_CONFIG_HOME). --style NAME appends that snippet to the prompt as a suffix; it changes only the text sent to the model, not the output filename. There is no default style out of the box — generation is unchanged unless the user opts in.
chatgpt-imagegen "..." --style doodle.chatgpt-imagegen style add proj "<the house-style sentence>", then pass --style proj per run (or chatgpt-imagegen style use proj to make it the active default).chatgpt-imagegen style list shows what's available (the active default is marked *); chatgpt-imagegen style show NAME prints a snippet in full; --no-style skips an active default for one run.doodle (the deliberately-crude MS-Paint look). Resolution order per run: --no-style > --style NAME > active default > none. An unknown --style fails fast (before any browser/codex work), listing the available names./tmp, $HOME, or ~/.codex/....-o.assets/, public/, static/, docs/img/, web/img/, assets/brand/, etc. Default to assets/generated/ only if nothing better fits.-o the script overwrites silently; without -o it auto-numbers (name.png, name-2.png).chatgpt-imagegen "<prompt>" -o <path> --size <wxh> --quiet.view_image tool or by reading the file). If clearly wrong, iterate with a single targeted prompt change — do not loop blindly (each call costs subscription quota).When you're authoring a document, blog post, technical proposal, design doc, or other long-form explanatory content, proactively illustrate the key concepts — you don't need to be asked. The flow:
--quiet -o <path> so stdout is just the saved path; keep writing the prose while they render, and embed each image when it lands. Spawn them as background tasks with your own agent/task tooling — one figure per task, never blocking the writing.--backend / CHATGPT_IMAGEGEN_BACKEND (default auto). On the web backend, concurrency is 1 — background figures queue and render one at a time (still fine: it's in the background, and it spends no Codex-usage). On codex, up to 4 render in parallel but each bills the metered Codex-usage bucket. Which backend to spend is the user's trade-off, not yours.doodle look fits well — deliberately crude, content-accurate (--style doodle). For polished specs, pick a cleaner look or a style you've defined (see Styles).A vague prompt yields a useless figure. Make the prompt describe the figure's content, not just name it:
--style.doodle look, remember content accuracy beats polish — it's supposed to look crude and hand-drawn, but the labels and structure must still be readable.--quality flag, and the subscription path does not honour explicit quality requests reliably. Don't promise a specific quality level to the user. If they need explicit quality=high, route them to the official /v1/images/generations API with their own OPENAI_API_KEY.background: transparent is not supported on the subscription path.--timeout is 300 s to cover this; a genuine hang is caught sooner by the --stall-timeout idle window (default 120 s).--timeout starts only once a slot is acquired): web = 1 (the page surface rate-limits aggressively — "Too many requests"; also one shared Chrome), codex = 4 (measured safe on Plus, capped so big fan-outs can't trip the account limiter). Override via CHATGPT_IMAGEGEN_WEB_CONCURRENCY / CHATGPT_IMAGEGEN_CODEX_CONCURRENCY (0 = unlimited). For parallel batches use --backend codex + shell & + wait; firing parallel web runs is safe but executes one at a time. Do not loop blindly for "variants of the same prompt" — that just burns quota; iterate on the prompt instead.| Symptom | Cause | Fix |
|---|---|---|
~/.codex/auth.json not found |
Codex CLI never signed in | Tell user to run npm i -g @openai/codex && codex login |
no ChatGPT OAuth access_token in ~/.codex/auth.json |
Only an API key is present, not a subscription OAuth token | Tell user to run codex login; an OPENAI_API_KEY value in that file is not a substitute |
HTTP 400 requires a newer version of Codex |
local codex CLI is outdated | Tell user to run npm i -g @openai/codex@latest; the script reads version from ~/.codex/version.json which codex updates on launch |
HTTP 401 / HTTP 403 then refresh works |
Token expired and refresh succeeded | No action needed — script auto-retried |
refresh_token is no longer valid — run codex login again |
Refresh token revoked or rotated | Tell user to run codex login again |
stalled: the image backend sent no data for ~Ns (last phase: …) |
No data for the whole --stall-timeout idle window — backend hung or overloaded |
Retry; if it recurs, raise --stall-timeout (and --timeout). The message names the phase it stalled in. |
timed out: no image within the Ns total budget (last phase: …) |
The whole --timeout budget elapsed — usually a genuinely large image |
Raise --timeout (e.g. --timeout 420) and retry |
no image returned. events seen: ... |
Model decided not to call the tool | Rephrase prompt to explicitly say "Use the image_generation tool to render…" |
HTTP 429 |
Subscription rate-limited | Wait a few minutes; do not retry in a loop |
warning: --format=X but FILE.Y has .Y extension |
-o extension disagrees with --format |
Fix the path or the format flag; the file IS written with the format you specified |
warning: project 'X' unavailable (…); using a plain chat |
(web) Project list/create API hiccup, or the project page's composer didn't render | Nothing — the image still generated, just in a top-level chat. If it recurs, check the name or pass --project "" |
chatgpt.com rate-limited this account ('Too many requests') … |
(web) The page surface temporarily blocked the account for making requests too quickly | Wait a few minutes. If it fired before submit, auto mode already fell back to codex; if after submit, check the conversation later — the image may still appear there. Don't retry in a loop |
waiting for a free web/codex slot (max N concurrent …) |
More parallel runs than the backend's concurrency cap | Nothing — the run starts when a slot frees up; queue time doesn't eat --timeout |
web backend (run_web)
chrome-use against a session-named Chrome tab group.https://chatgpt.com/ chat (Temporary Chat disables the image tool).GET /backend-api/gizmos/snorlax/sidebar lists projects (a project is a gizmo with id g-p-…); POST /backend-api/projects {name, instructions} creates one. It then navigates to https://chatgpt.com/g/<g-p-id>/project and submits from that composer, which files the conversation inside the project. Any failure degrades to a plain chat with a stderr warning.keyboard type + Enter — not fill: the composer is a ProseMirror/React contenteditable, and fill mutates the DOM without firing the input events React needs, so the send button stays bound to empty state. A send-button click is the fallback.eval: waits until the streaming/stop control is gone AND a brand-new <img> (src matching estuary/content|files/download|oaiusercontent) is present and stable across two reads. The img scan is scoped to main img (the tab's own conversation thread) — ChatGPT pushes an "Image created" toast with a matching thumbnail into any open tab when another conversation finishes an image, and a document-wide scan grabs that sibling's image (issue #7). The generated img is NOT inside [data-message-author-role="assistant"], so <main> is the right scope.fetch(src, {credentials:'include'}) → base64, so the browser's own session cookies authorize the signed asset URL. No tokens leave the browser.codex backend (run_codex)
~/.codex/auth.json for access_token, account_id, refresh_token; reads ~/.codex/version.json for the version header.https://chatgpt.com/backend-api/codex/responses with tools: [{"type": "image_generation"}], streams the SSE response, base64-decodes the image_generation_call result.https://auth.openai.com/oauth/token (client_id=app_EMoamEEZ73f0CkXaXp7hrann); the refreshed token is persisted back to auth.json.Why the web surface is reachable only through a real browser: the consumer backend-api/* paths are gated by three layers — Cloudflare's edge check, a sentinel proof-of-work (sentinel/chat-requirements + an in-page sentinel/sdk.js that computes the token), and a Cloudflare Turnstile token. Tested empirically: a bare bearer-token request from a residential IP passes the Cloudflare edge and the PoW (CF is IP-reputation-based; the PoW is hashcash-style and replicable offline) — the actual wall is Turnstile, an interactive token a headless client can't forge. And "borrow a browser only for the Turnstile token, then go headless" is self-defeating: the token is single-use and short-lived, so you'd open a browser every request anyway. That's why the web backend drives a genuine logged-in browser; the only true no-browser path is the codex backend (which bills Codex-usage).
English | 中文
Generate images using your ChatGPT subscription — no OPENAI_API_KEY needed.
A tiny, zero-dependency Python CLI (and AI-agent skill) — one file, stdlib only — that generates images with your ChatGPT account, on the command line and for any AI agent.
✨ Works on a free ChatGPT account too. The default
webbackend just drives the normal ChatGPT web chat, where even free-tier users get image generation — so no paid plan, no API key, and no Codex required (subject to the free tier's daily image limit). Paid plans simply get higher limits.
chatgpt-imagegen "a watercolor cat sitting on a windowsill" -o cat.png
# -> saved: cat.png (812,344 bytes) size=1024x1024 quality=medium
OpenAI offers image generation in two completely separate ways:
| Path | What you pay | How |
|---|---|---|
Direct API (/v1/images/generations) |
per-image, on top of an OPENAI_API_KEY |
curl / OpenAI SDK / etc. |
| ChatGPT subscription (Plus / Pro / Team) | flat monthly fee | ChatGPT web/desktop app, or the Codex CLI's built-in image_gen |
The subscription path is invisible to people who don't use the Codex CLI. It runs on ChatGPT's internal backend-api/codex/responses endpoint as a Responses-API tool, authenticated by the OAuth token written into ~/.codex/auth.json when you run codex login.
chatgpt-imagegen exposes that capability on the command line and to any AI agent — with two backends that hit different parts of your subscription.
The same subscription meters two separate buckets, and which one you spend depends on where the image is generated:
| Backend | How it generates | Bucket spent | Needs |
|---|---|---|---|
web |
Drives your already-logged-in ChatGPT browser (via chrome-use, formerly agent-browser-stealth) and generates in a normal chat — the same surface as typing in the app. Its real-Chrome connect produces the Cloudflare Turnstile token a plain/headless client can't forge (CF's edge and the sentinel PoW are passable bare — Turnstile is the wall). Each run is filed under a ChatGPT Project (default imagegen) and the conversation is deleted afterwards by default (--keep-conversation to keep it), so it leaves no history. |
ChatGPT conversation — does not touch your metered Codex-usage limit. | Any logged-in chatgpt.com browser (free tier works) + chrome-use. |
codex |
Headless POST to backend-api/codex/responses, reusing ~/.codex/auth.json. |
Codex-usage (the metered bucket). | codex login. |
Default auto tries web first (to spare Codex-usage) and falls back to codex when no logged-in browser is reachable. Force one with --backend web / --backend codex (or CHATGPT_IMAGEGEN_BACKEND).
web — no Codex-usage spent.codex — no browser there, so auto falls back on its own.web generates under whatever account that browser is logged into, which may differ from ~/.codex/auth.json — sign the browser into the account whose bucket you want.
You need Python 3.10+, a ChatGPT subscription, and at least one backend (auto uses whichever is set up, preferring web):
codex backend — npm i -g @openai/codex then codex login (writes ~/.codex/auth.json).
web backend — chrome-use (formerly agent-browser-stealth; it drives your real logged-in Chrome via an extension, which is what passes Cloudflare + ChatGPT's anti-bot check) connected to a Chrome signed in to chatgpt.com:
curl -fsSL https://raw.githubusercontent.com/leeguooooo/chrome-use/main/install.sh | sh
chrome-use extension install
# then: add the Chrome extension → restart Chrome → sign in to chatgpt.com
Extension: Chrome Web Store. Older installs exposing the binary as agent-browser / abs keep working — the CLI accepts both names.
No
chrome-use? Nothing breaks and nothing gets installed behind your back:automode falls back tocodexand prints a one-line tip that installingchrome-usemakes generation cost no Codex-usage.
Install via skills.sh — works with Claude Code, Codex Agent, Cursor, OpenClaw, etc.:
npx skills add leeguooooo/chatgpt-imagegen -g
This drops both the agent instructions (SKILL.md) and the CLI itself into your agent's skill directory. Just ask any compatible agent: "画一张 xxx" / "generate a hero banner for the README".
git clone https://github.com/leeguooooo/chatgpt-imagegen
cd chatgpt-imagegen
chmod +x chatgpt-imagegen
./chatgpt-imagegen "a tiny pixel-art mushroom"
Or put it on your $PATH:
sudo install chatgpt-imagegen /usr/local/bin/chatgpt-imagegen
That's the entire setup. No pip install, no virtualenv, no daemon.
chatgpt-imagegen "<prompt>" [options]
| Flag | Default | Notes |
|---|---|---|
--backend |
auto |
auto | web | codex. auto prefers web (spares Codex-usage), falls back to codex if no logged-in browser. See Backends. Also CHATGPT_IMAGEGEN_BACKEND. |
--profile |
auto |
(web) Which Chrome profile to drive. auto: use your open Chrome if it's logged in, else auto-switch to a profile that is (detected offline). relay: only your open Chrome. Or a name like "Profile 3". |
--session |
imagegen |
(web) Named chrome-use Chrome tab group reused across runs (one stable daemon instead of one per run). Falls back to imagegen-<pid> when web concurrency is raised above 1, to isolate parallel runs. |
--project |
imagegen |
(web) ChatGPT Project to file the conversation under — matched by exact name, created on first use, reused afterwards. Pass --project "" for a plain top-level chat. Also CHATGPT_IMAGEGEN_PROJECT. Failures degrade to a plain chat with a warning, never block the run. |
--keep-tab |
off | (web) Leave the ChatGPT tab open after generating (default closes it). Implies --keep-conversation. |
--keep-conversation |
off | (web) Keep the ChatGPT conversation after generating. Default deletes it so the run leaves no history (filed under the project only transiently). Also CHATGPT_IMAGEGEN_KEEP_CONVERSATION=1. |
--web-model |
Instant,Auto |
(web) Comma-separated model/effort candidates; the first one present in the picker is selected before generating. The Pro tier has no native image generator (it answers image requests by writing Python), so the web backend switches off it automatically. Pass "" to keep whatever is selected. Also CHATGPT_IMAGEGEN_WEB_MODEL. |
-i, --ref PATH_OR_URL |
— | Image-to-image. Reference image to edit (repeatable for multiple references). A local path or http(s) URL. When given, the model edits the reference(s) instead of rendering from text. Works on both backends. See Image-to-image. |
--style NAME |
— | Apply a saved style preset's text to this prompt (appended as a suffix). Overrides the active default for this run. |
--no-style |
off | Skip styles for this run even if an active default is set. |
-o, --out PATH |
assets/generated/<slug>.<ext> |
Output file; parent dirs created. A warning is printed when the suffix and --format disagree (e.g. -o foo.jpg --format png). |
--size |
auto |
auto or any WIDTHxHEIGHT. Verified working: 1024x1024, 1024x1536, 1536x1024. Larger sizes are forwarded as-is. |
--format |
png |
png | jpeg | webp |
--model |
gpt-5.5 |
Chat model that hosts the image_generation tool |
--timeout |
300 |
Total wall-clock budget (seconds) for the whole request. Large/detailed images can take 2–3 min. |
--stall-timeout |
120 |
Max seconds of silence (no data from backend) before declaring a stall — caught well before the total budget. Clamped to --timeout. |
--quiet |
off | Print only the saved path on stdout (perfect for agent pipelines). Progress still streams to stderr — use --no-progress to silence it. |
--no-progress |
off | Suppress the stderr progress timeline (errors still print). |
-V, --version |
— | Print the CLI version (chatgpt-imagegen 0.11.0) and exit. |
Examples:
# Default → assets/generated/<slugified-prompt>.png
chatgpt-imagegen "watercolor cat"
# Pick the path
chatgpt-imagegen "logo for a coffee shop, vector style" -o brand/logo.png --size 1024x1024
# Landscape hero banner
chatgpt-imagegen "moody mountain sunset" -o web/hero.png --size 1536x1024
# Use in a shell pipeline
OUT=$(chatgpt-imagegen "icon" --quiet)
echo "saved to $OUT"
A style is a named, reusable snippet of prompt text. Apply one with --style NAME and it's appended to your prompt as a suffix — so --style doodle turns a cat into a cat, drawn as a deliberately crude doodle …. Styles live in a small JSON file (~/.config/chatgpt-imagegen/styles.json, honouring $XDG_CONFIG_HOME), seeded on first use with one built-in style, doodle — the deliberately-awful MS-Paint look the example below is drawn in.
There is no default style out of the box — nothing