How Engineers Are Using Large Language Models (LLMs) in Everyday Coding

Artificial Intelligence (AI) has been making waves across various industries, and the world of software engineering is no exception. But the real question is: how are engineers actually using these AI-driven tools, particularly large language models (LLMs), in their day-to-day coding tasks? The answer might surprise you, especially if you’re not deep into the coding world yourself.

In recent, detailed blog post by by Nicholas Carlini (https://nicholas.carlini.com/writing/2024/how-i-use-ai.html) as well as other engineers shared their experiences on how they're integrating LLMs into their regular workflows. These insights highlight the transformative potential of AI in coding—transforming what was once tedious and time-consuming into something much more manageable and, dare I say, enjoyable.

Here, we’ll dive into ten specific ways engineers are leveraging LLMs to simplify their coding lives. The beauty of these examples is that they don't just apply to coding wizards; they can resonate with anyone who's ever had to wrestle with code, whether you're a seasoned developer or someone just dabbling in programming.

1. Understanding APIs Without Breaking a Sweat

APIs, or Application Programming Interfaces, are the building blocks of modern software. But understanding them, especially if they’re complex or poorly documented, can be a headache. Traditionally, you’d have to dig through documentation, search forums, or experiment with the API until something clicks. LLMs change this game. Engineers now use these models to quickly grasp how an API works. Simply feed the model some context, and it can break down the API’s functionality in plain language, helping you understand it without the usual hassle.

2. Differentiating Code with Precision

One of the more mundane tasks in coding is spotting differences between versions of a codebase—what’s commonly known as “diffing.” While tools exist to help with this, LLMs take it a step further by not only identifying the changes but also explaining them. This isn’t just about highlighting what’s different; it’s about understanding why those changes matter, which can save hours of back-and-forth for developers.

3. Trimming Down Codebases

Every developer knows that code can bloat over time. As projects grow, so does the amount of redundant or unnecessary code. LLMs are being used to trim the fat from these bloated codebases. By analyzing the code, the model suggests which parts can be optimized or removed altogether, ensuring that the codebase remains lean and efficient.

4. Refactoring Code with a Smarter Approach

Refactoring is another task that can be daunting, especially when dealing with large, complex projects. It involves reorganizing and optimizing code without changing its functionality, which requires a deep understanding of both the existing code and the desired outcome. LLMs help automate this process, making it easier to refactor thousands of lines of code quickly and efficiently. This is more than just a cosmetic change; it’s about improving performance, maintainability, and readability.

5. Tackling Boring Tasks Like Documentation

Let’s face it: documentation is not a task most engineers look forward to. Yet, it’s essential for maintaining a project’s usability and longevity. LLMs are stepping in here, too, generating documentation from the code itself or providing a starting point that engineers can then refine. This not only saves time but also reduces the mental load of having to switch from coding mode to writing mode.

6. Overcoming the Blank Page Problem

Starting a new coding project or tackling a particularly tricky problem can often be paralyzing—what’s known as the “blank page” problem. LLMs can help by generating an initial draft or suggesting a structure, giving engineers something to build on. This way, they can avoid that initial struggle and dive straight into solving the problem at hand.

7. Getting Up to Speed with New Technologies

Learning a new programming language or framework usually involves a lot of Googling, reading through tutorials, and trial-and-error. LLMs streamline this process by providing concise, relevant explanations or even generating sample code to demonstrate how things work. This can be especially helpful when you’re under time pressure and need to quickly get the gist of something new.

8. Writing Throwaway Code

In the past, writing code that you might not use again could feel like a waste of time. But with LLMs, the process of generating simple scripts or experimenting with new ideas has become so quick and easy that engineers are more willing to write “throwaway” code. Whether it’s a short JavaScript snippet to solve a one-off problem or a small automation script, LLMs make it easy to code, test, and discard without the usual overhead.

9. Breaking Down Complex Problems

Large projects often require breaking down big problems into smaller, manageable tasks. This is something that product managers and engineers alike wrestle with. LLMs are being used to help with this process, especially on the technical side. By feeding a high-level problem into the model, engineers can get suggestions on how to split it into smaller tasks, which can then be tackled one by one.

10. Building Entire Apps from Scratch

This might sound like science fiction, but engineers are already using LLMs to build complete applications with minimal input. These aren’t just toy apps; they’re functional, useful pieces of software. By crafting the right prompts, developers can guide the LLM through the process of coding an app, often with just a few iterations. This rapid development process has significant implications, particularly for prototyping and testing new ideas quickly.

The Changing Nature of Software Development

One of the most interesting takeaways from these examples is how LLMs are shifting the nature of coding itself. Coding is no longer just the domain of engineers with deep expertise. With tools like these, even those with limited coding experience can create functional software, opening up new possibilities for innovation.

However, this doesn’t mean that traditional engineering skills are becoming obsolete. Far from it. The role of an engineer is still critical, particularly when it comes to designing robust, scalable systems and ensuring that code is clean and maintainable. What’s changing is the distribution of labor: LLMs handle the grunt work, allowing engineers to focus on higher-level tasks.

A recurring theme in the use of LLMs is their ability to lighten the cognitive load on engineers. By taking care of routine, repetitive tasks, these models free up mental space for more creative and strategic thinking. This is not just about saving time; it’s about improving the quality of work by allowing engineers to focus on what really matters.

It’s easy to get caught up in the hype around AI and forget that, at its core, technology is about solving real problems. The examples shared here are not about futuristic scenarios—they’re practical, usable cases where LLMs are making a tangible difference in how engineers work. This should be reassuring for anyone concerned about AI’s impact on jobs. Rather than replacing engineers, LLMs are becoming valuable tools that enhance their capabilities.

As LLMs continue to evolve, their role in software development will likely expand. We can expect to see more advanced features, better integration with existing tools, and perhaps even entirely new paradigms of coding that blur the lines between human and machine collaboration.

For now, though, the key takeaway is that LLMs are here to help. Whether you’re an engineer looking to streamline your workflow or someone interested in the potential of AI in coding, these tools offer a glimpse into the future of software development—one where creativity and efficiency go hand in hand.

In Conclusion

The use of large language models in everyday coding tasks is not just a trend; it’s a shift in how we approach software development. By automating mundane tasks, providing quick insights, and enabling rapid prototyping, LLMs are becoming indispensable tools for engineers. The examples shared by engineers like Eric and Nicholas are just the tip of the iceberg. As more people explore these tools, we’ll likely see even more innovative uses emerge.

So, whether you’re a seasoned coder or someone just getting started, it’s worth paying attention to how LLMs are changing the game. The future of coding might be closer than you think, and it’s shaping up to be a lot more exciting than we ever imagined.