Every different personality seems to react differently to the way large language models are affecting software development. Some of my friends bemoan that they feel like they never fully gained an understanding of the fundamentals, and that LLMs are pushing that further and further away if they don’t have to look at them. Others say it’s taking the joy out of software development, because all the fun of puzzling out a bug and finally solving it is lost when Claude just does it in a few turns.
For me, however, I’m hugely enjoying AI. Which is really strange, because I don’t really like the code it outputs. I think that’s because, for me, the code and the process of debugging weren’t really my favorite part. That’s not to say I didn’t hugely enjoy it. I love solving puzzles and problems. But I always have a vision for the project and the goal I’m trying to reach, and those ideas, concepts, and things I want to experiment with come thick and fast.
There are so many times when I have discarded a side project because I knew I wouldn’t have time to complete it, even though I knew exactly how I wanted to build it, what I wanted to play with, what I wanted to instrument, and how I wanted to see it fit into the software and world around it.
In my archive folder, I have somewhere around 40-plus side projects that I started just to play with, sitting abandoned. Most of them got to the point where I could confirm that the concept they were built around would work. At which point, all that was left was eating the rest of the elephant. That’s usually the point at which I would recognize that the amount of work required to take that concept into something useful was far too much to fit my otherwise busy schedule.
And so those side projects would sit in a folder, all alone, knowing they were a cool idea I’d never be able to finish. And so the joy of proving out a novel concept would quickly give way to the despair of knowing there was no future for the idea, and that it only existed to satisfy my own curiosity.
And that is why the world of LLMs is such a massive benefit to me. Whenever I have an idea, I know how I want to implement it. In fact, many of the ideas come from me recognizing an odd use for an existing piece of technology, and/or an algorithm, or some concept I’d want to merge with some other concept to see if the end result would be worthwhile.
You can see plenty of such ideas on this website. For example, uApps are just what would happen if you stuck a web application and a SQLite database together in one file and passed it around like a spreadsheet. Or CubbyCAD, which is basically: what if you took TinkerCAD, combined it with the best parts of Blender, and added a novel way of interacting with shapes as if they were voxels?
Or Guido, which is an idea I’ve had since I was a teenager of taking the good old Godot game engine, stripping out everything that makes it focused on games, and using it as a lightweight cross-platform UI library over IPC. I called it Quark ages ago, but knew I would never have time to finish it. Once the concept was proven, it was meant to be a sort of lightweight alternative to Electron that would let you use any backend language to write a high-performance, cross-platform UI. It’s still a side project, but it’s much more to the point of being usable than it ever was before.
Another concept I’ve played with, more or less successfully, lately is the idea of bringing row-level security to SQLite. I want to be able to deploy a multi-user SQLite application without needing to implement a layer in front of the SQL that would provide authentication and authorization. I will admit that project hasn’t gotten as far as I would have liked, because I think the underlying infrastructure isn’t quite able to support the overall idea, but at least the basic concept is proven.
All of these things would have been cases where I’d try to write the minimum amount of code possible to get the concept to work, so that I could prove the concept and make myself happy, and then immediately be disappointed by how much I’d have to abandon the project, because there was nowhere it could go after that point.
So LLMs let me iterate on the ideas in my head, find the good ones, build the good ones out the way I want them to be built, and then move on to the next idea. It’s a sort of force multiplier for taking the ideas I want to explore much further than I could have on my own.
I still hate the code they generate. Oftentimes I look at it and just wonder how to untangle it, or what I’d do to refactor. But until I’m ready to take an idea into production, there’s not really much reason to refactor if all I’m trying to do is prove a concept.
And since LLMs started helping me prove my concepts, for the first time I’ve actually had ideas that I thought were worth taking into production. Ideas like CubbyCAD and uApps, that I’ve actually found useful in my day-to-day life.