Generative art doesn't need to be beautiful. It needs to break.

Last Saturday night, my laptop screen was covered with thousands of lines devouring each other. It was the result of a drawing script I'd written in Python spitting out errors. A bad color value mapping had left half the screen buried in pitch-black noise, and the curved pattern I'd intended barely survived on the other half. Strangely, though, that half-failed image held my gaze longer than any of the polished outputs I'd spent the past two months carefully crafting.

By day I design people's diets, and by night I draw with code. There's one thing I feel in common when doing nutrition consultations and when making generative art. People feel reassured when the output is clean and tidy. But that reassurance isn't always a good thing.

The discomfort of clean images

AI image generation tools now produce astonishingly smooth results. Perfect symmetry, soft gradients, flawless textures. At first, I was impressed too. After staring at them for months, I started sensing a strange emptiness in those images. They're like a face so perfect it says nothing at all. The surface is polished and unbroken, yet you have no sense of what lies beneath it.

My Python sketches are the opposite. The reason I insist on combining Python's Pillow library with numpy instead of using environments like Processing or p5.js is that I like the roughness. One wrong index in a loop and the entire pattern warps; change the random seed and the same code produces a completely different mood. That uncertainty itself is the heart of the work.

At a gallery in Austin

This summer, I went to a digital art exhibition at a small gallery in downtown Austin. The walls were covered with projected works, most of them AI-generated images in high resolution with perfect color grading. They were beautiful. And within thirty seconds, I was already moving on to the next piece.

In a corner sat a single small monitor. On the screen, shapes that looked like they'd been made through procedural generation were being created in real time. Lines trembled, colors spiked unexpectedly, and every so often the entire screen flickered and redrew itself. I stood there watching for a long time. A person next to me asked, "Isn't this a bug?" The artist happened to be standing right there and replied, "It is. That's the point."

That brief exchange is the reason I'm writing this.

The honesty of breaking

There's a scene I witness every day as a nutritionist. People come in for consultations carrying photos of perfect meals they found on social media. The calorie count is exact, the arrangement on the plate is symmetrical, even the colors are balanced. When I ask if they've ever actually eaten like that, most shake their heads. A perfect image doesn't motivate. It creates distance. Real meals are messy, they don't go according to plan, and precisely because of that, they honestly reflect a person's actual day.

I think generative art works the same way. When code drifts in an unintended direction, the result carries something beyond the artist's control. I want to call that "honesty." The very fact that the artist couldn't dictate every pixel opens up room for the viewer to interpret.

My favorite piece among my recent work came from a script where I set the parameters of a trigonometric function inside a for loop to shift slightly off with each frame. The intention was a wave pattern, but when I ran it, an irregular line appeared on screen, like a heart rate monitor. The moment I saw that line, I felt it was far more "alive" than any clean wave could have been.

Designing glitches versus allowing glitches

There's a distinction I want to draw here. "Glitch art" has become an aesthetic genre of its own, and people often deliberately apply distortion filters or layer on noise. That's making something look like a glitch. It isn't actually broken. What I'm talking about is the attitude of looking closely at the result when code genuinely behaves unexpectedly, rather than deleting it.

When I work in Python, I intentionally keep my error handling loose. If a color value goes beyond 0 to 255, I don't clamp it right away. I first see what visual result that overflow produces. Most of the time it just ends up ugly. But once in a while, very rarely, a color combination or shape emerges that I never could have imagined. That moment is the force that keeps me doing this work.

I've been attending a small creative coding meetup in Austin, and there are people there who say similar things. One game developer told me that terrain created by bugs in procedural level generation turned out to be the most popular with players. People who work with code know from experience that unexpected forms spark human curiosity more intensely than planned perfection.

On my desk right now, that half-failed piece from Saturday night is still printed out and pinned up. Sometimes I look at it during breaks between consultations. It isn't beautiful. But every time I see it, the surprise I felt in front of my code that night comes rushing back. That one imperfect image makes me remember more than hundreds of perfectly rendered ones ever could.