Programming Is Actually the Same Act as Painting

Let me redefine today something most people believe they "can't" do. Programming. Slowly.

Many of you reading this say, "I can't code. I'm not a science person." I said the same thing once. Then one day I watched a painter friend work, and my mind changed. The painting process and the coding process are the exact same thing.

Let me put the two scenes side by side.

A painter's day

• Face a blank canvas.
• Make the first stroke.
• Step back and look.
• Add color.
• Step back again.
• Erase and repaint if it doesn't feel right.
• Repeat all day.

A programmer's day

• Face a blank editor.
• Write the first line.
• Run it (stepping back).
• Add a feature (adding color).
• Test it (stepping back again).
• Refactor if it doesn't feel right (erase, repaint).
• Repeat all day.

Look at the two lists. What's different? Only the medium.

Painter's medium = paint, canvas, brush. Programmer's medium = code, screen, keyboard.

That's it. The structure of the act is identical. Making something meaningful out of nothing. This is true for oil, watercolor, sculpture, code, writing, video — every creation.

So why do people split the world into "painter = artist, programmer = technician"? It's a misunderstanding. And this misunderstanding blocks non-majors at the door.

"I can't code" is actually the same sentence as "I haven't learned this painting medium yet."

Let me show what changes when you swap the frame.

If you ask an aspiring painter, "Want to try oil?" the answer is usually not "Do I have talent?" but "Sure, let's try." Learning a medium is an obvious thing. You study it. It takes time. It's not a talent question.

Ask the same person, "Want to try Python?" and the answer changes. "My brain isn't wired that way." "I'm not science-minded." "I was bad at math." Coding feels like a talent question, not a medium question.

The fastest way to remove this misunderstanding is the redefinition: Programming = Painting. Mediums can be learned. Talent can't. Programming is a medium, not a talent. So it can be learned.

The mapping, more concretely:

This table shows how identical twin the two acts are. Ironically, the painter usually doesn't realize their work mirrors the programmer's. Programmers don't realize either. Each sees the other as a far-away species. They're doing the same dance.

A number from the last 6 months of teaching 30 non-major students. I opened every cohort with one sentence: "Programming is painting. Only the medium differs."

Result:

• Students still enrolled at week 6 under the old frame: about 30%
• Students still enrolled at week 6 under the painting frame: about 70%

More than double. Same curriculum. Same syntax. Same exercises. Same pace. The only change was the opening sentence.

Why the difference? The medium frame creates a tolerance for error. When you paint, you don't drop the brush because the first stroke looks ugly — you assume you'll paint over it. But in coding, when the first line throws an error, many jump straight to "I'm just not cut out for this." The frame shapes the attitude.

Easier analogy. Remember doodling on paper as a kid? A line with a pencil, erase if it's ugly, another line. You never wondered "Do I have doodling talent?" You just drew.

Programming is that doodle. The medium is a keyboard instead of a pencil. The paper is a screen. The eraser is Ctrl+Z. Approach it the way you doodled as a child. The moment you try to draw it perfectly, the doodle dies — and so does the code. The doodle attitude is the core programming attitude.

One more point. In the AI era, programming and painting got even closer.

Programming used to sit on the side of "technical labor — getting syntax exactly right." One missing semicolon breaks the world. That made talent and precision feel unusually important.

But AI now handles the syntax for you. You say "I want to build this," and AI writes syntactically correct code. What's left is what to build, how to structure it, what feel to give it — exactly the painter's territory.

So in the AI era, "I can't code" means "I haven't learned the medium yet." And since AI helps with the grammar of the medium, the threshold dropped even lower. What remains is painterly sense — what, how, why.

To close.

Programming is painting. Only the medium differs. The essential act — "making something meaningful out of nothing" — is identical. Accept this frame, and the sentence "I can't code" auto-translates to "I need to learn this medium." Talent question becomes medium question.

In the AI era, AI handles the grammar of the medium. What's left is painterly sense. Today, when you open the editor, sit down like a painter. The first line is the first stroke. Errors are unwanted colors. You paint over them. That's all.

Three years from now, you don't need to divide yourself into "not a painter, not a programmer." Both belong under the same name — creator. You simply use different mediums.

Three words for today — Canvas, Stroke, Paint.