In my own experience using AI for engineering, it allows me to focus more on the differentiating parts of my app, and less on the stuff that, while important, is just table stakes.

For example, I use Stripe to process payments. It’s great, and obviously important, but it has a complex API (because it supports lots of ways to get paid) and what I need it for is quite cookie cutter. There’s tons of material written about how it works, and I could understand the important parts quickly, but could leave the LLM the tedious parts of the integration. Did I look it over carefully to make sure it did what it was supposed to do? Of course. Did I save a lot of time? Yes, I estimate it took about half the time compared to what I would have done in the past (I have several decades’ experience building software).

Over time I’ve gotten better at knowing what tasks I can let the LLM handle and what I cannot. I think of it as an enthusiastic intern, very fast but needing a fair bit of guidance. Still, overall I can build 10x to 20x faster most of the time. Managing all the tedium just isn’t valuable; most of it simply needs to function.

Of course, there’s a tradeoff. Because I’m not building the deeper integrations, I’m not learning those as well as if I crafter them myself. But because I’m choosing to focus on the parts of my system that are differentiating, the parts that matter most get the most attention.

I must admit I've never seen any working code or patches from any LLM/GPT. Everything I have seen has been a total waste of time -- untested and unusable and complete slop. I just went through an episode on an issue where someone tried to use ChatGPT to analyze a macos crash dump where the stack trace was clear as day already. ChatGPT spewed out tons of unhelpful verbiage and then suggested a patch that it claimed fixed the problem, but unfortunately the patch would't even apply, let alone work. Someone else tried Grok on the same dump and it had even less useful suggestions. All the while they both spewed out miles of verbiage claiming confidently how helpful their suggestions were and offering even more analysis.

I don't doubt some folks have had some successes, but I think those are more up to chance than anything else.

The way LLM/GPT systems work, even with bolted-on so-called chain-of-thought "reasoning" enhancements, is totally and entirely devoid of any actual reasoning and hard logic. I find people who "believe" in LLM/GPT systems have a totally broken mindset in how they try to use them -- they command and argue with them as if they're talking to a human -- but they're talking to nothing better than a sack of potatoes! All they can do is respond to a series of input tokens in a way that their models suggest would be most likely, and often a tiny bit of randomness is thrown in to make sure they don't output the exact same thing to the same input every time. The so-called chain-of-thought systems just play off this randomness by feeding back the same input with the previous output a dozen times or so and then choose the most common output as their final output.

They are not search engines, and they don't store verbatim copies of the material that was used to train the model. Supposedly some can use search engines and other tools (e.g. actual mathematical processing systems) to give actually accurate output, but I haven't even seen that happen, even with Gemini enabled in google search. The actual search results are still better. Apple Siri did better a decade ago!

Yeah, again they're not for everything, and like any tool you need to learn how to use it or you'll find yourself trying to use a hammer to drive a bolt. However, for the vast majority of what I do, having an LLM contribute to it helps me get it done much faster.

That said, I'm a highly-experienced engineer who's written and reviewed millions of lines of code, and I limit the things I will use the LLM for. Building a settings page? Great. Here's the model and the UI library and the standards I need it to follow, don't make any assumptions and I'll fill in whatever gaps it needs before it gets started. Then I'll review the code along the way, cleaning up mistakes and clarifying things. Finally I'll make certain the code is good and the tests pass.

Recently I had to build an API that could run on AWS, Azure, Google Cloud, and Kubernetes. I've worked with some of these to various degrees of proficiency, ranging from lots with k8s and AWS to not at all with Azure and Google Cloud. I had a common library that I had built that already did the work, but I needed that library to present an API in each environment (the way they work are significantly different). With an LLM I was able to build all four in about six hours, taking into account the different APIs they each use, different deployment schemes, etc., with documentation for sysadmins that was correctly written for each environment. Without the LLM it would have taken me a month, since I would have had to learn each environment from scratch, try to keep them all in my head, and build each piece. It's low-value work that can be easily automated.

LLMs don't "know" anything, but by design they find patterns much better than we can. And much (most?) software is a lot like other software, so there are often plenty of patterns to follow.

Again, it's not a panacea, it's a tool. But just as OSS libraries allowed us to build systems faster by leveraging the work of people who'd done it before, LLMs can generate code that can, in specific use cases, save a ton of time. And just as OSS components have vulnerabilities and weaknesses, LLM-generated code has its own problems.

It's astonishing to me how fast the tech has improved so far. In July, agentic development became a thing and it has made tremendous improvements to how you can interact with the LLM, giving it specs and requirements and it being able to tackle larger and larger tasks. It's still no where near as capable as an experienced engineer, and it makes mistakes, but it gets you 90+% of the way there out of the gate.

Unless I'm trying to write fiction, I just can't get why anyone would even bother to use any LLM/GPT. It's dead-end technology that basically only demonstrates that a deep learning model can capture the essence of human language, and the GPT part is a cheap trick to show just how complete the model is.

It means other uses of deep learning may indeed have real value, e.g. double-checking radiologists on reading CT scans. Those kinds of uses where there is an engineered adversarial relationship between the deep learning model and its tooling vs. the practitioner who who has to do the same work anyway, show real promise, but as search engines and coding tools they're way too sloppy and just waste time, either now or later when you find out they screwed up. These tools should check your work, not do it for you.

If I can explain something well enough to prompt an LLM/GPT to give me something, then I'm pretty sure I can write what I need without its help and be sure that I understand what I wrote completely (or as completely as is possible while I hold the bigger picture in my head).

Why not mentor/train a real human junior and get them to do the real grunt work and learn by doing instead of trying to explain your needs to an LLM/GPT?