Part 2: Basic Tips

You don't need to code; you just need to think about how shapes work

When my friend Egg Syntax first showed me the websites of some of their favourite generative artists (which I'll share in a later section), I felt humbled and intimidated. A lot of their work involved math and computer code, and I thought that my weak background in those areas might mean that I would have a hard time learning the form. I'd made gorgeous ASCII art using LLMs before, and I'd gotten some good preliminary results with generative art, but I was so uncertain as to how to move forward and grow as an artist in this new medium.

In fact, as I've discovered, you don’t even have to look at code in order to make incredibly beautiful generative art with LLMs. But it is useful to have some general intuitions about shapes. As Egg put it,

If you see a finished piece by an artist you like, just stare at it and think ‘how could I describe exactly what it's doing’? ‘Something something metallic frame of an octahedron containing smaller copies of itself, each one rotates but with a delay based on size etc etc.’ And then once you have a clear understanding of what's happening, you can make it happen in code or describe it to an LLM. Basically if you can write down a complete description, you can make it! … including things that exist only in your head.

My friend Josh Turner told me that Egg's comment reminded him of von Neumann: "'If you will tell me precisely what it is that a machine cannot do, then I can always make a machine which will do just that.' … instead of precisely defining an algorithm in terms of information processing steps, you’re precisely defining the visual patterns you want to have."

With that in mind, Egg also taught me this incredible piece of wisdom:

You can think of generative art as having two parts (even if in practice they're often happening simultaneously and iteratively). The first part is thinking through the algorithm; what is it exactly that you want to have happen. The second part is implementing that into code. When you're using an LLM, you're still doing the first part and letting the LLM do the second part, but it's good to realize that you're still doing something fundamentally creative to the extent that you're describing clearly what you want to have happen.

Generative art often involves simple shapes and processes. The trick is to apply these elements in a specific sequence and scale to create a meaningful impact. A beginner in generative art can start with a set of basic shapes, like:

- lines

- rectangles

- circles

and then apply techniques such as:

- sine waves

- distortion

- noise algorithms (especially perlin noise)

- stretching

- shearing

- rotation

- moving things from one place to another ("transformation")

and add randomness on any or all parts of those.

This is already enough to create a massive amount of really cool art. There are other things you can add, but that's plenty by itself.

Even sine waves alone are already incredibly interesting and appealing to the human brain, e.g., if you look at the thing I made at the top of this page, I'm literally just adding some sine waves together, nothing else is happening, but I find it fascinating to look at.

As an analogy, consider the English language, where you can combine the same 26 letters into hundreds of thousands of words. The big takeaway here is that pretty much every generative parameter is just some kind of mathematical formula.

Consequently, looking up different types of algorithms (such as noise algorithms, for example) can help you get the right type of effect you’re looking for. Egg introduced me to a website, Processing.org, that contains helpful examples that will let you get an idea of how some pieces of code can accomplish these kinds of things, and what they look like. OpenProcessing is another website in this vein. As Egg said,

You don't need to worry about understanding the code in detail. But, if you look at what’s happening in the draw() functions and what math they're doing, you can get a sense of the underlying algorithms, and then use those to suggest different variables and combinations of variables in your prompts.