When Code Becomes a Medium

Computation has been an artistic medium for decades. What’s changing isn’t the existence of the medium. It’s who gets to use it, what it can be made from, and how far it can travel.

I didn’t start with that conclusion.

The first version of this essay argued that AI was turning code into an artistic medium. Then someone challenged me on it. The objection wasn’t complicated: hasn’t computation already been an artistic medium for years?

It was an uncomfortable question because the answer was obviously yes.

Harold Cohen’s AARON had been making drawings since the 1970s. Artists built entire practices around software, networks, interaction, and computation long before generative AI appeared. I wasn’t witnessing the birth of a medium. I was witnessing something else.

The medium is hanging in museums right now. At this year’s Whitney Biennial I stood in front of Leo Castañeda’s Camoflux Recall Grotto, a commissioned web game where you tend a garden of cyberflora. The screen sat in its idle loop. Visually flat. Waiting for a player. In the few minutes I watched, nobody walked up.

Hold that image. It ended up telling me what I actually want from this medium, and I’ll come back to it.

What typography taught me

Typography wasn’t invented as an art form. It was infrastructure. Letters carried contracts, laws, religious texts, and trade across distance. Producing a page required specialized knowledge and specialized tools. Scribes learned the craft. Printers owned expensive presses. The technology itself determined who could participate.

Nobody looked at a ledger and thought they were looking at art.

Then the tools changed.

Movable type widened access. Centuries later desktop publishing widened it again. Every expansion brought a flood of work that copied what came before. Some of it was awful. We’ve all seen the early desktop publishing flyers with six fonts fighting for attention on the same page.

But something more interesting happened underneath the mistakes.

As more people gained access, the questions changed. Designers stopped asking only what words should say. They began asking how language could behave. Could letters create rhythm? Could typography become image? Could the page itself become expressive?

The medium hadn’t changed.

Who could reach it had.

I keep coming back to that comparison because something similar feels like it’s happening with software. I don’t know that the analogy survives every edge case, but I haven’t found a better one yet.

A medium looking for more makers

Computational art already has a history.

Generative art. Net.art. Interactive installation. The demoscene. Software art. Game art. Entire communities spent decades exploring computation as material while most of the software industry was busy building products.

So I don’t think AI creates a new artistic medium.

It changes access to an existing one.

For most of computing’s history, making software meant becoming, at least partly, an engineer. You learned syntax, architecture, debugging, deployment. The language shaped how you thought long before you shaped anything with it.

I know that path because I started there.

I studied engineering for four years before leaving for art school. At the time it felt like I was walking away from one world into another. Looking back, I think I was circling the same material from opposite directions.

Coming back to software now feels completely different than it did twenty years ago.

Not because programming became easy.

Because conversation became part of programming.

I can describe a behavior instead of immediately writing an implementation. I can ask for five approaches instead of inventing one. I can build prototypes that simply weren’t within reach for me a few years ago.

That doesn’t automatically produce art.

Mostly it produces access.

History suggests that access usually begins with imitation. Early photography borrowed painting. Early film borrowed theater. Desktop publishing borrowed print. Most people entering a new medium repeat what already exists because that’s how you learn where the edges are.

Software seems to be following the same path.

The maker moves

The more I work this way, the less I think the important shift is writing less code.

The important shift is standing somewhere else.

A compositor once placed every letter by hand.

A desktop designer described the page and let software handle the mechanics.

Neither approach removed design from the process. It relocated it.

AI-assisted programming feels similar.

I’m spending less time specifying every implementation detail and more time shaping behavior. I still care about precision. I just judge it by how the system behaves now, not by reading the source. Sometimes I throw everything away and start again.

But increasingly the craft lives in iteration rather than transcription.

One of the earliest criticisms I heard was also the strongest.

“If the model writes the code,” someone asked me, “isn’t the model the artist?”

I still think about that question.

The first response is easy: no serious artist stops at the first output.

But that’s almost too easy.

The better answer came from paying attention to my own process.

The first thing a model gives me is rarely what survives. Sometimes it contains an unexpected idea. Sometimes it reveals a flaw in my thinking. Often it’s simply wrong in an interesting direction.

That conversation becomes the work.

The code changes.

My understanding changes.

The system changes again.

Eventually something emerges that neither the original prompt nor the original output contained.

That’s where authorship still feels real to me.

