[tarr11]

This has convinced many non-programmers that they can program, but the results are consistently disastrous, because it still requires genuine expertise to spot the hallucinations.

I've been programming for 30+ years and now a people manager. Claude Code has enabled me to code again and I'm several times more productive than I ever was as an IC in the 2000s and 2010s. I suspect this person hasn't really tried the most recent generation, it is quite impressive and works very well if you do know what you are doing

[stingraycharles]

If you’ve been programming for 30+ years, you definitely don’t fall under the category of “non-programmers”.

You have decades upon decades of experience on how to approach software development and solve problems. You know the right questions to ask.

The actual non-programmers I see on Reddit are having discussions about topics such as “I don’t believe that technical debt is a real thing” and “how can I go back in time if Claude Code destroyed my code”.

[buildbot]

People learning to code always have had those questions and issues though. For example, “git ate my code’ or “I don’t believe in python using white space as a bracket so I’m going to end all my blocks with #endif”

[stingraycharles]

Yes, I’m not saying this is new, I’m giving examples of what struggles non-programmers have.

[agubelu]

Isn't that what the author means?

"it still requires genuine expertise to spot the hallucinations"

"works very well if you do know what you are doing"

[pzo]

The author headline starts with "LLMs are a failure", hard to take author seriously with such a hyperbole even if second part of headline ("A new AI winter is coming") might be right.

[hombre_fatal]

But it can work well even if you don't know what you are doing (or don't look at the impl).

For example, build a TUI or GUI with Claude Code while only giving it feedback on the UX/QA side. I've done it many times despite 20 years of software experience. -- Some stuff just doesn't justify me spending my time credentializing in the impl.

Hallucinations that lead to code that doesn't work just get fixed. Most code I write isn't like "now write an accurate technical essay about hamsters" where hallucinations can sneak through lest I scrutinize it; rather the code would just fail to work and trigger the LLM's feedback loop to fix it when it tries to run/lint/compile/typecheck it.

But the idea that you can only build with LLMs if you have a software engineer copilot isn't true and inches further away from true every month, so it kinda sounds like a convenient lie we tell ourselves as engineers (and understandably so: it's scary).

[int_19h]

> Hallucinations that lead to code that doesn't work just get fixed

How about hallucinations that lead to code that doesn't work outside of the specific conditions that happen to be true in your dev environment? Or, even more subtly, hallucinations that lead to code which works but has critical security vulnerabilities?

[hombre_fatal]

Replace "hallucination" with "oversight" or "ignorance" and you have the same issue when a human writes the code.

A lot of that will come to the prompter's own foresight much like the vigilance of a beginner developer where they know they are working on a part of the system that is particularly sensitive to get right.

That said, only a subset of software needs an authentication solution or has zero tolerance to some codepath having a bug. Those don't apply to almost all of the apps/TUIs/GUIs I've built over the last few months.

If you have to restrict the domain to those cases for LLMs to be "disastrous", then I'll grant that for this convo.

What about everything else?

[lelanthran]

> A lot of that will come to the prompter's own foresight

And, on the current trend, how on earth are prompters supposed to develop this foresight, this expertise, this knowledge?

Sure, fine, we have them now, in the form of experienced devs, but these people will eventually be lost via attrition, last even faster if companies actually do make good on their threat to replace a team of 10 devs with a team of three prompters (former senior devs).

The short-sightedness of this, the ironic lack of foresight, is troubling. You're talking about shutting off the pipeline that will produce these future prompters.

The only way through, I think, will be if (very big if) the LLMs get so much better at coding (not code-gen) that you won't need a skilled prompter.

Good luck with that.

[hombre_fatal]

> how on earth are prompters supposed to develop this foresight, this expertise, this knowledge?

I suppose curiosity. The same way anyone develops expertise in the abstractions below after getting excited about the higher layer.

[fzeroracer]

Have you checked your package imports lately?

[seaucre]

I have a journalist friend with 0 coding experience who has used ChatGPT to help them build tools to scrape data for their work. They run the code, report the errors, repeat, until something usable results. An agent would do an even better job. Current LLMs are pretty good at spotting their own hallucinations if they're given the ability to execute code.

The author seems to have a bias. The truth is that we _do not know_ what is going to happen. It's still too early to judge the economic impact of current technology - companies need time to understand how to use this technology. And, research is still making progress. Scaling of the current paradigms (e.g. reasoning RL) could make the technology more useful/reliable. The enormous amount of investment could yield further breakthroughs. Or.. not! Given the uncertainty, one should be both appropriately invested and diversified.

[chomp]

For toy and low effort coding it works fantastic. I can smash out changes and PRs fantastically quick, and they’re mostly correct. However, certain problem domains and tough problems cause it to spin its wheels worse than a junior programmer. Especially if some of the back and forth troubleshooting goes longer than one context compaction. Then it can forget the context of what it’s tried in the past, and goes back to square one (it may know that it tried something, but it won’t know the exact details).

[asah]

That was true six months ago - the latest versions are much better at memory and adherence, and my senior engineer friends are adopting LLMs quickly for all sorts of advanced development.

[lm28469]

Last week I gave antigravity a try, with the latest models and all, it generated subpar code that did the job very quickly for sure, but no one would have ever accepted this code in a PR, it took me 10x more time to clean it up than to have gemini shit it out.

The only thing I learned is that 90% of devs are code monkeys with very low expectations which basically amount to "it compiles and seems to work then it's good enough for me"

[weare138]

..and works very well if you do know what you are doing

That's the issue. AI coding agents are only as good as the dev behind the prompt. It works for you because you have an actual background in software engineering of which coding is just one part of the process. AI coding agents can't save the inexperienced from themselves. It just helps amateurs shoot themselves in the foot faster while convincing them they're a marksman.

[Lionga]

It seems to work well if you DONT really know what you are doing. Because you can not spot the issues.

If you know what you are doing it works kind of mid. You see how anything more then a prototype will create lots of issues in the long run.

Dunning-Kruger effect in action.