I’m bored. And I don’t really know what to do about it.
I’ve been writing software for about thirty-five years.
I’ve been getting paid for writing software for almost thirty years.
In February I realised that what I did had fundamentally changed. That’s right, I’m talking about coding agents.
I’m still working as software developer, I’m still shipping code every week. In fact I’m probably shipping more code than I ever have before.
I’ve managed to get my clankers to handle most of the parts of the job that I don’t like - code review, estimation, boring stuff.
I’ve got a process that, for the most part, I can trust the clankers to write and release code which works - without security issues, generally bug-free, reasonably well-structured and understandable.
But now I’m bored. And also confused.
A while back I started on a full rewrite of my plumbing gemDon’t try using it - the rewrite is not ready.
The first part of the rewrite was entirely clanker-driven. I explained what I wanted, it went away and did the work. I checked the specs, which described the changes I wanted. And the specs all passed. Sounds good right?
So I set the version to 1.0.0 and published it.
Then I actually tried using it in a project.
And I found lots of sharp edges in the API that I did not like. As I’ve said before, rubyists look at things slightly differently to other types of developer.
This is my fault, not the clankers.
They built what I specified. I had started from what I wanted the gem to do when I should have started from the application that actually used the gem. That way I would have figured out how I wanted it to feel whilst using it and I could extract the new API and implementation from there.
Always start with the user.
So I opened up my editor and started changing the gem’s API.
And I hated the code that the clankers had written.
It was functional. It was efficient. But it wasn’t mine.
I reorganised the code, changing how individual pieces were split into modules, renaming things, restructuring the interactions between different classes and objects. All good object-orientated stuff.
And when I had finished, I realised that the whole process had been a headache.
I kept running into issues; specs would fail and I’d spend loads of time scratching my head and debugging.
It was not fun.
Plus I’d touched every single source file (including renaming a number of them). There wasn’t a class, barely a method, that was unchanged.
Remember - this wasn’t necessary.
I could have just updated the API.
But I couldn’t stop there, because I didn’t like the way the code looked. And even worse, this API change and refactoring took me hours.
The original clanker-driven rewrite took about three hours over the course of a few days. My manual rewrite took me at least eight hours, mostly done over three evenings - eating into my spare time.
The code feels like mine now.
I am much happier when looking at it.
But, in the near future, which humans are ever going to sit down and read the code? Aren’t we all just going to point our coding agent at it and say “how does this work?”
So, my job has fundamentally changed.
Now I spend a lot of time just waiting. The clankers do their thing and I take a look at their summaries.
And because I’m used to the clankers doing all the fiddly, messy, frustrating stuff, a big part of writing code by handthat I used to love is just annoying now.
Bored. And confused.
I think the answer is to put together sketches of the code, in the style I want, then let the coding agent actually make it work. Repeat the “keep the bits I like, give them the bits I don’t” strategy.
But I’ve not figured out how to do that yet. I’ll let you know when I do.