Renaissance Painters Who Lived to See Photoshop

Those of us who learned web development by hand, before AI, are Renaissance painters who lived long enough to see computer paint programs.

That's the jump I see in web development right now. Painting took roughly five hundred years to get from grinding pigment by hand to dragging a brush tool across a screen. Web development did its version in a couple of years. Same people, same careers, and we went from one side of the jump to the other in the middle of them.

I've been building for the web for thirty years. Almost all of it by hand, line by line, the way everybody did it. Now I mostly talk to Claude Code and look at what comes back.

Most of the job was prep

Think about what a painter in 1500 actually did before any painting happened. He, or more likely his apprentices, ground the pigments and mixed them with egg or oil. Somebody prepared the surface. If it was fresco, you only plastered as much wall as you could paint that day, because the plaster had to be wet. Years of apprenticeship before anyone let you near the part people would actually look at.

That was web development for a long time. Setting up the build. Wiring the boilerplate. Writing the same form validation for the fortieth time and hating it a little more every time. Hours of prep for the few minutes that actually needed me.

Dojo was my first framework

I've watched the whole progression. Early on, JavaScript and CSS showed up, and a page could finally do a few things on its own and have a real stylesheet. By the late nineties we had DHTML and Flash, which mostly meant fighting browser differences or shipping a plugin nobody wanted to install.

Ajax was a flashpoint. It got its name in 2005, and suddenly everybody was building pages that didn't reload every time you clicked something. Dojo showed up right alongside it, and it was the first framework I ever used. It changed how I worked. That was the first jump in productivity I saw, and the jumps haven't stopped since. Everyone had their pick back then: Prototype, script.aculo.us, YUI, jQuery, MooTools, Ext JS. Those were the first real abstractions.

By 2010 the app frameworks were landing. Knockout, Backbone, and AngularJS all came out that year, and Ember followed. They gave a growing pile of JavaScript some structure, so a browser app could actually behave like an app.

Then came React, Vue, and Angular, which is Google's ground-up rewrite of AngularJS, with Svelte right behind them. That's when we could build robust apps without grinding the pigment, so to speak.

I used every one of those at some point, and each one was a better brush, or paint that came premixed, but I was still the one painting.

The jumps never stopped, and now none of that even matters. I can have AI build me the same app in React, Angular, and Vue and it wouldn't even hesitate. All those years of framework arguments, and the machine doesn't care which one you pick.

That's closer to handing that painter a laptop with a paint program on it. Undo. Layers. Every color that exists, already mixed. He'd lose his mind for about a day, and then he'd get a ridiculous amount done.

That's where we are.

I can build whatever I want now

The painter comparison only goes so far, because the bigger change is who gets to commission the work.

Michelangelo painted the Sistine Chapel ceiling because Pope Julius II commissioned it, and it took him about four years. Leonardo kept working on the Mona Lisa for years. Those were the commissions of a lifetime. If you had the money and the connections, you got one, maybe a few.

We get to commission whatever comes to mind now. The tool you've wanted for years. The side project that would have eaten six months of evenings. The idea you only want to see working so you know whether it's dumb. Fully build it, or just POC it and find out if it holds up. Trying something got so cheap that the question moved from whether we can afford to build it to whether I actually want it.

That's how I work on my own projects now. I describe the thing, it gets built, I look at it and decide whether it lives.

A feature takes a month in most big companies

Personal projects moved first because nobody has to approve anything. Enterprise is slower, but it's coming, and that's where the change is going to be biggest.

Here's how a feature moves through most big organizations today. Refinement sessions to figure out what it is. A sprint or two to build it. A handoff to QA. Bugs go back to the developers, then another round of testing, then UAT, then it sits and waits for a release window. A month is normal. Longer isn't unusual, and somehow nobody thinks that's weird.

Most of that month is waiting. Waiting for a developer to free up, for QA to get to it, for the fix to come back.

When the build takes an afternoon, that whole chain collapses into refine, build, refine again. I can see the same team that sat in refinement testing that work the next day and pushing it to prod. The people who know what the feature is supposed to do are looking at it running while the conversation is still fresh. No handoff, and no three-week gap where everybody forgets why they asked for it.

A lot of organizations are going to struggle with that. Their whole process was designed around build time being the slow, expensive part. Take that away and what's left is the process itself. Most of it was always just waiting in line, and now everybody's going to see it.

The developer who retired from hand coding

I watched a clip this week that's been going around. A developer with 25 years of writing code by hand got up at a conference and said he retired from doing that around March. One slide closed out the old career, 2001 to 2026. The next one read "Energized Professional Maker," starting in 2026, with a question mark where the end date goes.

He said we should remember the hand coding era with joy. He also said, flat out, that coding by hand isn't economically productive for most programmers anymore, and that the new job is "steering intelligence."

He's right. I wrote a while back that slop is what falls out when nobody's steering, and steering is exactly the job now. A painter who knows how paint behaves is going to get more out of the paint program than someone who never picked up a brush.

Thirty years of doing it by hand still counts

Everything is about to change, whether anybody likes it or not.

Be happy that you know how the sausage is made. Thirty years of writing it by hand means I know what the code coming back should look like, where it's going to break, and when it's confidently wrong. That doesn't go away because I stopped typing. It's the reason the new tools are worth anything in my hands.

Future developers will have no idea. They'll start with the paint program. Most of them will never set up a build by hand or spend two days hunting one wrong character, and they'll be fine, the same way nobody learning digital art today mixes their own egg tempera.

We learned it the old way and got to see the new one. I'll take that.

---

Want more like this? Subscribe to my newsletter for weekly deep dives into frontend development, AI, and productivity.