Except... it does produce solid code in many scenarios. A lot of the time we are just applying the same patterns and tools to a specific problem. If you understand the problem, agents can and are producing quality code.

I do a lot with orchestrating cloud infra, provisioning and deprovisioning workflows, lifecycle management, updating CMDBs, access management, deployment automation, auditing configurations, and some APIs in front. The code is boring, mostly glue. The agents nail it quite consistently, especially with some guidance.

I do know what I want out of it, and that is deterministic quality code to solve specific business problems, so that we don't have people (or their agents) running amok.

Right up until you cut that fiber cable or gas line.

[dead]

Sought

They need to improve their spec on writing responses on Hacker News. Or maybe typos are an improvement by design to look human / increase engagement.

Not suggesting anything, but I'm wondering where the culture of having obvious misspellings without editing them out became the norm on HN. It's become the new em dash warning flag for me on forums.

> All the AI companies are retaining the messages we're sending to their agents to train the next models. I wouldn't be surprised if the agents will be able to do what I'm doing in a year or two.

Some things are very easy to solve via code (see https://xkcd.com/1425/), and others are extremely difficult.

For LLM based AI, it can be trained to write functionally correct code easily - there's tons of pre-existing code and documentation that can let AI learn patterns (LAMP stack, messaging queue, etc) and syntax.

Judgement is much more difficult. For some things "Should I go with a message queue for this problem?", there's a known set of solutions as to what works best in a specific situation, sure, LLMs can answer that easily.

But when it comes to turning human goals into code that does the job correctly and is maintainable and stable?

That's a heck of a lot different. Without human guidance and having tons of context gained by years of experience dealing with the very nuanced and situational judgement calls needed, LLMs are going to fail at doing a decent job.

LLMs (and junior people) don't know what they don't know. I think it will be really difficult to get a LLM to work well at a senior / staff level where it's more about coordination, working with human beings, handling situations based on legacy code, knowing what will and won't be fragile, etc.

People were saying the exact same thing exactly a year ago. “Last years models were no good, but this year we can do anything; so what about next years models?” the people said in July of 2025.

Well... Now we have next years models, and people are still saying: “Last years models were no good, but this year we can do anything; so what about next years models?” And I am pretty sure in July 2027 (if this whole thing hasn’t collapsed in on it self by that point [very likely]) you all will be saying: “Last years models were no good, but this year we can do anything; so what about next years models?”

For anything that isnt generic I find the effectiveness drops off very quickly.

It's already 100x better at writing todo apps than the average senior developer but when I get it to try and achieve something unusual using a relatively obscure library it flails.

> UPDATE: I'm getting a lot of replies to this thread and while I'm not trying to be argumentative here, I have to ask if a lot of them aren't rooted in denial...

I do think there is a very common denialism that is rampant causing many people to believe on what is essentially faith that AI is going to get just good enough to be a perfect assistant to them, but then magically halt on progress right before it entirely replaces them.

And to be clear I believe LLMs are likely to plateau before they replace literally everyone working in software development, but I also think that a lot more than n% of developers believe they will be part of the n% who will survive unscathed, where n ends up being quite a small number.

> Now it's at the level of a competent junior, who can almost do the whole task from start to finish but needs a little supervision.

Define tasks!

The most important aspects is that they’ve always been good at applying patterns, but have no discernment into why and the specific adjustments that needs to be done for a particular contexts. It’s rare that I can’t find discrepancy at the edges if several patterns have been used.

We already have good tools for patterns. It’s called code reusability. So frameworks, libraries, code generators, paradigms, snippets, and the mighty copy and paste (there’s a reason vim has like 26 registers).

Software development is all about managing complexity, which LLM are notoriously bad at. A little supervision won’t cut it.

I find myself just jumping up the abstraction ladder, aiming for more and more ambitious projects. It's like electric mountain bikes; at first there was a lot of objection across the purists (and there still is), but eventually people understood you put in the same effort just go longer and faster. I work the same hours and strain my thought just as much but my output is significantly more ambitious. Left to their own devices even SOTA models like Fable would produce a complete mess over time, fine locally but awful globally. Admittedly, I don't know if it's the nature of the beast or if I'm just not thorough enough with my prompting and let the LLM guess what I want to end up with; but clearly some directional expertise is required.

Understanding the fundamentals of anything will always be a valuable skill, and that only comes from hard work and experience. And much of the experience lies in tacit knowledge, not easily added as AI training data.

That, combined with knowing what to build, and more importantly what NOT to build, I don’t think AI ever will take away from us.

But I feel like over the last ~10 years there's been a trend back towards learning more about them (e.g., with Rust and new C# features, or with C++ Win32 programming becoming a cool hipster thing somehow)? Or maybe that's just my own personal bubble.

I do a lot of embedded C++ work and byte stream work where packing matters, but I agree with you. For most development it’s irrelevant, and in the future I expect it to be even less relevant.

This is a perpetual pet peeve of mine with LLMs. They will always opt to ensure "backwards compatibility" with a codebase built 30 seconds ago.

I always have to explicitly state, "we are making a clean break to v1.0, do not implement any compatibility layers".