My Two Cents on Coding and LLMs

Large Language Models (LLMs) have rapidly taken the spotlight in the tech community. They can seem magical when you first encounter them.

I think of them as powerful code editors with autocomplete on steroids..

They're fast, adaptable, and incredibly knowledgeable. Need help recalling a rarely used method? Struggling with boilerplate code or syntax? Chances are, an LLM can assist you almost instantly.

However, beneath this impressive capability lies an important reality.

Without solid expertise in your chosen programming language (especially a nuanced one like Ruby), an LLM is merely guessing.

This isn't to say it guesses poorly, but there's a stark difference between functioning code and elegant, maintainable, idiomatic code.

To illustrate, imagine handing someone exquisite painting tools such as a sable-bristle brush, a precision Mahl stick, and an elegant glass palette.

Without a foundational understanding of artistic concepts like composition, color theory, or lighting, these professional tools won't produce a masterpiece. Instead, the outcome will be uninspired at best.

Coding, particularly in the Ruby on Rails ecosystem, mirrors this scenario closely. Ruby is nuanced and idiomatic, steeped in carefully honed community standards. Rails, in turn, has well-established conventions, methodologies, and best practices drawn directly from real-world usage.

An LLM might produce functional Rails code snippets, but without deep insight into why certain patterns and idioms exist, the resulting code is often shaky or insecure. This fuels arguments among developers:

• Pro-LLM enthusiasts argue passionately that these models herald the end of traditional coding roles, automating away human error and inefficiency.

• Traditional coders counter just as strongly that LLM-generated code lacks the depth and foresight required to build secure, stable applications. They worry that "AI-assisted coders" produce tools that are superficially functional yet fundamentally fragile.

Here's my perspective:

As is often the case, the truth lies somewhere in the middle.

When you combine your deep, human understanding of Ruby's idioms, design patterns, and Rails conventions with the speed and breadth of an LLM, something truly powerful emerges. The result isn't just functional code; it's elegant, maintainable, secure, and performant.

In short, LLMs become powerful assistants, enhancing-not replacing-the developer’s craft.

And that’s when things genuinely get interesting.

Just my two cents. 🙏

If you're on this path and Ruby is part of your journey, it'd be my honour to share what I’ve learned over the years: 👉 https://www.rubycademy.com

Voilà!