Generative AI is a gacha game with no pity system A developer argues that generative AI is like a gacha game with no pity system, where each generation costs cents but the human judgment required to evaluate outputs can cost hours and cannot be parallelized. The developer notes that unlike gacha games, the odds of a successful generation do not improve with repeated attempts, and even a perfect result often requires manual vectorization, defeating the purpose of automation. Last week, I posted about a personal situation where I struggled with Generative AI https://dev.to/phalkmin/i-burned-through-thousands-of-ai-tokens-then-a-friend-did-it-for-free-31m8 and how I was able to fix the problem by asking if a real person could help me. I believe that some people got the point of the story, but some comments started piling up, and I thought that a full post following up on that discussion would be better than a long discussion thread. The strongest counterargument deserves to be stated properly: Inference is cheap. A hundred image generations cost less than one hour of a senior designer, and there's no dispute on that. The problem starts when you notice that the winning result might show up at attempt 2 or only at attempt 1,000, or never show at all. In a way, content generation is like a gacha game https://en.wikipedia.org/wiki/Gacha game . Every prompt is another pull. Better prompts don't necessarily guarantee the rare drop, they simply improve the odds that you'll get it before your token budget runs out. Even if you structure the first prompt like a real design brief instead of drip-feeding small corrections, a good model will often still require several tries. And you could argue "ok, but it's still cheaper than a designer", and again, sometimes that math is correct. I use GenAI myself for blog illustrations and placeholder art, where honestly even an uncommon pull in the gacha machine is a good result. But, hypothetically, what if you really need that SSR pull? That extremely rare card/item? Every attempt on GenAI needs a human on the other side to open the output, compare it against the mental picture they're aiming for, figure out what went wrong, and translate that judgment into new prompt language. The single generation costs cents. But the judgment can cost hours, and that part can't be parallelized. Run 40 attempts, and you spent much more than 40 generations: you spent an afternoon doing quality control for a machine that doesn't understand or even remember why attempt 12 failed. So not only did you spend time reviewing the art, but you also piled up frustration and stress. All these problems matter more than the price per pull. And here's one aspect where I feel that GenAI can be worse than a gacha game: Most gachas have some sort of "pity system", where you have a better chance to get a high-tier item after XX interactions. But GenAI is a gacha with no pity system. The model carries no optical judgment between attempts. Each generation samples from the same distribution, nudged by whatever words changed since the last round. When the target is "clean sans-serif wordmark", that distribution is dense with acceptable answers, and you win fast. When the target is "this exact typeface, with one letter working as two symbols at once", you're fishing in a region the training data barely covers. Attempt 400 draws from the same pool as attempt 4, and a perfectly structured brief hits the same wall, because the brief competes with the prior instead of overriding it. So, it's a gacha. But the chances won't improve as you keep playing. But OK, let's suppose that the model finally nailed it after attempt 400. Congratulations, now what you have is a raster image: pixels, at one size, on one background. A real working logo is a vector system. Editable anchor points, light and dark variants, a monogram for tight spaces, letterforms that survive both a 16-pixel favicon and a four-meter banner. Moving from the perfect PNG to that system means manual vectorization and redrawing, which lands you right back in Figma or Inkscape, doing the design work the generation was supposed to replace. "But OK, I could just ask the model to output the vector directly, right?" Right. That was my Claude experiment in the original post, and there's actual research explaining why it failed. Pixel generators learn statistical visual patterns from billions of image-text pairs and reproduce what text usually looks like in them. Typography demands stroke-level precision, and the gap between those two things is so well documented that it spawned a research subfield: TextDiffuser https://arxiv.org/abs/2305.10855 , GlyphControl-style conditioning https://arxiv.org/pdf/2605.20807 , Glyph-ByT5, and character-aware text encoders all exist specifically because base models garble letters. A letterform that must read as an h and as a / simultaneously is a constraint-satisfaction problem wearing an image-generation costume. Nothing in pixel prediction enforces "hold both meanings", so the model produces something plausible. Plausible is precisely the wrong target when the brief demands intended . Now, the vector route fails differently. An LLM writing SVG reads