The Work Moved Up a Floor: Ten Months of Coding With AI
Ten months ago, AI was autocomplete to me. A smart autocomplete, the kind that finished the line I was already typing and occasionally guessed the next one, but autocomplete all the same. I was a coder through and through. My hands were on every line. The model sat in the passenger seat and handed me the occasional suggestion, and I took it or I did not.
I do not work that way anymore. These days the agent writes most of the lines and my actual job is to read them. That sounds like a small change. It is not. It is the difference between being the person who lays the bricks and the person who walks the site and decides whether the wall is going up straight.
Nobody automated me out of the job. The job moved up a floor.
The coder I used to be
For most of twenty-plus years, the craft was in the typing. Not the physical act, the translation. You hold a shape in your head, the thing the software is supposed to do, and you turn it into syntax one decision at a time. Which data structure. Which boundary. Where the error gets caught. Every one of those is a small judgment call, and you make hundreds of them a day without noticing, because that is what the job is.
AI in that world was a convenience. It saved me keystrokes. It remembered the argument order of a function I use twice a year. It roughed out the boilerplate so I could get to the part I cared about. Useful, genuinely, but it never changed what I was: the author. I wrote the code. The tool helped me type it faster.
If you had told me then that within a year I would be writing very little of the code myself, I would have assumed you meant I had stopped building things. That is not what happened.
The work moved up a floor
Somewhere in the daily grind of using it, the balance tipped. I stopped asking the model to finish my line and started asking it to build the whole feature, then reading what came back like a reviewer reads a junior's pull request. Carefully. With a list of things I expect to be wrong.
That reframing is the whole story. My output did not drop when I stopped writing every line. It went up, because the slow part was never the typing. The slow part was holding the whole shape of the thing in my head and getting each piece to fit. The agent is fast at producing plausible code. It is not the one deciding whether the code belongs.
So now I spend my day at a higher altitude. I read a diff and ask whether this is the design I actually want, not just whether it compiles. I catch the shortcut the model took because it optimized for looking done rather than being right. I notice when it solved the symptom and left the cause sitting there.
That is review work, and review work is where the experience pays off. Twenty years of scars are worth a lot more when your job is spotting the thing that will break in three weeks than when your job is remembering a function signature.
The plan is the bottleneck now
Here is the part the demos never show you. An agent is only as good as the direction you point it in, and pointing it is harder than it looks.
When I was writing the code myself, the plan lived in my head and revealed itself as I typed. I would start down a path, feel it go wrong, and correct without ever saying the plan out loud. You cannot do that with an agent. It does not feel the path going wrong. It happily builds the thing you asked for, including the part you did not think through, and it builds it fast enough that a bad direction becomes a lot of bad code before you have finished your coffee.
So the thinking moved to the front. Before I let an agent touch anything real, I have to know where this is going. Not the next line, the next three moves. What this feature turns into when the next one lands on top of it. Which decision here I will regret when the codebase is twice the size. The agent handles the how. I own the what and the why, and I own them earlier and more deliberately than I ever had to when it was just me and an editor.
That is not less engineering. It is arguably more of it, just concentrated in the part that was always the actual work: deciding what to build and how it should be shaped.
It writes fast, it does not think for you
The tools got easier. The responsibility did not move an inch.
When something breaks in production, and it will, the agent is not the one who gets paged. I am. The model does not understand the app it just wrote. It has no memory of why we made the call we made in that other module six weeks ago, no sense of the customer who will hit the edge case, no stake in the thing staying up at 2am. All of that still lives with the person whose name is on the work.
This is the quiet catch in the whole story. AI can make you faster at producing code than you have ever been, and it can do it while you understand the system less than you ever have, if you let it. Those two things pull in opposite directions.
The developers who come out ahead are not the ones who type the fewest characters. They are the ones who still know exactly what their software does and why, even when they did not personally write every line of it. That understanding is not optional. It is the entire job now.
So I read everything. I do not merge what I cannot explain. When the agent produces something clever that I do not fully follow, that is a stop sign, not a shortcut. The moment I ship code I do not understand is the moment I have handed the responsibility to something that cannot hold it.
What I still like about the work
I expected to mind this more than I do. I came up loving the act of writing code, and a younger version of me would have read all this as a loss, as the fun part getting handed to a machine.
It has not felt like that. The part I actually loved was never the typing. It was the problem. Understanding a messy domain, finding the clean shape hiding inside it, making a decision that looks obvious in hindsight and was not obvious at all going in. That part did not get automated. If anything it got bigger, because I spend more of my day up there now and less of it wrestling with syntax.
The tool changed. The craft moved up a floor. And the thing that made a good engineer good, judgment, taste, knowing what to build and what to refuse to build, matters more now than it did when we were all measured by how fast we could type. That is a trade I will take.
If your workflow has shifted the same way over the last year, I would be curious how it landed for you. And if it has not yet, it will. Worth deciding now what kind of engineer you want to be on the other side of it.
