The Impact of Large Language Models on Software Engineering: A Developer’s Perspective

In recent months, I’ve spent considerable time experimenting with Large Language Models (LLMs) like OpenAI’s ChatGPT and Claude’s Sonnet 3.5. I’ve been genuinely impressed by their ability to generate responses on virtually any topic. This rapid advancement in AI has sparked a lot of conversations about whether these models might replace software developers or reduce the demand for software engineering jobs over time. In this post, I’d like to share my thoughts on how these models are currently used to write software and what the future might hold for software engineers.

LLMs and Enhanced Learning Efficiency#

One of the most significant benefits I’ve experienced from using these models is the efficiency they bring to learning new concepts. In the past, learning about a new topic often meant scouring Google, hopping from one link to another, and wading through a sea of information to find exactly what I needed. Now, with tools like ChatGPT, the process is far more streamlined. Instead of sifting through multiple sources, I can simply ask a question and receive a well-structured, informative answer in seconds.

For example, I recently needed information on kubernetes controller concurrent reconcile. My initial search on Google led me down the rabbit hole of Stack Overflow threads, which ultimately left me more confused than informed. Turning to ChatGPT, I received a much more focused and relevant explanation. While it didn’t give me a solution, it provided enough pointers with a bit of trial and error.

Real-World Applications: A Boost in Productivity#

The productivity gains from using LLMs are not limited to learning—they extend to coding as well. Recently, I faced an issue while copying files from a corrupted USB drive. rsync was throwing I/O errors, so I turned to ChatGPT for help. The model suggested using ddrescue and even generated a script to get me started. After a quick sanity check to ensure there were no harmful commands (like rm -rf), I ran the script. And it didn’t work out of the box, but it provided a starting script that I could easily modify for my needs.

This is where LLMs truly shine: they don’t just save time; they reduce the friction that often leads to procrastination. By generating the initial boilerplate code, LLMs allow me to focus on the more interesting aspects of coding, like refining logic and handling edge cases. The result is a significant increase in the number of tools and projects I’m able to develop.

One afternoon, I decided to create a tool called treebuilder, which builds a directory and file structure from a text-based file layout of a project. Such directory structure is usually emitted by the GPT tools, when asked give file structure of the project. I asked ChatGPT for creating a go lang script to read the file and create directory structure, and it generated a syntactically correct go lang script that looked promising at first glance. But again, the initial version had its flaws—there were bugs and missing logic for navigating the directory structure—but it gave me a great starting point. After making implementing the core logic and handling edge cases, I had a functional tool that saved me considerable time.

The Future of Software Engineering in the Age of LLMs#

So, what does the future hold for software engineers as LLMs become more prevalent? I believe we’re currently in a period of rapid development for these models, but I foresee a point where the pace of innovation will slow as we approach the “global maxima” of their capabilities. Similar to how the evolution of smartphones like the iPhone has plateaued, future advancements in LLMs may become more incremental.

That said, there will be continued innovation in the tooling and integration around these models. We can expect to see complete environments where code can be generated and run instantly, deeper integration with IDEs, auto-generation of code comments and documentation, and more robust testing frameworks and code review integration. Software engineers will need to master these tools to remain competitive, as industry expectations will evolve to demand this level of efficiency.

However, I don’t believe the rise of LLMs will lead to fewer jobs for software engineers. While these models excel at generating generic boilerplate code, they still struggle with accurately translating complex business requirements into functional code. Engineers often work with cross-functional teams to understand these requirements, and that nuanced understanding is something LLMs currently lack.

Additionally, LLMs are not yet capable of tackling the intricate challenges involved in building complex systems, such as managing concurrency, avoiding deadlocks, or designing distributed systems. Bugs generated in such systems are hard to reason about even for Human Intelligence (HI). These are areas where human ingenuity and experience remain irreplaceable. With the new found efficiency with such power tools, more innovative applications will come to market which will need to scale at an un-precedent level thus increasing demand for more competent software engineers.

Conclusion: A New Era of Innovation#

In conclusion, LLMs are powerful tools that have the potential to significantly enhance productivity and innovation in software engineering. By automating the more mundane aspects of coding, they free up developers to focus on solving complex problems and bringing new ideas to life. As these tools evolve, the role of the software engineer will also evolve, becoming more centered on leveraging AI to deliver faster, more efficient solutions.

Far from making software engineers obsolete, I believe LLMs will drive demand for engineers who can use these tools effectively to navigate a rapidly changing technological landscape. The future of software engineering is bright, and those who adapt will find themselves at the forefront of this exciting new era.