A fourth piece, after "What's left when the machine writes the code", "How to start when the machine writes the code" and "What I build now that the machine writes the code". Those were about what changed and what I do with it. This one is about how it feels, which turns out to be the part people actually argue about. A year ago, the code an AI produced for me was close to useless. It was an advanced autocomplete: good at finishing the line I had already decided to write, bad at anything that required knowing why I was writing it. I used it the way you use a better keyboard. Then November 2025 happened. That was the switch, for me. Suddenly the model was producing code that was not far off what was actually needed. Not correct, not finished, but in the right shape, close enough that fixing it was cheaper than writing it. That is a different tool from the one I had in the summer. It changes what you reach for it to do. There was another jump at the start of this year, and that is when my job changed. Not my tooling, my job. I could take on things that were simply not on the table before, things that had been sitting in my todo list for years with no realistic path to ever coming off it. I wrote about three of them in the last piece: the WordPress port I had told people was impossible for fifteen years, the template I could not design, the little tools that were never worth a weekend. That was the year the list of possible projects got longer. And then another jump this summer, which was different again, and this one is the one I did not expect. The summer jump was not only the model. Three things landed together. The models got better again, which is the part everyone talks about. But I had also put in a real CI/CD pipeline: checks, tests, verification on every change, nothing merging unverified. And the codebase I was pointing all this at was already structured, because fifteen years of maintaining the same product forces that on you eventually. Stack those three and something crosses a line. The model now writes code that is better than what I would have written myself. Not faster than mine, better than mine. It finds solutions to problems that would have cost me hours, sometimes days, and it finds them while I am doing something else. I know this sounds like the kind of thing people say to be provocative. I am saying it flatly because it is what the diffs show. The honest consequence, and the one that makes people uncomfortable whenever someone else says it out loud: I read less and less of the code. That is not carelessness and it is not blind trust. It is that the trust moved. I used to verify by reading, because reading was the only instrument I had. Now the tests, the checks and the pipeline do the verifying, continuously and without getting tired, and my attention goes to whether the thing being built is the right thing at all. I still read code. I read it when something is subtle, when the pipeline cannot express what I care about, when I have a bad feeling. But I no longer read every line, and the quality of what ships went up, not down. That is not a claim you can make from nowhere. It only holds because the verification is real. Without the tests and the checks, "I do not read the code" is just a description of how you are going to ship a bug at two in the morning. The harness is what buys you the right to stop reading. Build the harness first. But that is not why I am writing to you today. I want to talk about feelings. Some people find this depressing. I understand why. There is a real grief around this, and I do not want to be glib about it. If you love code for its own sake, if the pleasure is in the craft, in finding the elegant expression of the thing, in the moment where a messy function collapses into six clean lines, then what I just described is a loss. You are being handed a paradigm where the part you love is done by something else, faster, and where the elegance you would have spent an evening on is produced without you and read by nobody. And in some cases it is worse than that, because you are not even left out of it. You still have to read the output and validate it. The making goes, the checking stays, and you are turned from a craftsman into a cog in someone else's process, signing off on work you would rather have done yourself. I am not going to tell those people they are wrong to feel it. They are describing something that genuinely went away. It just did the opposite to me. Fifteen years in, I had stopped wanting things. I have been in the same domain for fifteen years. I had, in the way you do eventually, been round it. I knew the problems, I knew roughly how each one would go, and there was very little left that surprised me. And we are a very small team, which sets a hard ceiling on ambition: the big projects, the ones that would have been interesting, were not turned down because they were bad ideas. They were turned down because the arithmetic did not work. Years of work, not enough hands. So they stayed on the shelf and I stopped proposing them, and after a while you stop even thinking of them, which is the part that should have worried me more than it did. I had lost the motivation. That is the plain version. Not burnt out, not miserable, just flat, doing competent work on a list that no longer contained anything I was excited about. AI put that back. Not by making the work easier, but by putting things back on the list. When the ceiling moves, the ideas come back, because there is now a point in having them. I have been starting projects one after another since, and the bottleneck in my week is no longer capacity, it is deciding which of them is worth doing. That is a much better problem, and it is one I had not had in a decade. The other thing, which I did not plan and would not have predicted: it gave me time back outside of work. The projects got bigger and my evenings got freer. Both, at once. I have no clever framing for that. It is just what happened. The reason, I think, is that code was never the point for me. I have thought about why the same shift lands as grief for some people and as a reprieve for me, and I keep arriving at the same answer. For me, code was a means, not an end. What I actually like is making things exist. Shipping something a person uses. Watching an idea I had in the shower turn into a thing with users and bug reports and opinions attached. The code was the toll I paid to get there, and I paid it happily for fifteen years and got good at it. Good within my own domain, at least, which is what I would like to believe. But I was never in it to write beautiful code. If tomorrow the beautiful code writes itself and I get to make twice as many things, that is not a loss for me. That is the toll going down. If your answer is the other one, if the writing is the thing you love, then this shift takes something from you, and no amount of talk about leverage and possibility makes that untrue. I would only offer this: it is worth actually asking yourself which one you are, rather than assuming. I found out I was a builder who had been telling himself he was a coder, and finding that out was worth more to me than any of the code I stopped writing. The machine writing the code did not take my job. It took the part of my job I was doing to get to the part I wanted.