Almost everyone has some kind of opinion on how Large Language Models are changing how we work or search for information. Recently I have realized when discussing my stance on LLMs, their benefits and drawbacks I had a hard time to formulate my opinions in reasonably short and coherent way. So this post is an attempt to sift my thoughts and lay out what I think about them especially with regards to Software Engineering.
On learning and skill
I admire good and efficient design, not only in code, but in engineering in general. This should not be confused with processes where sometimes having some kind of friction is deliberate and good.
I also like solving puzzles and solving difficult problems. It’s rewarding to be able to understand a system, program or concept in a deep and detailed way which then enables me to use that understanding to point the finger to the root cause with ease. I also like to learn a lot. Recently I came across a Modern Java online book that I found so enjoyable. It mentions something in the intro about why should people install an editor without a Java plugin:
That is a valid question. The answer is that such plugins are usually made with working professional developers as their intended user. The kinds of support they provide can be helpful in preventing you from making all sorts of mistakes and help you to produce working code quicker.
Somewhat counter-intuitively - and you’ll have to take my word for this - when you are learning you actually want to be making mistakes and producing working code slower. Your primary goal should be to acquire a skillset and “bumping into the guard rails” is helpful for that.
Ever since I’ve read this paragraph I was subconsciously thinking about how very true this is. And even though I’ve never said it being stated do clearly, this is how you actually learn code best. By making mistakes and failing. When you have a Java plugin in your IDE, it can help with the boilerplate and will highlight mistakes in your syntax. But this is not what you want when you learn. And you must actively learn when you want to be good at something.
Your attention
How does this relate to the LLMs? People in Software Engineering use AI for various things, from generating code, analyzing new and unknown codebase, finding security vulnerabilities, writing tests, boilerplate or repetitive code all the way to fixing existing bugs and researching new system architecture. With agents you can now effectively offload all of the code generation to the language model. It has been said that this democratizes the development making it more accessible to people without the necessary background and skill. But does it though?
As an experienced programmer even if you supervise the agent and have to go slowly through the code it produces you can still find yourself more productive and when the model starts to hallucinate, you will be able to spot that quickly and go back without losing too much time. On the other hand If you don’t have a clue about the code being generated, you might eventually get stuff done just by chance if you persist long enough, but you’re not getting better at coding, your brain was on autopilot the entire time. Why should you care about that?
LLMs ability is so attractive, the ease how the code be generate can feel almost magical. Stumbling over a working program out of sheer luck is like getting a big dopamine hit. If you’ve never worked with any particular programming language you feel like you can start contributing without actually learning absolutely anything in this domain. It still feels very good though and you might feel that this is really rewarding and worthy of your precious time.
It’s progress isn’t it?
Now you might argue that this is the entire point, it’s just progress and we’ve seen these kinds of shifts in the way how people rely on tools more and more becoming dependent on them. We don’t really calculate in our heads anymore since the pocket calculator was invented but we still teach kids the maths without them. I think with programming it’s similar, now you have this extremely powerful at your hands, but you don’t want to use it at all times, especially not when you want to learn.
When you learn to code, you’re not just generating text. You reason about the abstractions, you use suitable data structures, you think about performance. Language is a means of exchanging information with other people about a model of something that exists inside your brain.
Now you might want to say: “But hey, you can still use LLMs to assist you with learning, improve how you reason about particular code base or complicated system instead of just use them to generate new code.” And sure, that absolutely right and for me this is the way how I’m using LLMs right now.
Final thoughts
I see some parallels in the aviation industry, you can judge if you feel it’s not a fair analogy, but please bear with me.
The big commercial jets are and have been capable of flying on their own using computers that are processing sensor data for quite some time now. However as it turned out, the pilots became used to rely on the automation and have stopped practicing their skills and their mental model of how the plane behaves. This caused a serious problem during emergency scenarios and this was a major contributor behind the tragic Air France Flight 447 accident where the pilots were clueless as of why the plane keeps loosing altitude when their nose was still pitched up.
I’m not arguing here that software development has the same safety requirements as in aviation, but being skilled in something unfortunately does not come for free (either by watching LLM generate complex code or observing in the captain’s seat how a plane flies itself).
There are other implications and things that worry me which I haven’t touched on yet:
Junior engineers are usually being mentored by their more senior colleagues and they learn from them how to think about the problems. We might lose this aspect if the junior developer instead of asking for help just uses LLM as that’s less of a hassle.
Sometimes the best solution for a problem or a requirement is to remove code instead of writing more of it. I think this also comes with experience but so far I am not convinced that having LLM at your disposal which makes writing more code so cheap in terms of effort will foster this mentality in developers.
The price of the frontier LLMs is heavily subsidized to gain market share, I wonder what the actual cost will be, if these companies would be profitable from inference only.
I doesn’t go well with me that the models are trained on copyrighted material without author’s consent.
Oh yes, and we’re most likely ruining our planet.