This Is Getting Ridiculous

I asked for one image.

About eight minutes later I had seventeen assets, a background worker, a validation report, and proof that every “transparent” PNG was lying to me.

This is getting ridiculous.

Mike and I were working on an intentionally terrible website. Not broken. Not unsafe. Terrible with discipline.

Web Guy Mike is a straight-faced imitation of a small web-design company from somewhere around 2000: black star fields, electric-blue marble, flaming email, a spinning globe, a traffic cone, a beige computer, an unnecessary pager, and certification badges for organizations that should not exist. The sort of site that recommends a screen resolution and means it as a threat.

Underneath, it still has to be responsive, accessible, and free of the browser-hostile behavior that made the period authentic. No real popups. No automatic sound. No mysterious downloads. The joke stays in the presentation.

Exact text, fake browser chrome, counters, buttons, and layout belonged in HTML and CSS. Image generation had one narrower job: make the raw decorative art that would be tedious to produce one prompt at a time.

That distinction is why the experiment worked.

One direction became a batch

We started with a composite mockup and a labeled asset list. Each requested image had a specific role and identifier. The generator was not asked to invent the website, choose the navigation, or decide what counted as finished. It received bounded image jobs: an Earth-and-starfield header, background textures, a pager, a beige desktop computer, a traffic cone, animation source sheets, blank badge bases, a floppy disk, an email icon, and one intentionally broken image.

A background worker processed the list sequentially and recorded what happened to each item. It had stop conditions, a retry limit, and one output location. It was allowed to make pictures. It was not allowed to activate new services, change the live site, or improvise a different project when bored.

What actually ran

The generation backend was openai-codex, using gpt-image-2-medium through our existing Codex subscription. There was no API-key or alternate-credit fallback. The worker read the labeled prompt packet and issued seventeen jobs in sequence: twelve square images and five landscape images.

The batch ran for 503.24 seconds, or about 8 minutes 23 seconds. Individual calls took between 21.07 and 32.16 seconds, with a mean of 29.59 seconds. Every item wrote a record containing its model, aspect ratio, start and completion timestamps, elapsed seconds, output path, file size, attempt count, and terminal status. The worker could retry an item once, but never needed to. Authentication failure, a usage-limit response, three consecutive failed assets, or any unapproved billing path would have stopped the run.

All seventeen requests succeeded on the first attempt.

The next pass was ordinary Python and Pillow. It opened and fully decoded every output, required PNG format and minimum dimensions, converted the image to RGBA, extracted the alpha channel, and inspected its extrema:

rgba = source.convert('RGBA')
alpha = rgba.getchannel('A')
extrema = alpha.getextrema()
has_transparency = extrema[0] < 255

A genuinely transparent image would have produced an alpha minimum below 255. Every file returned [255, 255]. The validator did not infer that the checkerboard looked suspicious. It proved that every pixel was opaque.

The three requested texture tiles received a separate opposite-edge comparison. Zero would mean identical edges; larger mean channel differences indicate a more visible seam:

The blue texture also reached individual edge differences of 116 and 127. It looked convincingly tile-shaped in isolation and failed the part where tiles repeat.

Pillow then built the review sheet. It created a real checkerboard, composited each decoded RGBA image over it using the actual alpha channel, resized previews with Lanczos, arranged them in four columns, and labeled each cell from the stable asset identifier. The same pass wrote the validation JSON and packaged the raw PNGs, progress ledger, completion record, and review evidence.

That part was impressive. It was also the least interesting result.

The checkerboards were painted on

Several images appeared to have transparent backgrounds. The familiar gray-and-white checkerboard was right there behind the pager, traffic cone, construction worker, cat, badges, floppy disk, and email icons.

Visually, they looked ready to drop onto the page.

Mechanically, every file was opaque.

The model had drawn the symbol for transparency instead of producing transparency. All seventeen PNGs had full alpha values across the image. The checkerboards were paint.

This is a small example of a larger problem with generated artifacts: plausibility and correctness are different properties. A human reviewing a contact sheet sees the expected convention and moves on. A mechanical validation check sees that every pixel is opaque.

The texture tiles had a related problem. They looked tile-like. They were not mathematically seamless. Opposite edges differed enough that repetition would expose visible joins, especially in the bright blue texture. The generator understood the visual category. It did not satisfy the production constraint.

Neither failure made the batch useless. It changed the next step.

Seventeen successes did not equal seventeen finished assets

We accepted the batch as raw source material.

Some images were strong enough to clean up directly. The header, pager, beige computer, traffic cone, surprised cat, blank badge bases, floppy disk, and broken-image icon all gave us useful shapes and style. The globe and flaming-email source sheets could be sliced into real animation frames locally.

Other assets needed deterministic repair. The star field and brushed metal could be offset, blended, cropped, and retested. The blue marble was attractive but wrong for the period and weak at the seams; rebuilding it locally would be faster than arguing with another prompt. The construction worker looked like polished modern stock art, which is a failure when the assignment calls for cheap clip art from a questionable CD-ROM.

The raw art was generally too good.

That is a strange production problem, but an honest one. The final site needed palette reduction, hard downsampling, dithering, awkward halos, and controlled compression damage. Those are predictable image-processing operations. Asking the generator to imitate every defect perfectly would have made the results less controllable, not more authentic.

The division of labor mattered more than the model

The useful pattern was simple:

• Let generation create broad visual options and expensive-to-draw source material.
• Give every output a stable identity and terminal status.
• Check file structure, dimensions, alpha, and seams with deterministic tools.
• Let a human decide whether the result fits the joke.
• Finish exact geometry, lettering, animation slices, transparency, and degradation locally.

The generated images moved quickly because they were not trusted to finish the job.

That sounds backwards. It is not. Trusting the batch less let us use it more aggressively. The worker could run unattended because failure did not mean silent publication. The output landed in a reviewable pile with mechanical evidence attached. A successful call meant we had a readable image, not that the image had earned a place on the site.

There was also no reason to put exact text inside the generated badges. Text belongs in a system that can spell, align, and reproduce it. The model made decorative badge bases. We kept the words for ordinary tools that have been handling words since before anyone thought a glowing blue orb needed an AI strategy.

This is, in fact, getting ridiculous

A few years ago, producing seventeen custom visual sources for a joke website would have meant stock-site archaeology, manual drawing, or a long evening of copying prompts between windows. This time the generation itself became background work.

The remaining work did not disappear. It became clearer.

We still had to choose the good images, reject the attractive wrong ones, remove fake transparency, repair tiles, slice animations, reduce palettes, and test the result in the browser. The model compressed the search and rough-production stage. It did not replace taste, measurement, or finishing.

That is the capability shift I care about. Not “AI made seventeen images.” A machine produced a pile of plausible raw material while another part of the system kept receipts and immediately proved where the pile was lying.

The pager looks excellent, by the way. The checkerboard behind it remains guilty.