I first wrote about this in a thread on X. A thread only gets you so far, though, and this one deserved more room, so here it is at length. In particular I want to explain what I mean when I say I've always thought of programming as a form of art. Without that, my mixed feelings about working with AI agents probably just sound like grumbling.
I've been writing code for most of my life, and what I love about it has never been only the result. It's the work itself. I have spent endless nights on something nobody would ever notice and gone to bed pleased with myself, because I'd finally found the right way to say what I meant. Lately I think about that pleasure a lot. Mostly because I'm getting less and less of it.
The closest comparison I have is writing. A writer cares about a word, the rhythm of a sentence, where a paragraph breaks. Nobody reads a poem and asks whether it compiles, but the care is the same kind, and I feel it about how I express myself in code. Take C#. I like the syntax, the actual shape of it. There are several correct ways to write the same behaviour and I'll have a strong opinion about which one is right, where right means the one that reads the way I hear it in my head. Choosing names. Arranging an expression until it says exactly one thing, and says it concisely. I can read a piece of code I've just written and enjoy it before I've even run it. That probably sounds odd if you don't write code. It doesn't sound odd to me.
The feeling is strongest when I find the right abstraction. After this many years I don't really start from a mess. My head already thinks in code, and by the time I sit down the shape is usually there, at the right level of abstraction. What follows is refinement. I go over it again and again, a little finer each time, chasing a kind of perfection. Maybe a responsibility sits one layer away from where it belongs. Maybe two variants of the same problem are still handled as if they had nothing to do with each other, when they should be one thing. One more pass and I can read it back and think, yes, that's it. I care about that even when the code already worked. Even when I'm the only person who will ever know the difference.
It works at the other end of the scale too. When I design the infrastructure to orchestrate a set of microservices, I'm deciding how to split responsibilities, how the services coordinate, what happens when one of them fails. Scalability forces the same kind of thinking: maybe the work needs distributing differently, maybe I'm sharing more state than I should. I enjoy reasoning my way through that and landing on something I can understand, explain to someone else and actually run. It's the same satisfaction as getting one small idea right in C#, only bigger.
Then there's the slow accumulation. Over the years I've built up abstractions and reusable components so I don't have to reinvent the wheel every time I start something new. It usually goes like this: I solve a problem inside one project, later I notice it's a more general need, and I work out how to pull that piece out and make it useful elsewhere. That means deciding what belongs inside the component and what should be left to whoever uses it. I get the boundary wrong. I fix it after using it a few times. Eventually I reach the point where I can pick up that small piece with complete confidence, because I know exactly what it does and exactly where it stops.
And then the best part: starting a new project and assembling it out of those pieces. I recognise something I worked out a long time ago, combine it with something new and watch the whole thing run. I remember the effort behind each part. The finished project is the new idea, of course, but it's also the visible result of all those earlier decisions, and there's a continuity in that I find deeply satisfying. I've made something new out of a pile of small things I once cared enough to build well.
There's an odd twist to this. Nearly everything I've just described is technical skill, built up over years, and that's precisely what's fading now. Some of it has gone, some of it has just been muted, because it matters less than it used to. What hasn't faded is whatever got me there in the first place. The thing that made me good at the art of programming turns out to be the same thing carrying me forward into agentic coding, and that makes me suspect it was never really a hard skill. More of a soft one. Wanting to learn. Curiosity. The constant itch to get better and to keep discovering new things.
So. Agents.
When I started coding with them, I spent an embarrassing amount of time arguing. I'd ask for an implementation, read it and immediately find something I wanted to fight about. Sometimes I could see a more efficient approach. Sometimes I simply couldn't accept how many unrelated responsibilities had been shoved into the same place, or how much work I'd need later to change one small thing. God files. Those damned god files. I'd open one and find half the application crammed inside. This still happens, by the way. I haven't reached some serene state where I look at that and think it's fine. I look at it and it still annoys me. A lot.
I tried very hard to teach them to work the way I do. I wrote instructions about SOLID, about Clean Architecture, about Domain-Driven Design. I specified the stacks, the boundaries I expected between parts of the system, the responsibilities that had to stay apart. Then I'd review the result and send it back for another pass. I could burn a long time explaining why something should be organised differently, correcting it, and rewording the instruction so I wouldn't have to have the same argument tomorrow. Often I had a solid engineering reason. But I also had a very precise picture of how I would have written it myself, and I didn't always stop to check which of the two was actually driving me.
At some point I got tired of fighting windmills. I was spending the time I'd saved on implementation trying to get exactly the implementation I would have produced anyway, which, said out loud, is a strange way to save time. So gradually I moved up a level. I still set the architecture. I still pick the stack. But more of my attention now goes to what I actually want to build, the constraints I can't bend and the decisions that will be painful to reverse later. I still step in when I see a real problem. I'm learning, slowly, to tell the difference between a correction that matters and a preference I'm dressing up as one.
I also had to laugh at myself, because I was turning into a caricature. The old-school programmer from the late eighties or nineties, sneering at someone for writing C without knowing assembly. Well, of course it's easy if you're using C. I could see how ridiculous that attitude is and I was doing my own version of it anyway, with agents. I'd grown attached to working at a particular level and I didn't want to let go, even when I could see what I'd gain by letting go. I don't want to be the guy who dismisses someone's work because they didn't have to suffer through every hard thing I once did.
So now I describe what I want, discuss the architecture, push back on the decisions I think deserve it, and then watch thousands of lines appear that I didn't write. I'm still thinking. I'm still choosing. I just spend far less time living inside those choices line by line. I can be genuinely impressed by how much I've managed to build and still feel, at the end of it, oddly flat. Sometimes I miss the exact work I used to complain about having to do.
I won't pretend I enjoyed every minute of programming. I didn't. But when I hand over more of the implementation, I also hand over a good part of the pleasure I've just spent all those paragraphs describing. I can review a generated component and understand perfectly well why I'd use it, without ever having had the satisfaction of designing it. When I assemble a project from components I built over the years, I remember making those choices. With an agent I can reach a working project having made far fewer of them. There's still an idea to chase and decisions to take, but I'm present in the implementation in a different way. That distinction matters to me, even if it's hard to explain to someone who only wants to know whether the software works.
And yet. I have never experimented this much in my life.
I can try something in a night that I used to shelve because I knew it meant weeks of implementation. 3D pipelines, AI experiments, games, small tools. I can chase a genuinely ridiculous idea just to see what happens, and I have a real weakness for ridiculous ideas. I don't need a business case to justify a couple of days spent being curious, quite often multiple topics in the same session.
Before, I had to ration myself. I could find an idea fascinating and still turn it down, because I could estimate the effort and the answer was always too much. At this point in my life there aren't enough evenings and weekends to explore everything that interests me the old way. With agents I can afford more of it. I can get far enough in to find out whether I want to keep going, instead of killing an experiment before it has taught me anything.
I find it hard to weigh those two things against each other. I used to get more joy from building every piece by hand. Now I have more time to explore, which is something I have always, desperately, wanted more of. I still enjoy programming. But more and more, what I enjoy is finding out whether I can make something interesting at all. I've started asking what would happen if I just built the idea, before worrying quite so much about how.
Up at that level there are still plenty of creative decisions to make. What to attempt. Which direction to follow. Whether I like what came back. When I ask for changes I'm drawing on taste and experience, and the less time I spend on implementation, the more obvious it becomes how much all of this rests on ideas, curiosity and judgement. I've grown comfortable working this way. I have not entirely worked out how I feel about what I've given up.
The part that actually worries me is learning.
As a programmer I learned by struggling at least as much as by succeeding. After hours stuck on a problem, I'd understand something I could never have got from reading a working solution. I'd tried the wrong approaches myself. I knew where my bad assumption was, and I'd recognise the same mistake the next time it turned up in a different shape. That's where intuition comes from, tedious parts included, even the ones I would happily have skipped at the time.
When I delegate the hard piece, I may also be delegating away the chance to learn it. I can read the result, ask questions, poke at it. I'm not convinced I learn the same things at the same depth. I might nod along with an abstraction without ever discovering, for myself, why the alternative would have hurt. I might approve a design meant to handle more traffic without following every assumption closely enough to know when I should start doubting it. I don't want to romanticise pointless frustration as if suffering were a credential. But I do want to take seriously the possibility that in skipping some of the struggle, I'm also skipping some of the learning. Noticing how fast I can finish a prototype doesn't settle that.
Until a few months ago I feared something bigger than my own learning. I thought AI would make all of us a little more stupid. The agent does the heavy lifting anyway, so why bother, and over time we'd hand over the difficulty of thinking itself. Much as most of us stopped being able to find our way around a city once Google Maps arrived. Then again, nobody needs to know how to strike a flint to light a fire any more, and we don't call that a loss. What changed my mind was noticing what exploring does to me. Every new idea, every new project makes me want to dig deeper, not less. So I no longer think AI makes people stupid across the board. I think it's an amplifier. A curious mind, hungry to learn, gets a tool that multiplies it. A mind with little curiosity and few stimuli gets a very comfortable way to stop using itself. I'm not especially optimistic about how that averages out, and I'd like to be wrong. But that's a different essay.
Even so, I feel intellectually reckless again, and I like it. I can follow an idea into a discipline I barely know without first deciding whether months of effort are justified. Experiment, get it wrong, turn around and try another direction. Spend time on something for no better reason than that it interests me. At this stage of my life I value that more than I expected to. Without it, too many of those ideas would simply stay unexplored.
I can't honestly call this a straightforward improvement. I miss something I loved about programming, and I don't expect to stop missing it just because I can build more now. I also have no intention of giving up this freedom to experiment. There are more disciplines to poke at, more strange ideas to try, more chances to turn a passing thought into something real. I can be sad about doing less of the craft myself and excited about what I'll try next. Both at once. That's what I mean by a bitter victory, and I'm still living with both halves of it.