The Next Rung At some point I realized that almost all of the code I had ever written had been deleted. At the very least, refactored or rewritten, but my LOC were for the most part confined to the dustbin of repo history. I was lamenting the fact that the stuff that did survive felt like it was all some embarrassing junk I had thrown together in a couple of days before moving on to the next thing, and I wondered what mark I had really left on the code. The trend accelerated once I became a manager and my dwindling contributions were swiftly consumed by normal code churn. Most of the coding I did was nights-and-weekends tinkering on personal projects. I was turning all this over in my head and spiraling a bit thinking about what really makes a great software engineer and was I ever one and would I ever be one. I realized the people I admired most weren't the galaxy-brained folks who built magnificent "future-proof" systems that would still work in ten years but the ones who could see just one move ahead. When the next big problem arrived, their design was just malleable enough to make the transition straightforward. Their code felt almost designed to churn. Great software engineering is building rungs on a ladder. The code that got mowed over in a refactor had to exist for the refactor to happen. It served its purpose and now sails off in a Viking funeral. What is the alternative? Climbing back down? All that code I wrote to indulge myself on nights and weekends? I still have absolute git blame dominion over it. 100% of the lines have my name on them. And they do not matter at all, and the way you can tell is that they're not churning. Many of those repos haven't seen a commit in a decade. With vanishingly few exceptions, churn is a sign of life. The stuff that doesn't last is the stuff that matters. — "The models are the worst they will ever be." I hear from my friends at the labs that some researchers act almost as if programming (even with agents!) is a waste of time, because the models are going to eventually just be able to do it all for you. Yes, of course nobody writes the code by hand anymore. Some people have given up on reading it altogether. Some people don't even try to understand how it works anymore. But it is a mistake to assume that just because the code is disposable, the understanding is too. For my part, the amount of handwritten code I'm producing does indeed round to zero. But not understanding what's actually going on underneath is insanity for anything non-trivial. You might be able to get away with this someday, but you cannot build a system of any complexity whatsoever using even the best models without good technical guidance, and you cannot give good technical guidance if you have no idea WTF is going on. Maybe we will get to the point where you can just let go and let Claude. But we are not there yet, and we will never get there if we try to operate as if we are already living in some imagined future instead of the real one we live in today. There is a difference between being able to see a rung and being able to grab it. We have to keep building. We have to keep climbing. fic.us/writing/the-next-rung