A simple takeaway from two years of agentic coding.
I've been using coding agents for a while now, and the biggest change I see isn't in the way software works. It's in the way we write software.
We still do the same things we've always done: design, implement, test, review and refactor. The difference is that implementation is becoming much cheaper. Instead of writing the code ourselves, we describe what we want and the agent writes it.
That moves the focus to design. Knowing what to build, how the pieces should fit together, and where the design will break when the system gets bigger.
In fact, I think the fundamentals of software engineering are becoming more important, not less. An agent will build whatever we ask it to build, and it will usually do it successfully. But it can still follow bad patterns at scale, and it's not very good at criticizing its own design.
Reviewing the code isn't really different either. I still review it the way I always have: understand the design, see how it fits the bigger context, and look for things that will cause problems later. I probably pay more attention to tests now, because agents have a tendency to generate a lot of redundant ones.
The interesting part is that this isn't really a new way of programming. It's more like moving programming up the stack — similar to what C++ did compared with assembly.
The code is still there. We just don't have to write all of it ourselves anymore.
For me, that's the real change.
What has changed most in the way you program over the last two years?
Top comments (0)