Coding Agents Made Me a Better Programmer

Maybe I have a different learning curve, but using coding agents has made me a way better programmer and system designer. I went from GPT-Engineer to Aider to Cursor to Claude Code over the past year. Each one taught me something different.

The common fear is that AI will make developers lazy and unskilled. My experience has been the opposite. These tools forced me to think at a higher level of abstraction. You can’t brute force your way out of not understanding what you’re building. Trust me, I have tried.

The flip happened fast

Around late 2025, something shifted. I went from maybe 80% manual coding with autocomplete to 80% agent coding with manual edits and touchups. It happened over a few weeks, not months.

I’m mostly programming in English now. It feels a little strange to tell an LLM what code to write using words instead of just writing it. There’s an ego hit there if I’m being honest. But the ability to operate on code in large chunks is too useful to ignore once you adapt to it.

This is the biggest change to how I actually write code in maybe fifteen years of programming. And I don’t think most people outside the industry realize it’s happening.

The mistakes are different now

The agents still make mistakes. But the mistakes have changed.

They’re not syntax errors anymore. They’re subtle conceptual errors. The kind of thing a hasty junior developer might do. The agent makes assumptions on your behalf and just runs with them without checking. It doesn’t surface inconsistencies. It doesn’t present tradeoffs. It doesn’t push back when it should.

I’ve watched Claude write 800 lines of code for something that could be done in 80. Bloated abstractions. Unnecessary indirection. And when I point this out, it immediately agrees and simplifies. It knew the simpler solution existed. It just didn’t offer it.

They also still touch code they shouldn’t. Comments get removed. Unrelated functions get “cleaned up” as side effects. I’ve tried to fix this with instructions in CLAUDE.md but it still happens.

Despite all this, I can’t imagine going back to manual coding. The net improvement is too large.

Learning from agent mistakes

Here’s something I didn’t expect: I’ve learned more from fixing agent mistakes than I ever did from copy-pasting Stack Overflow answers.

When the agent gets something wrong, you have to debug it. That means actually reading the code. Understanding the architecture. Figuring out where the logic broke. You can’t just accept the output and move on.

The agents are good enough that the code usually runs. But “runs” and “correct” are different things. I’ve become much better at reading code critically because I have to review everything the agent produces.

Generation and discrimination are different skills. Writing code and reading code use different parts of your brain. The agents handle generation. You handle discrimination. That shift has made me better at the reading part specifically.

The shift from syntax to systems

The biggest change: I went from “how do I write this function” to “how should this system be designed.”

Agents handle syntax. They know the APIs. They remember the import statements. They write the boilerplate. What they don’t do is understand the bigger picture of what you’re building and why.

So that’s where I spend my brain cycles now. System design. Architecture. How pieces fit together. What the failure modes are. The agents are fast at filling in the blanks, but the blanks need to be the right shape.

I think generalists might start outperforming specialists because of this. The agents can fill in specialized knowledge. What they can’t fill in is the ability to see across domains and make good decisions about how things should fit together.

The tenacity thing

One thing that surprised me: watching an agent work on something hard for thirty minutes straight.

They don’t get tired. They don’t get demoralized. They just keep trying things. A person would have given up and come back tomorrow. The agent just keeps going until it figures it out or hits a wall.

I’ve started to realize that stamina is a bottleneck for a lot of work. Not intelligence, not skill, just the energy to keep pushing on a problem. The agents have unlimited stamina. That changes what’s possible.

It’s not just speedup, it’s expansion

People ask how much faster coding with agents is. I don’t know how to measure it.

Certainly I feel faster at things I was already going to do. But the bigger effect is that I do more than I was going to do. I build things that wouldn’t have been worth building before because the effort would have been too high. I approach codebases I couldn’t work on before because of knowledge gaps.

So it’s speedup, yes. But it’s also expansion. The set of things I’m capable of building has grown, not just the speed at which I build them.

Before, I’d take shortcuts because “that would take too long to implement properly.” Now I prototype the real thing. And I learn why it works or doesn’t work because I can actually try the ambitious version.

Leverage through loops

The agents are exceptionally good when you put them in a loop with clear success criteria.

Don’t tell them what to do step by step. Give them a goal and let them figure out how to get there. Write the tests first, then ask the agent to make them pass. Put the agent in a loop with a browser. Let it iterate until the thing works.

This is a shift from imperative to declarative. Instead of “do X, then Y, then Z,” it’s “make this work” and let the agent figure out the steps. That’s where the leverage is.

Programming is more fun now

I didn’t expect this: programming feels more fun with agents.

A lot of the fill-in-the-blanks drudgery is gone. What remains is the creative part. Figuring out what to build. Deciding how things should work. Evaluating tradeoffs.

I also feel less stuck. There’s almost always a way to make positive progress when you’re working with an agent. The feeling of being blocked on something for hours is less common now.

I’ve seen the opposite sentiment too. Some people find agent-assisted coding less satisfying. I think it splits engineers based on whether they primarily liked the act of coding or primarily liked building things. I’m in the building camp.

The atrophy question

I’ve noticed that my ability to write code manually is starting to atrophy.

The little syntactic details. The exact API signatures. The boilerplate I used to write from muscle memory. It’s fading. I had to look up something basic the other day that I would have known cold a year ago.

This bothers me a little. But I can still read code fine. And reading code is what matters for reviewing agent output. Generation is the part that’s atrophying. Discrimination is holding steady or improving.

Maybe this is fine. Maybe it’s like how I can’t do long division by hand anymore but I can still reason about numbers. The low-level skill decayed but the high-level understanding remained.

Or maybe I’m rationalizing. I’m not sure.

Where this leaves me

The capability of coding agents crossed some threshold in late 2025. Something changed in how coherent and capable they became. It caused a phase shift in how I work.

The intelligence part feels ahead of everything else right now. The integrations are still catching up. The workflows are still being figured out. The industry is still metabolizing what this means.

I don’t know exactly where this goes. I’m pretty sure the ratio between the most productive engineers and the average is going to grow a lot. I’m pretty sure that understanding systems matters more than memorizing syntax. I’m pretty sure that the people who learn to work with these tools well will have an advantage.

What I’m less sure about is what programming feels like in five years. Is it like playing a strategy game? Managing resources and making decisions while the execution happens automatically? Is it like conducting an orchestra? Directing the overall shape while others handle the individual parts?

I don’t know. But I’m having more fun building things than I have in years. And I’m learning more about systems and architecture than I ever did when I was focused on the syntax.

That feels like a net positive. Even if I can’t do long division anymore.