Not in producing the first answer.

In recognizing which answers deserve another hour of work.

The average output, strangely enough, becomes useful. It gives everyone roughly the same starting point. What separates one maker from another isn’t access to the average. It’s the willingness to keep pushing past it.

That’s the part I don’t think the tools automate.

Not taste.

Not judgment.

Not knowing when something finally becomes alive.

How far the work travels

There’s a second shift I almost left out of this essay, because it’s harder to pin down.

Distribution.

I hesitate because reach is not new. The printing press was a distribution technology. Net.art lived on the open web in the nineties.

In 1995, Ken Goldberg and Joseph Santarromana’s Telegarden let strangers on the internet tend a real garden through a robot arm. A lone developer in 2006 could ship a networked toy to the whole world.

So when I catch myself saying the reach is new, I have to be more careful than that.

What feels new is the combination.

The maker doesn’t have to be an engineer anymore. The material can generate instead of repeat. And everything ships with an audience attached.

Work that used to be rare, participatory, alive to many people at once, starts to look buildable by one person.

I think that goes somewhere the older tradition couldn’t quite reach.

I’m not sure.

The soil is richer now. Richer soil grows things that didn’t grow before.

The instrument nobody wanted

None of this guarantees art. Access opens the door. It doesn’t walk anyone through.

My favorite story about this is the Roland TR-808.

It was a commercial failure. Reviewers heard its drum sounds as thin and fake, and Roland discontinued it after a few years.

Then producers with no conservatory training picked up the machines secondhand and cheap, and built hip-hop and techno on exactly the sounds everyone had rejected.

The default the world heard as wrong became a language.

It took years. It took a stubborn few.

That’s the shape I expect here.

Access raises the floor. Desktop publishing did the same thing to type: the templates lifted the floor and flattened the middle in one motion, and the work that mattered still came from people who fought the template.

I’ve argued elsewhere that these tools get almost anyone eighty percent of the way. The last twenty percent, where the meaning lives, is the part they can’t hand over.

The timing nags at me too.

The radical computational art of the past came from people who knew the machine cold. The demoscene broke the machine because it understood the machine. That was the only door in.

Now artists can reach the material before engineering’s sense of what code is for hardens into the only sense.

I don’t know what they’ll do with it.

That’s rather the point.

Clockwork and weather

Underneath the access and the reach, the material itself changed.

I keep thinking this is the deepest part.

Code was always clockwork. Exact rules, run exactly, the same every time.

I spent four years being trained to want that.

The systems that guess and vary used to live in research labs, expensive and walled off. Now a generative model drops into a web page the way a database did in 2005.

One more component.

Which means a work can be part clockwork, part weather. The deterministic parts hold what must not drift. The probabilistic part supplies what exact code never could: variation, response, surprise.

I don’t fully know what to do with that combination yet.

Nobody does. That’s what makes it material.

The work that stays awake

A poem is reread. A score is replayed. A painting hangs and waits.

Computation stays awake.

This is the thing I can’t stop thinking about. The rules of a work can keep running after the artist lets go.

Ian Cheng describes his live simulations as a video game that plays itself. They evolve whether or not anyone is watching.

A work can take input, hold state, and answer the hour and the room and the person standing in front of it differently every time.

Which brings me back to that idle screen at the Whitney.

That flatness wasn’t a failure of Castañeda’s piece. The gentle idling is part of its design. It’s the older contract of interactive art: the work holds still until someone volunteers, and the request for interaction just sits there, static, hoping.

The version I want to make doesn’t wait.

Work that’s already in motion when you enter the room. Work that reads the world without needing a hand on it, so the invitation is the behavior itself. That’s what I’ll be chasing as I keep working in this medium.

Not software that finishes a task and closes. Work that stays open. Work that lives in the threshold between the system and the world, between one state and the next, never the same twice because the world never is.

Artists have been pointing at this for decades. What’s different is that the material can finally carry it further, and far more people can pick the material up.

Most of what gets made will sit at the default.

That’s fine. That’s what a raised floor looks like.

The work worth watching will come from whoever refuses to stop there, and keeps pushing until the system says something it never would have said on its own.

Which leaves the title of this essay. It’s the sentence I got wrong, and I kept it on purpose. Code became a medium long before I arrived. What it’s becoming now is a medium for more of us.

Me included.