deadlime

The ChatGPT-refreshed version of the original image

Actually, it should be '36 months later', but I couldn't resist the weak movie reference. So, three years ago, I tried to make a hobby project idea a reality with the help of AI. The experiment was mostly a success, yet ultimately, it didn't produce code that I would be happy to run in production. Looking at it from that perspective, it seems the project was never really finished. Three years is a long time, and the technology has surely evolved a lot since then, so I figured it might be worth trying again.

Briefly about the project: it periodically reads RSS feeds, generates emails from the feed items it finds, and uploads them to an email account via IMAP.

First attempt

Even though this mindset is getting less fashionable these days, I still like to understand "my own" code that's being written. With that in mind, I started the project by writing the code myself, letting the AI teach me how to develop in Go.

I wanted to use as few external dependencies as possible so I could focus on getting to know the language and its standard library. Obviously, I wasn't going to reimplement an SQLite library, but for the pipeline-like architecture I had in mind, I could have used existing solutions. Instead, I chose to dive deeper into the world of Go channels, contexts, and concurrency.

This is a territory where an inexperienced person (me) can easily shoot themselves in the foot, and the AI, with all its enthusiasm, is more than happy to help to do exactly that. If you can get yourself thoroughly confused on your own, with AI assistance, you'll manage to confuse each other twice as badly. The AI makes you doubt yourself, and in exchange, you influence it with every little signal. In the end, you find yourself hunting for some tutorial written by a real human being, back before the AI boom.

As is often the case, after a while, I got bored with this educational project and put the whole thing on the back burner. I managed to get to the point where there was a working prototype, and about half of the pipeline existed in a "production-ready" state.

Second attempt

Later, when I picked up the thread again, I approached things a bit differently. I no longer wanted to learn; I just wanted to finish the project. Not because I actually needed the working program, but because I felt I could get a clearer picture of the tools by seeing something through to the end.

I adjusted my toolkit accordingly and carried on with Claude Code, but not with the currently fashionable "let's unleash 30 agents on the problem and see what they come up with" attitude. The first attempt had given me a solid enough foundation to move forward in small steps. I supervised every step and corrected things when needed, but I didn't make any meaningful changes by hand. I didn't even try running it until the very end.

After roughly half a day and burning through $35, I had what you could call a finished piece of software. Since I'm not a Go developer, I'm unfortunately not in a position to judge how elegant or idiomatic it is. It might not even matter that much now. Maybe people should just give up on reading through the code.

The end-to-end tests still caught a few potential problems (mostly around concurrency), and the dry run with real feed data uncovered a few more (overly permissive regular expressions, improper encodings), but it was nothing earth-shattering.

In the end, I wrote the .gitlab-ci.yml for GitLab CI and the Dockerfile for production deployment by hand because it felt like that would be faster than arguing with the AI about it.

Takeaways

The output

I tend to think that the more complex the topic is, the less you can trust the output (whether it's text or code). This is especially true if you are not well-versed in the given subject. Fundamentally, I consider it a good, personalized learning (or code-explaining) tool, but I have my reservations about the output.

The other aspect of this is how easily it gets influenced by my input. If I throw out an idea, it tends to run with it, but that doesn't make me certain that my alternative was actually the better idea, or if it's just choosing my solution out of an urge to please me.

Sometimes I pitch an idea as a question, like 'I wonder if this would work like this or that.' The AI, of course, responds with 'Great insight, I'll get right to implementing it.' Then it spends 10-20 minutes arguing with itself, tearing the whole project apart, clearly going nowhere, but it won't stop on its own. Eventually, I just make it stop and hit git restore.

Workflow

This is closely related to the quality of the output. My conclusion is that I wouldn't be comfortable letting it run loose and do whatever it wants. You have to catch it as early as possible when it's heading in the wrong direction, challenge its ideas, bring up alternatives (or sometimes just the right keywords). But this can only work if you have a certain level of expertise to be able to tell when things are going off track.

And then there's the oddity that I ended up writing the .gitlab-ci.yml and Dockerfile by hand. I don't think it happened simply because I was fed up with chatting by the end of the day and just wanted to do something. It was probably more along the lines of: if I know something well enough and I think it won't take much time, I'd rather just do it myself than spend the same amount of time (or more) telling someone else how to do it. Especially when that someone gains absolutely no benefit from doing it themselves (because, for instance, they're not capable of learning from the experience).

Speed

In this case, I was using it for a hobby project, so I'm in no rush. The problem isn't that it's slow. It's just that the interaction pattern is somehow awkward. It's a bit too slow to avoid getting bored, but too fast to do something meaningful during the idle time.

You could run multiple conversations in parallel (I haven't tried that), but I suspect neither I nor the AI is particularly good at that kind of multitasking.

Cost and value

Then there's the question of price. As I mentioned, I spent around $35 on this project in the second round alone. I don't know the exact cost of the first round because it was done with a monthly subscription, but my rough estimate is somewhere around $10-20.

I couldn't say whether that counts as a lot or a little, but when that final figure came up, my first thought was: if someone tried to sell me this finished piece of software for $35, I wouldn't buy it.

Brave new world, act two

So here we are, three years later. The novelty has worn off a little, and the cracks are starting to show through the peeling paint. The genie is certainly out of the bottle, but instead of an all-powerful magical being, what we got was a hyperactive junior developer. I'll leave it to everyone to draw their own conclusions based on their own situation. As for me, I still don't see clearly how our life together is going to work out.