Images for your project on autopilot: one style, one script

Help me write a style prompt for generating illustrations that
I'll reuse repeatedly for [project: a personal finance blog].

What I know about the visuals:
- I want [a hand-drawn-looking line drawing], not photorealism
- palette: [white background, dark gray line, a single brick-red accent]
- mood: [sober, matter-of-fact, slightly playful, definitely not corporate]
- the images will run as [an article header image at a 16:9 ratio],
  with [a headline] running over the top third, so that area needs
  to stay calm
- target audience: [people 30-50 years old, US readers]

Write the style prompt in English, structured into blocks:
technique, composition, color palette, light, mood, and a separate
block of prohibitions (what should never appear in the image).

In the prohibitions block, include things I wouldn't have thought
of but that usually cause problems for this type of illustration.
For each prohibition, write one sentence on why.

Finally, give me three questions I need to answer before I start
using this style on a whole series.

I have this style brief for illustrations:

[paste the style prompt]

Generate a list of five as-different-as-possible motifs to test
this style on — deliberately ones where the style might break:
something abstract, something with a figure, something technical,
something with a landscape or space, and something where the model
might be tempted to fall back on text or numbers.

For each motif, write one sentence of description I'll append to
the style brief, and note what I should watch for in the result.

Write me a script that generates illustrations through the image
API of [name of the service I'm using]. I don't know how to
program, so along with the code write me a step-by-step guide of
what to install and how to run it — on [macOS / Windows].

The script should:
1. load the style brief from a file called style.txt (don't
   change it, just append to it)
2. take a motif description from a command-line argument
3. assemble the final prompt as: style brief + blank line + motif
4. call the API and generate [3] variants
5. save them to an output/ folder named [slug]-1.png, -2.png, -3.png
6. convert each one to WebP at 1200px wide, quality around 80
7. keep the original PNGs in output/raw/ in case I need to
   regenerate later
8. write to a log.csv file: date, slug, motif, model, image count

Requirements:
- load the API key from an environment variable, never put it in
  the code
- if a call fails, retry it twice with a delay, then print a clear
  error message in plain English, not a stack trace
- if a file with that name already exists, don't overwrite it —
  ask first
- comment every step in plain English explaining WHY it's done

At the end, tell me everything that could go wrong and how I'd
notice.

Explain this script to me block by block, as if I'd never seen
code before. For each block: what happens in plain English, what
happens if there's a bug in it (do I lose files? money? just
time?), and which value in it I can safely change myself.

Point out specifically every place where files get deleted or
overwritten, and every place where a paid API gets called.

[paste the script]

Here's the text of my article:

[paste the text or the first three paragraphs]

Suggest 5 motifs for a header illustration. Conditions:
- the motif must be visually simple, describable in one sentence
- no text, numbers, or lettering in the image
- no clichés like a lightbulb for an idea, gears for a process, an
  arrow going up for growth, or a puzzle piece for collaboration
- the motif should relate to the specific content of the article,
  not the topic in general

For each one, write:
1. one sentence in English I'll append to the style brief
2. why it fits this particular article
3. the risk — where the model might get it wrong

Rank them from least to most clichéd.

Extend my script with a batch mode.

The input will be a motifs.csv file with columns:
slug ; motif ; note

The script should:
- go through the rows one by one and generate [2] variants for each
- save them as [slug]-1.webp and [slug]-2.webp
- skip a row if the file already exists, and write one line to
  the console about it (I want to be able to rerun the batch
  without paying again for what I already have)
- pause briefly between calls, so the service doesn't rate-limit me
- if one call fails, keep going and list the failed rows at the
  end in a file called errors.csv

At the end, print a summary: how many images were made, how many
were skipped, how many failed, and an estimate of how many API
calls the whole thing cost.

Add a flag that does a dry run of the batch, printing what it
would do without generating anything.

Here's my current style prompt:

[paste the style prompt]

Here's what I don't like about the results: [e.g. the images feel
too empty, the motif gets lost, the accent color is used
randomly].
What I want to keep: [e.g. the cleanliness, the single color, the
white background].

Suggest 3 variants of a style tweak. For each one:
1. the full new wording of the prompt
2. exactly what changed compared to the original (list just those
   sentences)
3. what risk the change carries — what might get worse
4. how I'll know from the test set that the variant is better

Don't change more than one thing at once. Each variant should
address a single cause.

Attached are [10] illustrations from one series. They're supposed
to look like they were made by a single illustrator following this
brief:

[paste the style brief]

Do a visual audit:
1. Which images stand out, and specifically how (color, line
   thickness, level of detail, composition, mood)? Rank from most
   to least different.
2. For each one, say whether it should be regenerated or whether
   the style brief itself should be adjusted because it's a
   systemic issue.
3. Is there an element showing up across the series that I never
   asked for, yet the model keeps adding it anyway?

Don't sugarcoat it. I want a list of things to fix.

Help me set up an API key safely for my script on
[macOS / Windows / Linux]. I've never worked with environment
variables before.

I want:
1. a step-by-step guide for where to store the key so the script
   can see it, but it never ends up in any file I might
   accidentally publish
2. how to verify it's working without printing the key to the
   screen
3. exactly what to add to .gitignore, since the project is
   version-controlled
4. how I'd notice if I accidentally wrote the key down somewhere
   — what to search the project for
5. what to do if the key does leak: a step-by-step sequence

Write it for someone who only knows basic terminal use.

Adjust my script so I have costs under control.

Add:
1. an API call counter for a single run, printed at the end
2. a hard limit: if a run would make more than [50] calls, the
   script asks for confirmation and won't continue without it
3. logging to log.csv: date and time, slug, model, image count,
   resolution, success/error
4. a small helper command that sums up log.csv by month: how many
   images, how many calls, how many of those failed

Also tell me which places in the script could trigger an
unintended repeated call (loops, retries after an error) and how
they're guarded against it.

I want to choose an image API for this project: [description,
e.g. line-drawing illustrations for a blog, about 30 images a
month, commercial use].

Compare the available options, and for each write:
- where it's strong and where it's weak for MY type of output
- how it's billed (per image, per resolution, subscription)
- what the license terms say about commercial use of the output
- extra features I'd actually use (variants, transparent
  background, vector, composition control)
- how hard it would be to switch to it, given I already have a
  working script

End with a recommendation and one sentence why. For the license
terms, tell me where to verify the wording myself — I know it
changes, and I don't want to rely on your description.