People often reach for comparisons when talking about AI in software. Calculators for engineers. Tractors replacing farmers. They're useful analogies, but they feel a bit small for what's actually happening.

The one that keeps making sense to me is the Industrial Revolution.

Before the Machines

Before it, production depended almost entirely on human labor. If you wanted more output, you needed more people. There was no other way.

Then machines appeared.

A single machine could produce what used to require many workers. Not perfectly at first. But enough to change how work was fundamentally organized.

Factories didn't just add machines and call it a day. They reorganized around them.

Software development feels like it might be going through the same thing right now.

When I started my career, most of the work began with a blank editor. I wrote the first line. I structured the function. I filled in the details. The work started from nothing and I was the one who started it.

That's not really true anymore.

AI can generate entire functions, modules, even whole features now. Not just autocomplete. Not just suggestions. Working code, end to end. The developer's job is basically to decide if it's right and not to write it in the first place.

It's a bigger shift than it sounds. It changes how most programmers have approached their work for most of their careers.

How the work changed

During the Industrial Revolution, machines didn't eliminate workers. They changed what workers did. Instead of producing by hand, people started operating, overseeing and directing systems that produced.

Something similar seems to be happening now.

Less time writing code. More time deciding what the system should do, whether the generated code is actually correct and how the pieces should fit together. The judgment work – that part hasn't gone anywhere. If anything, it matters more now, because someone has to know when the machine is wrong.

The Job Is Different Now

What interests me is that this doesn't just make coding faster. It changes what programmers actually spend their time doing.

Writing code was the job. Now the job is increasingly closer to directing — knowing what to ask for, evaluating what comes back and understanding the system well enough to catch what the AI confidently got wrong.

That's a different kind of work. Even if the title stays the same.

The way factories reorganized around machines, software teams might reorganize around systems that can already generate code. Not because developers are disappearing, but because the work is shifting toward judgment, architecture and oversight... away from production.

It's still early and it's hard to know where this ends up. But if the Industrial Revolution analogy holds, the biggest change won't be the tools themselves.

The machines didn't define the Industrial Revolution. The people who learned to work with them did.

Maybe that's the job now. 🤷🏻‍♀️