The Shopping Trolley Theory: LLM Edition

Programming in the present is extremely fun. Languages are becoming more expressive, new editors are emerging with their own flavour, but one thing has controversially poisoned the joy of programming: LLMs.

In every era, a new programmer faces different struggles compared to one from a different time. Perhaps that’s having no internet and needing to rely on books, or asking questions in a phpBB forum. But for some time now, there hasn’t been a need to wait for someone more experienced to give you an answer, because the yes-men (LLMs) will always give you something immediately.

Personally, I find a lot of joy in programming. I find a problem akin to solving a puzzle, which in turn releases those sweet, sweet dopamine hits.

When I was a CS student, I took a class on systems programming in C. In the early weeks of the semester, one of the week’s exercises involved a linked list implementation. As I liked to always stay ahead when material was released, I tried writing it a week early before the class. I think deleting was what I found the hardest, and overall it took me a couple of hours to finish. I spent a lot of time during my failures, slowly thinking about what happens when x or y occurred, which eventually led to me being successful.

I didn’t know what a linked list was, but by understanding how it’s supposed to work at a high level, I wanted to try my best. In doing so, I gained growth. This is a pattern I would repeat again and again. Of course, I could’ve simply looked up an already written implementation, but that would’ve stolen my chance to grow by enhancing my problem-solving ability. I think if you don't make an honest attempt, then it’s no different from being someone with 1 year of experience repeated 10 times.

This is where the present comes in: LLMs are very accessible, and everyone is using them. Unfortunately, there’s no gatekeeping because the creators want your money by building the best models and generating hype about their capabilities. It’s like a drug, almost. The temptation is very strong when your friends are also using them. LLMs, though, are going to be okay at some things and bad at others.

Having access to an LLM is like using a shopping trolley to help you carry all your shopping around the shop and then back to your car. Appropriate use of the trolley would be to return it to its bay once you’re finished with it. Unfortunately, some bad eggs will leave trolleys in poor spots (sometimes blocking other car park spaces). The morality behind where you leave the trolley can determine your maturity in handling situations without being pressured by others (some may care that people see them leaving a trolley somewhere; others really don’t care).

I don’t think it’s fair to say that using an LLM = bad / not using an LLM = good. LLMs are here, and leveraging them (like a trolley) is a net positive. You must ensure, though, that you’re responsible with how you use it (looking at you, person taking a huge trolley through a tiny self-checkout area). For boilerplate code, there’s nothing interesting about remembering how to write it after you’ve done it once. There’s no chance I’ll remember how to wire up SSO in Spring Security, but I’ll know what the code looks like when I see it.

For more ‘ambiguous’ things, like algorithms, you would definitely need to know them before consulting an LLM. If you rely on the LLM to one-shot your quicksort, mergesort, or mindgoblinsort code, there’s no chance you will know it’s correct (thus, the problem with LLMs shines). It’s not wrong to use an LLM to attempt to generate the algorithm, but you have to know what the implementation must correctly be. Overreliance on LLMs will make you appear replaceable if you’re unable to solve a problem without them; they should just be enhancing you, and that’s specifically about code.

Copilot seems to be making its way through every enterprise as the most common LLM that’s enterprise-approved. We’ll see a lot more LLM-generated code at work soon (if you haven’t already). Unfortunately, I’ve seen some poor-quality code in other teams where someone will raise a PR with obviously LLM-generated code that looks extremely sloppy and unmaintainable. If you’re going to use LLM-generated code, you could use it to get a working implementation, get tests that cover the expected outcomes, and then refactor. You don’t want to be that person who leaves their trolley somewhere, right?

I am always worried, particularly with Java code. Most places are still using Java 8 (the rest, which obviously use Spring, were bullied by Spring to move to version 17 at a minimum), which means that LLMs are trained on some of the least compatible code in existence with modern Java versions. Java 8 has also been around for over 10 years, and there are still many developers who don’t understand its features well. This results in skewed training data that won’t generate great code for Java ≥ 21. Will they train better with the code of tomorrow? I’m not sure, but I would hope so. The code of tomorrow will also look very different.

Just please be courteous and put your trolley back; don’t make it someone else’s problem.