I Ran 255 AI Agents to Make Three Comics. The Line Between Slop and Good Is Thicker Than I Thought.

Three AI graphic novels, one research question: where does the line between slop and quality actually live? What changed across 255 agents, 16M tokens, and three complete pipelines.

Slop is the word of 2025. Merriam-Webster named it their word of the year. News feeds fill with the stuff. You see it on YouTube (one study counted the first 500 Shorts served to a brand-new account: 21% were AI slop, another third adjacent brainrot), on TikTok, on Pinterest, everywhere. And nobody chose this flood. It just arrived when everyone realized you could toss a one-line prompt at an LLM, scale it to infinity with no editor, and watch the machine crank out volume. The internet now runs on the output of people who aren’t paying attention to their own work.

But “AI slop” as a category still feels fuzzy to me, like everyone uses the word for different things depending on their frustration level. So I ran an experiment: I would make the same creative thing three times, with increasing amounts of human thought, and watch the quality move. I wanted to find the boundary with my own hands, and to understand what exactly changed between “this is slop” and “this is worth looking at.”

The first comic was bad in a very specific way. Fifty pages, drawn by fifty AI agents, perfectly coordinated, visually consistent, delivered in thirty minutes with zero errors. And soulless. Barely readable. A near-copy of the TV series that inspired it. I told my agent exactly that, in exactly those words, and that feedback became round two.

Here is what I was actually testing. I have never touched the artistic side of AI. I build agents, automations, the occasional game, but generating images or anything that pretends to be art? Never pulled me. What did pull me was this question: everyone talks about AI slop like it’s one thing, one flood, one texture. One problem we all agree to hate. But I wanted to see the anatomy of slop: the actual structure that makes something slop instead of work. What do you skip, mechanically, that tips the output into that category? And more important: what do you have to actually do to undo it?

So I designed an experiment. I would make the same creative task three times: a graphic novel about ordinary people waking up with early superpowers. Same theme, similar token budgets, three completely different pipelines. Between each round I would read the whole thing and write down honestly what I thought: what specifically wasn’t working, in plain words. Then I would feed that feedback back into the next round. The three finished comics are public at wiz.jock.pl/comics, with the pipeline and the costs next to each one. You can read all three and watch the quality move.

Round 1: maximum scale, minimum thought

The setup was deliberately naive, because that is what most slop production is: naive at scale. One agent writes a 50-page beat sheet in a single pass. Fifty Sonnet agents each get one page and draw it as raw SVG code. Vector shapes, gradients, text elements. No image model. No editor. Nobody ever reads the whole thing before it ships.

The coordination was genuinely impressive from an engineering standpoint: 51 agents, 3.4M tokens, zero failures, one consistent color system across 50 isolated workers who never talked to each other. As a production system, beautiful. As a comic? It looked like a UML diagram having a nightmare. Characters were geometric mannequins. The lettering was often unreadable. The story copied its inspiration beat for beat, because my one-line brief had listed the inspiration’s plot elements: eclipse, future-painter, power-stealing villain. The writer did exactly what I asked, and the fifty downstream agents did exactly what the writer said. No deviation. No editorial judgment. No one reading the full thing and going, “This doesn’t work.”

My verdict after reading the whole 50 pages: no style, no soul, nearly a copy of the TV show. Most of that was my fault (the brief was one line, and the plot elements in it came from me). Cost of the lesson: about $0 in images and an evening of tokens. I don’t mind it. That was the point of a baseline. And this is slop in its purest form: a perfectly executed pipeline that produces output nobody would read by choice.

Round 2: fix the medium, add a critic

Two structural changes. The art moved from code-drawn SVG to an actual image model (Nano Banana Pro, about $0.14 per page), with every page agent looking at its own output and retrying if the lettering was garbled. And the script got an editorial loop: a writer drafted all 50 pages, a separate critic agent tore the draft apart systematically, the writer revised based on that feedback.

The result, “The Warm Hill”, is a quiet story about a dying Silesian mining town, a caregiver who absorbs other people’s pain into her own body, and her indebted son. The art jumped a full league. Painted, moody, consistent across all fifty pages. I liked looking at it. The image model had taste that the SVG code didn’t.

And I was bored reading it.

My own verdict: the art was much better. The story was weird and detached. Little dialogue. No action. No character building. The single critic pass had produced something literary and lifeless, like a short-story journal that nobody buys. Here is where the math got interesting: the token budget was nearly identical to round one. Roughly 3M tokens. The only differences were the medium (SVG to images) and adding one critique pass. Plus about $9 of image generation. Two rounds, nearly identical cost, an enormous quality gap between them.

So the budget was never the knob that mattered. I had been thinking about scale wrong the whole time. You can throw more tokens at a bad process and all you get is a bigger version of bad. The variable was how much judgment touched the work.

Round 3: I finally did my part

Both earlier rounds failed where I had been lazy. In round 1, I gave the system a one-line prompt and let it run. In round 2, I added feedback but the feedback was shallow and the brief was still one line. That’s why for the final round I changed my own input completely. No more phone-it-in briefs.

I spent twenty minutes writing a real creative brief instead of a line. Powers at generation zero: a strong man lifts a car for four seconds and tears his tendons doing it. Powers learned like skills, with failed experiments on the page so the reader sees the cost. Disconnected storylines across five countries that converge because one weak power, a woman who finds people through dreams, slowly learns to aim her gift. A morally grey antagonist: a company founded by someone with a power, containing people like her, and holding one genuinely good argument (they found a man whose body brews a lethal virus). Inspiration allowed. Copying banned.

