The hard part was never the typing

For most of my career, writing code was the job. You had an idea, and then you sat down and turned it into syntax, line by line, for hours. The typing was the work. The better you got, the faster and cleaner the lines came out.

That is not my job anymore, and I want to be precise about what changed, because it is easy to get it wrong.

I do not write most of the code by hand now. I direct agents that do, and I spend my time on something else: deciding what to build, shaping the architecture, and verifying that what comes back is actually right. People sometimes hear that and picture someone who forgot how to program, typing wishes into a box and shipping whatever appears. That is the opposite of what happens.

Here is the thing nobody tells you about working this way. The agent will happily give you code that runs. Running was never the hard part. The hard part is knowing whether the code is correct, whether it will hold under load, whether it quietly breaks a case you did not think to check, whether the shape of it will make the next six months easy or miserable. An agent does not know any of that for you. You have to know it, and you have to catch it, every time.

That is not a junior skill. It is the most senior skill I have. It is twenty five years of writing code by hand, of shipping things that broke and fixing them, of learning where systems rot from the inside. That experience did not become useless when I stopped typing. It became the whole job. The typing was the part a machine could take. The judgment is the part it cannot.

So when I say I verify instead of write, I do not mean I do less. I mean I moved up the stack, to the part that was always the point. I still read every important line. I still reason about the code I did not write, the same way I used to review a teammate’s pull request, except now the teammate is fast and tireless and needs a firmer hand. I decide what good looks like. I say no a lot. I catch the thing that runs but is wrong.

The tools got dramatically faster. The bar for what I let ship did not move at all.

There is a version of this that is genuinely dangerous, and it is the version people are right to worry about: someone with no foundation, accepting whatever the model produces because they cannot tell good from bad. That person is not directing anything. They are hoping. The difference between hoping and directing is exactly the twenty five years, and there is no shortcut around it.

I think the developers who do well in the next few years are not the ones who type the fastest, and they are also not the ones who let the machine decide. They are the ones who know enough to hold the machine to a standard. That is craft too. It is just craft pointed at a different part of the work.

The typing was never the hard part. It only looked like it was, because it was the part we could see.

Have any thoughts? Send me a message >