The sticker factory

The sticker idea was not mine: a friend asked me for them, wanting a dozen or so pictures in one style, each with a different creature, all in the same format and on the same background. I could have commissioned a graphic designer and they would probably have turned out nice (a good designer does things that none of my processes will do), but I went another way, because I decided that this task was a very good opportunity to test whether it could be turned into an automation that, in a relatively short time, would generate not a few or a dozen but dozens or hundreds of stickers meeting the set criteria.

Criteria for a good sticker that a machine can check

The hardest part of the whole task turned out to be not running the model, not the hardware and not the code, but describing what a “good sticker” actually means: that the picture has exactly one creature, shown in full, not two and not a scene with several characters, that every creature has a thick, dark outline, that the colors are bright, that the whole thing is surrounded by a white border (like on stickers cut from a sheet), and that it is one sticker, not a sheet of ten. It sounds trivial until you have to write it down so that a machine can check it, and without an automatic check the whole process could not be automated, so this checking part turned out to be what the whole project depended on.

AI

Generating images locally: three computers and two models

I built an automation out of it that runs entirely on hardware in my home, that is, on three computers I use only for AI work: two of them are connected and work as one machine, which runs the language model (at the moment GLM 5.3 Flash, an open model that anyone can download and run themselves), and the third takes care of everything else, that is, images, sound and video. In this automation the language model is responsible for the ideas and for rating the finished pictures, while the drawing is done by the third computer, so everything happens locally and I pay no outside provider for individual requests.

How one sticker is made

First the language model comes up with what should be on a given sticker (if I wrote the prompt for each picture myself, I would probably end up with variants of one idea). I only set the boundaries (that it is to be an invented creature, what the style is and how the creatures should differ from one another: body shape, fur or slime, number of eyes, facial expression, dominant color and so on), and the model fills in the rest by itself, with a list in front of it of what it has already come up with in this series, which matters more than it might seem, because without that list I would probably get fifteen versions of the same creature.

In the next step the second model (the image one) draws what the first came up with, and does it on a black background, which is no accident: the sticker's white border has to be found and cut out later, and it shows best on black.

AI

Before the picture goes on for further processing, the language model takes a quick look at it, that is, it does a fast and cheap check of whether it makes sense at all and whether it is worth spending computing power on this generation. If it is not worth it, the process goes back to the start, so I don't waste computing power on pictures that already fail the set requirements at this stage, and which in effect do not become finished stickers but disappear a few seconds after being drawn.

Once the generation has passed this first approval, the actual processing begins, the most time-consuming part of the whole process: the picture is upscaled, the background is removed, and what is left lands on the target color, and two versions come out of it: the finished sticker on its background and the sticker alone without a background, which can be placed on any other background.

AI

At the end comes the final quality check, and in my view it is the most interesting element of the whole process: the language model looks at the finished picture and rates it in six categories (whether it follows the prompt, whether it keeps to the style, whether there is one creature, whether it is free of defects, whether the background is clean and whether it holds up as a picture), and these ratings are combined into one number; a value below a set threshold means the sticker does not go further: the model lists its specific flaws, and these go back to the start as an addition to the original instruction (the next generation is made knowing what went wrong last time, so it has a better chance of avoiding that particular error). Each slot in the series gets several attempts at this, and if the following generations still do not score enough points, the process lets that slot in the series go and moves on to the next one (what I care about is the quality of the final result, not generating a set number of images as fast as possible).

While writing this text I ran the whole process once more, and generating fifteen stickers took just under nineteen minutes. What matters more, apart from starting the process I did not have to give it any attention: I did not click, choose or correct anything, I just got on with something else, and in the meantime the stickers made themselves.

Where a person is still needed

After a few iterations the whole process runs very smoothly, but there is one point in it where a person is still needed, and I left it there on purpose. The final quality check rates each sticker separately and does not have the whole set in front of it, so it will catch a broken picture but will not notice that fifteen correct stickers are too similar to one another or that the whole series is in one color scheme (after the first attempt I got a series of pictures that passed the check but in which almost all the creatures were smiling). This step can be automated too (it would take extra work and probably separate algorithms comparing images within a series), but since these are stickers and not production where real money is at stake, I left a manual review at this point.

When an automation like this pays off

And here I come to what I consider the real benefit, because people usually talk about something else: this process does not win on the first sticker (on the first it probably loses), but on the hundredth, and when I change my mind. If I decide that the whole set should be in a different color scheme or that the creatures should be scarier, I edit a few sentences in the description and run it again, so what I am buying here is not so much the pictures themselves as the ability to change my mind at no cost.

The same pattern in document workflows and quality control

The stickers are only an example here, and a deliberately light one, because they make it easiest to show the whole mechanism. The pattern itself (describe the criteria so that they can be checked, generate, check cheaply, only then do the expensive part, rate the result against the criteria and send back what does not meet them) looks the same in far less showy tasks, from document and ticket workflows, through product descriptions, to quality control in manufacturing. What changes is what I count as a good result, not how the process is built.

I would not want to leave the impression that everything worked the first time, because it did not: several things in this process look different today from how they looked at the start, and each of those changes came from a specific error that I first had to see. I will write about that separately, because it is a more interesting story than this one.

In short

• To build a good automation, you have to be able to write down what result you consider good (acceptable) in such a way that a machine can do the checking.
• To produce the stickers I use two models (the language model invents and rates, the other one draws), and neither of them works without checks.
• A quick check before the time-consuming step saves a lot of work, because a pointless picture drops out before it starts using computing power.
• A rejected generation is not a loss: its flaws go back to the start as an addition to the instruction, so the next attempt knows more than the previous one.
• The model rates every sticker, but I review the whole series myself, because the model sees only single pictures. This step can be automated too (here it was not essential).
• The same pattern works beyond stickers. What changes is the definition of a good result, not how the process is built.