A follow up to my last piece on AI in the developer workflow. Since then, a lot has changed in the models, and in everything built around them.
Since My Last Post
Last time, my mental model was simple: LLMs were very good at summarizing, explaining, and producing simple snippets of code. A great autocomplete with a brain, but a single pass tool at the end of the day: you ask, it answers, you paste.
That’s not what an LLM is anymore. Two things happened:
-
The models got dramatically better at reasoning. Current models don’t just predict the next token; they plan, backtrack, call tools, inspect their own output, and recover when they fail. They can “think” in a way that 2024 models simply couldn’t.
-
The harnesses caught up. In 2024 there were a few early harnesses, scaffolds that could generate code in a loop. Today’s harnesses (agents, tool integration, file access, terminal, test runners, context management) are a completely different category. Delegation is now trivial: you hand the agent a task, and it works in a loop, reading, writing, running, failing, fixing, repeating, until the task is done.
The result is that agentic coding went mainstream fast, and honestly, I consider it S tier now. Not “promising tech”, not “useful for boilerplate”, but a legitimate primary way to build software.
What Actually Changed for Me
Producing a project is the easy part, and I mean that literally. A weekend of focused iteration with a good model and a good harness can produce a working app that would have taken me weeks solo. But the bigger shift is on the other side of “done”: maintenance.
Maintaining software was always the expensive part. With agentic coding, the maintenance cost dropped dramatically too, which changes the math on small and mid sized projects entirely. Projects that used to die because maintaining them alone meant too much overhead simply stop being a constraint.
That said, I want to be honest about where I stand: I’m still experimenting. I haven’t fully pushed agentic coding to its limits, and I’m the first to admit I don’t know its full potential yet. What I do have is a clear picture of how I want a harness and model pair to slot into my daily workflow, and the results so far are very promising.
What Bothers Me (A Little)
There’s one inversion I find genuinely strange: we write less and less code, but the “quality” of the software we can produce keeps going up. That sentence felt contradictory a year ago. It’s not anymore, but it’s still worth sitting with.
And there’s a hard limit I’ve hit: generating a large application entirely with an LLM is possible, but reviewing it as a human is extremely hard, sometimes practically impossible. At that scale, you’re not really developing anymore; you’re literally entrusting the project to the agent. The code stops being “mine” in the old sense, and starts being something the agent owns and I supervise.
That’s fine. But it’s a different relationship to the work, and I think we should name it.
The Tradeoff That Remains
There’s an eternal tension between speed of production and depth of understanding. Agentic coding pushes hard toward the first. So the bar I hold myself to:
- I keep the main hand on what gets generated: the problems being solved, the architecture, the tests.
- I review diffs, I run the tests, I understand the invariants, even when I didn’t type a single line.
- If I can’t explain why a piece of the codebase looks the way it does, it doesn’t ship.
As long as that holds, agentic coding stays manageable. The moment it doesn’t, you’re not developing software anymore, you’re gambling with it.
What Actually Produces Good Results
One more observation from my experiments: raw output quality has risen across the board, but nothing exceptional comes out of a single prompt. The apps and tools that feel genuinely great are the ones that were orchestrated: iterated, constrained, tested, refined over many agent cycles. The quality now lives in the loop you run, not in the model alone.
Same lesson as with humans, honestly: better artifacts come from better process, not from a single heroic gesture.
Where I’m Convinced
I love what this unlocks, and I’m fairly convinced agentic coding is going to be a normal part of our daily workflow, not a novelty, not a niche tool. The models have the reasoning, the harnesses have the autonomy, and the maintenance economics are already different.
So that’s where I am: experimenting seriously, keeping my hand on the wheel, and paying attention to what it feels like when the person in the loop stops being the typist.
This text was drafted with the help of AI… but the experiments, the doubts, and the opinions are 100% mine.