The Future Is Bright for Human Software Engineers
Despite many people thinking that Large Language Model (LLM) technology will reduce the need for software engineers, I remain optimistic about the future of human software engineers such as myself. One major reason for this is that LLM products such as Claude Code are likely being priced at levels far less than they actually cost. In my view, it is only a matter of time before the companies behind these products are forced to significantly raise prices or degrade quality. However, this is mostly speculation on my part, so I decided to focus on the following reasons why I believe creating software by programming computers directly is still the future.
Quality is more important than speed
Some LLM enthusiasts like to boast about how the tools allow them to ship code more quickly. However, this not a positive development in my view. When it comes to building software, I believe that it is more important to do it right than to do it quickly. Software that has not been carefully designed or implemented will undoubtedly be poor quality and unreliable much of the time. Of course, it is possible to spend too much time worrying about code quality, but it is still a key part of building software that people want to use.
Writing is thinking
It’s one thing to have an idea or thought in your head, but actually writing down forces you to really think about and clarify your idea. The same goes for writing code. Typing a prompt and having an LLM generate code allows a developer to skip the important step of actually thinking about what they are trying to create. The problem is that LLMs fundamentally cannot think. LLMs cannot actually understand the context of an existing project or the needs of people the software is being is built for. The best-case scenario is that the LLM will output code that resembles the code that is actually needed. LLMs can produce code which might result in a functioning application, but that application is likely to be generic and poorly suited for its users’ needs.
Code needs to be human-readable
Writing code that is understandable to machines is not the only challenge when it comes to writing quality code. The code needs to be understandable to humans as well. Part of the reason that some organizations cannot replace their ancient COBOL applications is that no one can actually understand the logic behind the code that makes those systems operate. LLMs might be capable of generating code that can make software function, but if that code is not easily read by human beings, then it will be difficult to work with or understand in the future. I do realize that it is possible for humans to refactor LLM generated code to improve the overall quality, but I think this process would probably end up being less efficient than writing the code directly to begin with.
Simplicity is key
In my experience, most people want software that is simple and straightforward to use. Even before recent advancements in LLM technology for generating code, many software projects’ quality has suffered as a result of feature bloat and over-engineering. For example, many web applications have been built with unnecessarily complicated front-end setups that result in a user experience that is slow and unstable. The ability to quickly add new features and complexity with LLM technology could make this issue even worse.
Learning by doing
The only way for a developer to improve and learn new skills is to practice. For example, I recently created my first Ruby Gem, or code library. In the process, I gained a fuller understanding of how gems work as well as the internals of the Ruby on Rails framework. If I had relied on an LLM to generate the code, I would likely have not learned as much. LLMs are not capable of learning by doing.
Natural language is messy
Computer scientist Edsger W. Dijkstra wrote an essay in the late 1970s titled “On the foolishness of ‘natural language programming’”. In the essay, Dijkstra argued that a standardized means of communicating with computers would always be superior to attempts to accomplish something resembling computer programming with natural language. This proves that attempts to allow humans to program computers using plain language are not new. People have apparently been trying to create this functionality for decades.
Natural language will never truly be standardized, and for this reason, computers will never truly be able to understand it. Modern LLM technology is far from perfect when it comes to understanding natural language and these imperfections will never be fully resolved. I worry that people who try to tailor their writing style to communicate with LLMs will damage their ability to communicate with other humans in the process.
In conclusion, I think that LLMs might be fun to play with while working on hobby projects where it doesn’t matter if the requirements are unclear and the UX has no financial impact. However, they are not well-suited for professional software development. I believe that writing code directly and using code libraries will ultimately be more efficient than using LLMs in the long run.