Make things with code.
A working theory of creative coding after AI, at reading pace. For whenever you're ready to actually start.
What creative coding is, and isn't.
Creative coding is the practice of writing programs as expressive media rather than as tools for solving problems. The artifact is the point. A generative artwork, an interactive sculpture, an audiovisual piece, a tiny mathematical animation. The code is a means, the experience is the work.
It is not a new field. People have been making art with code since the 1960s, when artists like Vera Molnár, Manfred Mohr, and the loose group later called the Algorists used early mainframes to make plotter drawings that look uncannily contemporary. There is a half-century of practice behind every blob you see in your feed.
What changed recently is access. The web became the universal canvas, browsers got hardware-accelerated graphics, and tools like Processing and p5.js were built to make the medium teachable to artists rather than only to programmers. The community accreted: OpenProcessing, Genuary, the long-form generative art platforms, a thriving culture of plotter art, live coding venues called algoraves. The medium is wide.
The code is a brush. The screen is canvas, instrument, and stage at once.
And then, between roughly 2022 and now, the most stubborn barrier to entry (having to be fluent in a programming language before you could make anything) collapsed. That collapse is the reason for this guide.
You don't need the math. You need the mental model.
Most people use these tools without knowing what they are. That's fine, until it isn't. Here is the working model that will save you hours of confusion.
The core mechanism
A large language model is a next-word predictor. You give it some text. It produces a probability distribution over what word (more precisely, what token) comes next. It picks one, appends it, and repeats. That's the loop. Everything else you see ChatGPT or Claude do is built on that single behavior, scaled up enormously.
What "trained" means
The model learned by reading huge amounts of text (books, code, websites, conversations) and having its internal weights adjusted billions of times until its predictions matched what came next in the training data. It isn't retrieving answers from a database. It is pattern-matching at a scale that is genuinely hard to intuit. When you ask it to write a p5.js sketch, it has read thousands of p5.js sketches; it is recombining and adapting patterns it has seen.
The two knobs that matter
Context is everything you give the model to work with: your prompt, the prior conversation, any files you attach. The model has a finite context window (think: short-term memory). Bigger context, generally better results, up to a limit. Vague in, vague out.
Temperature controls how randomly it samples from its predictions. Low temperature (near 0) makes it pick the most likely next token every time: safer, more deterministic, useful for debugging. High temperature lets it pick less likely tokens: more surprising, more variation, useful for ideation. Most chat interfaces hide this knob, but you can effectively control it by asking: "give me five surprising variations" pushes it toward higher temperature behavior.
Why it hallucinates
The model is optimized to produce plausible-sounding next tokens. It is not optimized to produce true ones. When it doesn't know something, it will confidently produce something plausible-sounding anyway. This is not a bug to be fixed; it is the mechanism working as designed. Your defense is verifying anything that matters and treating confident-sounding specifics with skepticism.
The model is a transformer, a stack of layers in which each token "attends" to every other token in the context, learning which words relate to which. The attention mechanism is what lets it handle long-range dependencies. None of this is necessary to use the tools well, but it is quietly beautiful if you want to read further: search "Attention Is All You Need" and "the illustrated transformer."
AI shows up in your workflow as three different things.
Most creatives encounter mode one and stop there. Mode three is where this gets genuinely new.
Mode I: AI as the one writing the code
Natural-language-to-sketch. Debugging an error you don't understand. Translating a Processing sketch to p5.js. Asking what a stranger's shader does line by line. This is the accessibility story: the wall of syntax disappears.
It works well because code is text and the model has read enormous amounts of it. It works especially well for the small, self-contained sketches that creative coding favors: a few hundred lines, no dependencies, runnable in a browser. Less well for large codebases, novel libraries, or anything obscure.
Use it for
Starting a sketch from a verbal description. Translating between languages. Explaining errors. Quick prototypes you might throw away. Learning what a piece of code does by reading it aloud with the model.
Mode II: AI as muse and variation engine
You bring intent and taste. The model brings breadth and speed. Ask for ten directions an idea could go, pick one, refine. Ask for five palettes that evoke "autumn rust." Ask what would happen if your flow field's noise function were replaced with a sine grid. The model is a tireless brainstorming partner that has no ego about its suggestions.
This mode is dangerous because it is intoxicating. You can spend hours generating variations and lose the thread of what you were actually making. The skill is curation: knowing what to keep, what to discard, and when to stop asking and commit.
Use it for
Getting unstuck. Exploring axes of variation. Sanity-checking aesthetic decisions. Finding adjacent ideas you wouldn't have arrived at alone.
Mode III: AI as material inside the artwork
The piece itself calls the model at runtime. A generative poem that writes a new line every minute. A photo collage that re-captions itself. An installation where the AI interprets what a webcam sees and responds with text or sound. The model isn't building the work. It is the work, or at least a load-bearing part of it.
This is the most artistically interesting frontier and the one most creatives haven't tried. It is also where the existing art-historical lineage of AI-as-medium lives: Memo Akten, Anna Ridler, Refik Anadol, Sougwen Chung. If you want to make work that couldn't have existed before, this is the mode to spend time in.
Use it for
Work where the unpredictability of the model is the point. Interactive pieces. Long-running generative systems. Anything where you want the artwork to surprise even you.
Most "AI is bad at creative coding" is actually "my prompt was bad."
A small kit of habits. Examples first, principles second, because that's how the model learns and how you will, too.
When the model's first answer isn't right, don't just say "no, try again." Tell it what was wrong with the previous answer and what you want instead. "The colors are too saturated; I want muted earth tones" beats "wrong, try again" by a wide margin.
The skill that turns AI from toy into tool.
Anyone can prompt a sketch into existence. Getting it to do what you want is where most people stall. Here is the meta-skill.
Paste errors verbatim
Always. The exact text of the error message (line numbers, stack traces, browser warnings) is the highest-signal thing you can give the model. Paraphrasing destroys the information. If the error spans multiple lines, paste all of them.
Ask for line-by-line explanation
When the model gives you code you don't fully understand, paste it back and ask for an annotated walkthrough. Do this even for code that works. Especially for code that works. It is the fastest path from "I have a sketch" to "I understand the sketch."
Ask for three approaches before picking one
Before letting the model write a complex piece of code, ask: "what are three different ways to approach this, with the trade-offs of each?" Then you pick. This single habit prevents the most common AI-coding failure mode: getting locked into the first plausible approach when a better one existed.
Don't accept the first suggestion silently
If you can read the code, read it. If you can't, ask the model to explain it. The black-box-acceptance pattern is what people mean when they say "vibe coding": it gets you to "okay" fast and stalls there.
Know when to stop asking the model and start reading
If you've gone three rounds and it's not getting better, the bottleneck is usually that you don't yet know what good looks like. Step away. Read someone else's code on OpenProcessing. Come back with a sharper target.
Treat the model as a smart junior collaborator who has read everything but has never met you. It will hand you something reasonable on the first try. Your job is to push back, redirect, and ask better questions until what it produces matches what only you can see in your head.
Which AI for which job.
The honest snapshot, knowing it will shift. Pick by what you're doing, not by what's hyped.
Pick one and get fluent. Switching cost is high: each tool has its own quirks, prompting style, and surface. The differences between Claude and ChatGPT for creative coding are real but small. The difference between fluency in either and dabbling in three is enormous.
What this is bad at, and why it matters.
A guide that only sells the upside is hype. Here is what to watch for, especially this year.
The AI aesthetic is real
Pieces made by prompting alone tend to converge on a recognizable look: smooth gradients, glowing particles, drifting smoke, the same purple-to-pink palette. Defaults are an aesthetic, and right now the defaults are loud. The way out is taste: clearer intent, opinionated constraints, willingness to override the model's first instincts. Make work that you recognize before anyone else does.
The black box you can't open
If you can't read the code, you can't fix it past the first version. You will hit a wall: a bug the model can't fix, a feature you want that doesn't fit the structure, a performance problem you can't diagnose. Some understanding of what the code is doing is non-optional past the prototype stage. Plan for that earlier than you think you need to.
The provenance question
These models were trained on enormous amounts of work, including art and code from people who weren't consulted. The legal and ethical questions around this are genuinely unsettled. You don't need to have the answer (nobody does), but you do need to have thought about it, especially if you are a working artist whose income depends on commissions or licenses.
Taste does not autocomplete
The model will happily generate a thousand variations. It will not tell you which one to keep. It will not tell you when to stop. It will not tell you that the piece is finished. The decisions that make work yours (the editing, the restraint, the commitment to a single direction) are exactly the things the model cannot do. The barrier to entry collapsed; the bar for taste did not move. If anything, it got higher.
Seven days. Specific moves.
If you take nothing else from this guide, take this. The fastest way to internalize the medium is to put hands on something every day for a week.
editor.p5js.org. Ask any AI to write you a p5.js sketch from one sentence you write yourself. Run it. Don't change anything. Just look at it.hydra.ojack.xyz in a browser tab. Try the examples. Type one line, change one number. This is a different shape of creative coding: live, immediate, audiovisual.The vocabulary, in plain language.
Twelve terms you'll meet repeatedly. Two sentences each.
Where to go after this.
Every link below earned its place. The annotation is what it's best for and when to reach for it.
Tools
Reading
Community & practice
AI as medium
The syntax wall just fell. The bar for taste just got higher.
Be early.