Think about what it takes to build a car.

You take hundreds of pieces of metal and put them together. When two of those pieces have to be joined, they get welded. For a long time, that was done by a person standing on the line with a welding torch, making the same weld, on the same spot, car after car.

Then the car companies decided to bring in robots.

 

Who Built The Robots?

Here is the part that matters. The welders did not build the robots.

The car companies brought in robotics experts. Those experts designed the robots, programmed them to make the welds, and kept them running when they broke. The welders' knowledge of what a good weld looks like still mattered, but it ended up inside someone else's program.

For many of the people holding the torches, the job simply went away. The new jobs went to a different group of people with a different set of skills.

The people who did the work were not the people who automated the work.

 

The Agentic Revolution

Now look at what is happening in our industry.

AI coding agents can now write a large share of the code in an application. They can read a codebase, build new features, write the tests, run the program, and fix what breaks. This is how I build applications now.

So the question everyone is asking is: are programmers the welders in this story?

I don't think so. Look at who is implementing the agents.

It is the same programmers who used to write the code by hand. We are the ones writing the specifications the agents follow. We are the ones setting up the projects, the tools, the instructions, and the guardrails. We are the ones reviewing what comes back and deciding whether it is right.

In the car factory, the welders were replaced by robots that someone else built. In software, the programmers are building and running the robots themselves.

 

Why The Programmers Get To Keep Their Jobs

The robotics experts in the car plant didn't need to weld better than the welders. They needed to know how to build and program robots. Those were two different jobs.

In software, those two jobs are the same job.

To direct an AI coding agent well, you have to know what good code looks like. You have to know how the application should be structured, where the data lives, how authentication works, how it will be deployed, and what will break when it runs against real data. That is exactly what programmers already know.

An agent can produce a lot of code very quickly. It can't decide what should be built, and it can't be accountable for whether it was built right. Someone has to:

• Decide what the application needs to do
• Turn that into a clear specification the agent can follow
• Choose the architecture and the tools
• Review and verify the result
• Take responsibility when it goes to production

That someone is a programmer.

 

The Job Changes

I want to be clear. Keeping the job does not mean the job stays the same.

My own work has moved from typing code to writing specifications. I start with Markdown spec files and diagrams that describe the whole application. The agent interviews me and asks questions before it writes anything. Then it builds the application, runs it, and verifies it, and I review what it produced. I covered the details in my post Agentic Coding: Where I Am At Now [October 2026].

I write far less code by hand than I used to. I make far more decisions.

The programmer moves from the welding torch to the control room.

 

The Catch

The welders did not get a choice. The robots arrived, and someone else was hired to run them.

Programmers do have a choice, but only if we take it. The programmer who learns to direct agents, write good specifications, and verify the output becomes more productive than ever. The programmer who ignores this and keeps working the way they did a few years ago risks ending up where the person with the torch did.

The difference is not the technology. The difference is that we are the ones who know how to build the robots.