The pipeline grew judgment layers to match. The script went through two separate critique passes, not one: one for structure and character arcs, one only for dialogue, action choreography, and pacing. Sixty-five art agents each directed their own page and QC’d the output with their own eyes. Then a layer that didn’t exist before: editor agents read every finished chapter as drawn, like a reader would, and ordered redraws of pages that failed. They caught things I would have missed myself: a boy drawn as a grey-haired adult in a flashback. Script stage directions leaking into speech balloons. One caption of pure gibberish. They sent those pages back for revision.

The result is “Small Hours”. 65 pages, five countries, a painted cover, chapter title cards. My honest verdict: much better. The first one that reads like an actual comic with stakes. Still imperfect. Faces drift between pages in places. A few typos survived the final review. It would need more rounds and more back-and-forth to be truly done. I am completely aware of that.

But put round 1 and round 3 side by side and the quality gap is impossible to miss. And here is the thing that stayed with me: round 1 and round 2 cost roughly the same. Round 3 cost more tokens (because of the extra critique passes and the reviewer layer), but not proportionally more. The jump between 1 and 2 happened for free. The jump between 2 and 3 came from me spending twenty minutes being thoughtful instead of a minute writing a prompt.

The technical guts, for those who want them

Everything ran on Claude Code Workflows: deterministic scripts that fan out subagents, so loops and phases are code while judgment stays in the models. Model assignment per role mattered a lot, same logic as when I matched models to jobs in my agent:

Character consistency across 65 independently generated pages came from strict textual tokens pasted verbatim into every prompt. A real one from the book: “Tomasz Wierzbicki, big, blond stubble, grey beanie, orange hi-vis vest over navy overalls, dog tags, bandaged left forearm.” Hex codes for palettes, one committed art direction string reused everywhere, and a per-thread lighting accent so Lagos never looks like Gdansk.

The full three-round bill:

Failures worth sharing, because they always are. My OpenRouter account died mid-run at exactly $100.02 of $100.00, stranding the book at 23 of 65 pages; the agents degraded gracefully and saved their finished prompts to disk as blocked-files, so after a top-up the resume was mechanical. The card agents also discovered that my image script had been silently ignoring its aspect-ratio flag for weeks. And the funniest failure class: the image model kept rendering script speaker labels inside speech balloons, so a market scene proudly displayed “ABUELA: LADRON!” until a reviewer caught it. Every one of these got caught by an agent, which is its own small argument for judgment layers.

The thick line

I went in expecting a thin line, something you cross by accident. What I found is thick, visible, and easy to see. It sits exactly where human input sits. And it splits into three places where a human has to stop what the machine is doing and actually decide something.

First, the medium itself. SVG code versus an image model. This choice decides more than it looks. SVG code can be generated procedurally, plumbed through a single pipeline, and it will coordinate perfectly because every agent is writing text to the same spec. But it has no taste. It cannot render a mood or a shadow or anything that requires judgment about appearance. An image model has to be prompted, but the prompt is where human taste lives. When I switched mediums, the art jumped. That jump came from one choice: putting taste work upstream of the scale.

Second, judgment layers. Who reads the work? Who decides if it is good? Round 1 had zero. The writer output, the artists drew it, nobody sat between the draft and shipping. Round 2 added one critic. Round 3 added two critique passes plus editor agents who read chapters like readers and sent pages back for revision. Each layer cost more tokens, but the cost is not linear. One critic is cheaper than you’d expect. The jump from one to three was maybe 30 percent of the total token budget for round 3. But the impact on the output was immense. Because criticism is how you make work better. It is how you distinguish between “the machine did what I asked” and “what I asked produced something worth reading.”

Third, the brief itself. How much thought does the human put into specifying what they want? Round 1: a one-line prompt listing plot elements. Round 2: still one line, but I’d read the output from round 1. Round 3: twenty minutes of real thinking. A plain brief: here is what I want to see happen, here are the characters’ names and what they look like, here are the three main arcs, here is the ending, here is what makes the antagonist credible. Real creative direction. That is the heaviest human lift in the entire loop. And it produced the biggest quality jump.

All three sit outside the technology. Model capacity, token count, API pricing: none of them move these levers. Each one is a place where you, the human, have to sit down and decide something instead of letting the machine run.

When we use AI, what really matters is what value it creates or could create. And the difference is how much we give it, in terms of context but also our own direction and creativity. Without human creativity, we can’t really use AI to create something meaningful, fun, and entertaining.

That’s where I landed, and it matches what I keep finding on the partnership spectrum and in the value experiments: the machine amplifies whatever you put in. Put in a one-line prompt, get amplified emptiness, which is the exact definition of slop. And that emptiness traces straight back to a choice you made. Put in taste, constraints, and honest feedback, and get something with a pulse. Put in a character’s full description and a reason why the antagonist is credible instead of simply evil, and the machine has something to amplify besides noise.

One thought keeps coming back. I poured maybe an hour of real creative attention into this across three rounds, and got a readable 65-page comic. The work was better than I expected, given how little time I spent. Now imagine an actual comic artist, someone with years of story instinct and visual training, pouring two or three full days into this same loop. Their sense of how a scene should flow. Their eye for which pages need redraws. Their understanding of character design and what makes a face readable across 65 pages. I think there is a real chance they would come out with something printable. Something you could hold and show people. The tools are already there. The model capacity is already there. Taste is the scarce part. And every experiment like this makes it clearer that taste will only get more valuable.

Read all three at wiz.jock.pl/comics and judge the line yourself. Round 1 is kept up unedited, as the baseline. It earned that much, because it is the truest version of what slop is: perfect execution of thoughtless input.

---