Shipping sprites without drawing them
A solo dev with no pixel artist producing the assets for an idle game through a generation API. The real work isn't the generation: it's the protocol around it. Briefs, budget, selection, composition.
Zero skill, zero GPU to compensate
I can't draw. No false modesty here: zero pixel art skill, and no pixel artist in a one-person studio. Yet Idle Orbit, my space-station idle game, needs assets: seven station modules to depict, and a scene that builds up as the player progresses.
Local generation was ruled out from the start: my card tops out at 8 GB of VRAM, already cramped for everything else. That left a subscription to an external pixel-art API, PixelLab in this case. Except a subscription solves nothing by itself. It moves the problem: I no longer need to know how to draw, I need to know how to place an order. And that, I learned by paying.
Two protocols in the bin before the right one
My first protocol generated isolated 64x64 assets, then composed them into three visual tiers per module (T1, T2, T3): every building was supposed to evolve graphically. The second aimed at an ambitious, cumulative mega-scene with stacking visual tiers. Both went in the bin for the same reasons: too many credits burned, too much variance between generations. Every extra asset was one more chance for the AI to drift off-style.
The v3 protocol, the one that held, is brutally simpler: one single asset per module, seven assets for the whole zone. No visual tiers, no evolution. The asset appears on the scene when the player acquires the module, full stop. The lesson landed before the first line of prompt engineering: shrinking the generation surface pays more than optimizing the prompts.
A brief validated before every credit
The per-module protocol starts with what costs nothing: a short brief, 500 to 1500 characters of description, under 200 for the palette. Those bounds aren't zeal, they're the API's hard limits: past 2000 characters of description or 200 of palette, it returns an HTTP 422. The brief describes the silhouette, the expected position on the base, the spatial constraints, the game's palette. And it gets validated before spending a single credit.
Only then: one paid call, exactly one. Selection happens on a 6x-zoomed comparison grid of the eight latest versions. If the result fails, one retry maximum, hard cap. On the budget side, my homemade runner refuses any paid call without two explicit flags, --live and --confirm-spend, with the token kept in an environment variable. The result at this point in production: roughly 160 credits spent, zero budget accident.
The gotchas paid for in full
The API shows an estimate of 30 to 90 seconds per generation. Reality: 3 to 8 minutes. Not dramatic, but any workflow timed against the official estimate collapses, and you learn to fill the wait differently.
More expensive: generated tiles come out with a dark border that makes them unusable laid in a grid, they draw visible gridlines across the whole map. And the canvas drifts: asking for a 52x52-pixel main element doesn't guarantee you get one. My countermeasure has two parts: a calibration table enforcing the 60/40 rule (the main element takes roughly 60% of the target bounding box, the accessory 40%), injected into every brief, and a post-generation auto-crop that trims the actual content to the target size. The comment in my docs sums up the spirit: guarantee the rule even if the AI doesn't follow it.
What the AI doesn't do
The final composition never goes through the API. Every selected asset is placed by hand in GIMP, on an anchor map that pins the exact coordinates of each module and the forbidden zones: the habitat windows, for instance, which no asset is allowed to cover. It's slow, it's manual, and it's exactly the kind of spatial decision I don't delegate to a model.
The other big piece is procedural: a Python script of roughly 600 lines of PIL that composes the tier variants from a base template, without a single AI call. Measured savings: about 120 credits per tiered module. The paradox still amuses me: the most profitable piece of my AI generation pipeline is the one that contains none.
What I take away
Generation was the easy part. The real deliverable of this project is the documents and scripts around it: a brief validated before every credit, a retry cap written down in black and white, two flags that lock the spending, a calibration table that compensates for the model's drift, and a final composition that stays human.
A generation subscription replaces the pencil stroke, not the craft. Art direction, budget arbitration and quality control didn't get outsourced: they just changed shape. If you go down this road, write the protocol before paying the first credit. That protocol is the most valuable asset in the pipeline.