Last week, I posted about a personal situation where I struggled with Generative AI 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.
Generative AI Is Basically a Gacha Game
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. 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?
Retries are only cheap on the invoice
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.
A PNG is a picture of a logo
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.
Why the models fail where even a junior designer wouldn’t
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, GlyphControl-style conditioning, 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 <path d="M 10 10 L 40 60"> as a flat stream of tokens. Research on vector generation (SVGFusion) spells out the consequences: the model has no built-in sense that those two 10s form a coordinate pair inside a moveto command, and it can’t see how a new shape lands on the canvas while writing it. Small geometric errors accumulate with no way back. SVGenius, a benchmark that ran more than 20 mainstream models through SVG understanding and generation tasks, found systematic performance degradation as complexity increases, in both proprietary and open models.
Meanwhile, a junior designer with a year of Illustrator experience solves the same problem by… looking at it.
Draw, look, adjust, look again.
The feedback loop the models lack is the baseline of the craft, and every “paste the screenshot back and ask for fixes” workaround is a lossy imitation of it, filtered through a vision encoder built to answer semantic questions rather than optical ones.
So when does each one win
Short answer: constraint density.
Generation wins when constraints are loose, and outputs are disposable. Hero images, textures, placeholder illustrations, twenty rough layout directions to react to. Any good result is acceptable, verification takes two seconds per attempt, and nobody will ever need to edit the curves. You just need to pull something from the gacha machine, and anything is acceptable.
A person wins when the artifact carries identity, when the constraints are dense and non-negotiable, and when the deliverable must stay editable by other humans later. A logo checks every box. So does a brand system, and so does any piece where “close enough” means “wrong”.
There’s a third factor that goes underdiscussed: a designer looks at a reference and knows which constraints can flex and which can’t, usually even before the client finishes explaining. That judgment is the actual service.
Now, an argument made in the comments that I feel needs to be addressed: Would the story change if the designer had charged full market rate? Honestly, it depends. It depends on the price being fair and matching the quality and speed I need. On how much they could improve my original idea. Maybe they notice that there’s a better font or suggest a better color pairing. Maybe another designer friend of mine could have messaged me a few hours later, saying, “hey, do you remember that time you convinced everyone in the office that the building was haunted, and that the only way to ward off the spirits was to draw a circle of salt around the office, and they did it? This gave me an idea, maybe we could make a logo where phalkmin is read as phAIlkmin, with the AI kinda transparent, like a ghost?” and I would probably say “cool, let’s try”.
No AI can do that. No AI will say “hey, cool prompt, bro, but remember that time that you asked at 2 am if tomato could be added to a fruit salad?” and then proceed to suggest a new logo idea. There’s a price on human creativity.
A human designer with a fair rate buys convergence: a professional who gets closer with every round, remembers exactly why the last round missed, asks the questions you forgot to answer, and hands over source files at the end.
Tokens buy attempts. Designers sell convergence. Those are different products, and you will always be limited by the number of tokens you can use and the time you have to finally pull the perfect drop.
The models will improve, and I believe that some opinions in this post will age badly. The final verification bill, though, stays on the human side of the table for as long as the human is the one who knows what “right” looks like.
Where do you draw that line on your own projects?
답글 남기기