Developer in the Age of AI Agents: Redefining the Joy of Coding

In the early ’80s, I was typing in code listings from Compute! magazine. I wanted to understand everything, control everything. After a decade of personal projects, including a BBS, that passion became a career.
Despite the demands of work and my move into management, I never lost my taste for programming. Until recently, I was still setting myself coding goals for the holiday break: writing code recharged my batteries.
So I dreaded the arrival of AI coding agents. Now that they’re here, I feel melancholy, even sadness. What do you do when the thing you love, the thing that defines part of who you are, gets handed over to robots?
And yet, I’ve stopped resisting. Agents make it possible to achieve great things in a fraction of the time. Used well, they produce quality code. Those who denounce “AI slop” clearly haven’t seen all the “human slop” I’ve reviewed, or written, over the past 40 years!
So it’s with enthusiasm for what’s possible, but also while grieving an activity that nourished me for so long, that I decided to move our agentic shift forward.
Human-Centered Agentic Development
Our client experience relies heavily on our employee experience. It’s hard to deliver great service if our teams aren’t happy, motivated and engaged.
That’s why we approached this transition by putting people first: everyone who wanted to make the change had to have the opportunity to do so.
Our process must bring in humans at the right moments, for the right things. Their judgment and creativity are essential. That, I believe, is exactly what we need to protect. The risk is very real: a developer flooded with proposals to validate ends up approving them mechanically. They no longer review, they just stamp (the infamous rubber-stamping). At that point, the human is no longer in the loop. They’re just part of the scenery.
Agent capabilities keep evolving. We have ideas about the future roles of our teams, but we’re keeping an open mind. We’re asking everyone to embrace change, break down silos between practices and foster collaboration.
However, in all of this: how do you find joy again when you’re no longer doing what you loved?
Rediscovering Meaning at Work
Cutting stones, building walls or raising a cathedral: everyone can find fulfillment at different levels. Meaning at work is personal, and it shifts from project to project and moment to moment.
So I won’t pretend to define the meaning of developers’ new work. That would be reductive. What I can do is share the realizations that helped me make the leap.
First, I came to understand how much programming let me get into “the zone,” that state where time disappears and focus becomes deeply satisfying. That pleasure is no small thing: the brain gets real rewards from it. Replacing those hours with exchanges with agents is more efficient, but far less rewarding.
I sometimes find that bubble again by focusing on a specific task while my agents carry out my instructions. To get there, I have to resist the urge to constantly check on their progress.
Second, I rediscovered the satisfaction of seeing someone use what I’ve built. A script, a microservice or a feature: meeting a real need is still motivating.
Agents speed up that response, with an unexpected bonus: I’m more open to change requests. After a few hours of building rather than several weeks, I’m less attached to the initial solution. Happier users, more often: that’s rewarding.
Finally, I’ve always been confident in my ability to find technical solutions. Learning a language or a technology mostly took time. Agents save me that time and let me focus more on the “what,” at a speed I never had access to before.
These realizations are personal. You may not recognize yourself in them, and that’s okay. First, you need to understand what used to bring you joy, so you can find your own way to evolve.
Because there’s no going back: coding agents are here to stay.
What the Future Holds
I don’t have a crystal ball, but I believe the transformation of software development is only just beginning.
It requires rethinking the entire development lifecycle to integrate AI in an efficient and controlled way. Simply replacing a few steps risks producing disappointing software, for users and creators alike.
Engaged teams, however, will be able to solve far more problems, far faster. For developers, that means shifting our attention from the “how” to the “what” and the “why.”
Of all the changes I’ve lived through in four decades, this is the one I find the hardest. Still, I believe I’ve reached my tipping point, without turning my back on the curious teenager who brought me here.
I’m convinced you can make the leap too, in your own way. I’d love to hear about your experiences!