Over the last couple of years I've adopted agentic coding practices and really leaned into using it for my side projects. Looking back at the work I've done this year and it is clear that my code output has increased quite a lot, but the number of unfinished projects has increased in kind.
I think that the reason I have such a hard time finishing things, even with the help of these powerful agents, comes back to the old 80/20 problem, where the first 80% of the work takes 20% of the time, and the last 20% takes the remaining 80%. LLMs haven't solved the last mile problem, not yet anyway, the unintended side effect is that the cognitive load on the human developer is dramatically increased.
In my experience the best way to develop software is to make something very, very small, that works, and then you iterate on top of that. As you do so the kernel of the way the code works becomes cemented in the developers mind slowly over time beneath the layers that are built on top of it. This helps me develop a good mental model of how the code works, and agentic coding short circuits this in a couple of ways.
First, they tend to generate way too much code to start with, and it's getting worse as context windows get larger. Second, they have no problem re-writing whole swathes of code from scratch to solve a problem, which prevents me from developing a good mental model of the code, so I frequently have to ask the agent to explain to me what is going on.
This reminds me of the quote
Complexity can't be eliminated, it can only be moved.
I think this is true in the case of agentic development as well, we've sort of taken the complexity out of writing code and transformed it into a different kind of complexity. Where I used to have a small number of projects that I knew well enough to jump back into at any time, but was blocked for lack of intelligence. Now I've unblocked all of those projects, plus added a half dozen more, except I don't "know" the codebases of any of them.
So while before I didn't want to work on a project because of whatever known issue was blocking me, now I don't want to work on projects because I'm low key dreading the process of re-mapping their complex code bases into a mental model in my mind.
Sometimes too, I feel like watching the agent burn through tokens while it's "thinking" is just as frustrating as banging my head against the wall myself, just frustrating in a different way. Instead of whitling away at the problem and slowly reducing frustration by increasing understanding until the problem is solved, now I watch an agent re-write a couple of classes before prompting it with something like, "the code couldn't have been that wrong before, could it?" and getting a response like, "you're right, this could be done more concisely" and changing 10 lines instead.
So what's the verdict?
Even after saying all of that I don't think humans, generally speaking, will ever write code again, I'm still going to continue generating all of my code as well. But I wanted to report back from the field and give a realistic view of what LLMs are capable of. Even in my day job, I spend a lot of my time applying the latest models to a variety of problems, this week Codex 5.4 dropped, and I've never felt more secure in my role as a developer.