News for hackers. Stuff that matters.
Re:Hallucinations in code are the least dangerous form of LL... by notepad0x90 on Sunday March 02, 2025 @06:24PM (#43236385)
My fear is that LLM generated code will look great to me, I won't understand it fully but it will work. But since I didn't author it, I wouldn't be great at finding bugs in it or logical flaws. Especially if you consider coding as piecing together things instead of implementing a well designed plan. Lots of pieces making up the whole picture but a lot of those pieces are now put there by an algorithm making educated guesses.

Perhaps I'm just not that great of a coder, but I do have lots of code where if someone took a look it, it might look crazy but it really is the best solution I could find. I'm concerned LLMs won't do that, they won't take risks a human would or understand the implications of a block of code beyond its application in that specific context.

Other times, I feel like I'm pretty good at figuring out things and struggling in a time-efficient manner before arriving at a solution. LLM generated code is neat but I still have to spend similar amounts of time, except now I'm doing more QA and clean up work instead of debugging and figuring out new solutions, which isn't fun at all.

Re:Hallucinations in code are the least dangerous form of LL... by noisy_boy on Sunday March 02, 2025 @07:44PM (#43237043)
I do these things for this:

- keep the outline in my head: I don't give up the architect's seat. I decide which module does what and how it fits in the whole system, it's contract with other modules etc.

- review the code: this can be construed as negating the point of LLMs as this is time consuming but I think it is important to go through line by line and understand every line. You will absorb some of the LLM generated code in the process which will form an imperfect map in your head. That's essential for beginning troubleshooting next time things go wrong.

- last mile connectivity: several times the LLM takes you there but can't complete the last mile connectivity; instead of wasting time chasing it, do the final wiring yourself. This is a great shortcut to achieve the previous point.

Re:Hallucinations in code are the least dangerous form of LL... by zahlman on Monday March 03, 2025 @12:56AM (#43238729)
The way you've written this comes across like the AI is influencing your writing style....
Re:Hallucinations in code are the least dangerous form of LL... by plxxyzs on Monday March 03, 2025 @12:58AM (#43238745)
Three bullet points, each with three sentences (ok last one has a semicolon instead) is a dead giveaway
Re:Hallucinations in code are the least dangerous form of LL... by Jensson on Monday March 03, 2025 @01:47AM (#43238992)
Lots of people wrote like that before AI, AI writes like people its made to copy how people write. It wouldn't write like that if people didn't.
Re:Hallucinations in code are the least dangerous form of LL... by johnisgood on Monday March 03, 2025 @05:12AM (#43240250)
Yes, I prefer using lists myself, too, does not mean my writing is being influenced by AI. I have always liked bullet points long before AI was even a thing, it is for better organization and visual clarity.
Re:Hallucinations in code are the least dangerous form of LL... by KronisLV on Monday March 03, 2025 @07:14AM (#43241015)
I feel like “looks like it’s written by AI” might become a critique of writing that’s very template-like, neutral, corporate. I don’t usually dislike it though, as long as the information is there.
Re:Hallucinations in code are the least dangerous form of LL... by noisy_boy on Monday March 03, 2025 @07:14AM (#43241016)
Three bullet points AND three sentences?!! Get outta here...
Re:Hallucinations in code are the least dangerous form of LL... by noisy_boy on Monday March 03, 2025 @06:39AM (#43240778)
thatistrue I us ed to write lik this b4 ai it has change my life
Re:Hallucinations in code are the least dangerous form of LL... by matthberg on Monday March 03, 2025 @09:36AM (#43242127)
As someone pretty firmly in the anti-AI camp, I'm genuinely glad that you've personally found AI a useful tool to polish text and help you communicate.

I think that just because someone might be more or less eloquent than someone else, the value of their thoughts and contributions shouldn't be weighed any differently. In a way, AI formatting and grammar assistance could be a step towards a more equitable future, one where ideas are judged on inherent merits rather than superficial junk like spel;ng or idk typos n shi.t

However, I think what the parent commenter (and I) might be saying is that it seems you're relying on AI for more than just help expressing yourself—it seems you're relying on it to do the thinking too. I'd urge you to consider if that's what you really want from a tool you use. That said, I'm just some random preachy-judgy stranger on the internet, you don't owe me shit, lol

(Side notes I couldn't help but include: I think talking about AI and language is way more complicated (and fascinating) than just that aspect, including things I'm absolutely unqualified to comment on—discrimination against AAVE use, classism, and racism can't and shouldn't be addressed by a magic-wand spell-checker that "fixes" everyone's speech to be "correct" (as if a sole cultural hegemony or way of speech is somehow better than any other))

Re:Hallucinations in code are the least dangerous form of LL... by noisy_boy on Monday March 03, 2025 @09:52AM (#43242277)
> As someone pretty firmly in the anti-AI camp, I'm genuinely glad that you've personally found AI a useful tool to polish text and help you communicate.

> I think that just because someone might be more or less eloquent than someone else, the value of their thoughts and contributions shouldn't be weighed any differently. In a way, AI formatting and grammar assistance could be a step towards a more equitable future, one where ideas are judged on inherent merits rather than superficial junk like spel;ng or idk typos n shi.t

I guess I must come clean that my reply was sarcasm which obviously fell flat and caused you to come to the defense of those who can't spell - I swear I don't have anything against them.

> However, I think what the parent commenter (and I) might be saying is that it seems you're relying on AI for more than just help expressing yourself—it seems you're relying on it to do the thinking too. I'd urge you to consider if that's what you really want from a tool you use. That said, I'm just some random preachy-judgy stranger on the internet, you don't owe me shit, lol

You and presumably the parent commenter have missed the main point of the retort - you are assuming I am relying on AI for my content or its style. It is neither - I like writing point-wise in a systematic manner, always have, always will - AI or no-AI be damned. It is the all-knowing veil-piercing eagle-eyed deduction of random preachy-judgy strangers on the internet about something being AI-generated/aided just because it follows structure, that is annoying.

Re:Hallucinations in code are the least dangerous form of LL... by danielmarkbruce on Monday March 03, 2025 @10:31AM (#43242693)
It's funny that some folks seem to assume AI writing style just arrive out of thin air....
Re:Hallucinations in code are the least dangerous form of LL... by noisy_boy on Wednesday March 05, 2025 @08:01AM (#43265898)
Maybe LLM generated text was their first-contact with structured and systematic writing.
Re:Hallucinations in code are the least dangerous form of LL... by happymellon on Monday March 03, 2025 @01:25AM (#43238883)
> This is a great shortcut to achieve the previous point.

How does doing the hard part provide a shortcut for reviewing all the LLVM code?

If anything it's a long cut, because now you have to understand the code and write it yourself. This isn't great, it's terrible.

Re:Hallucinations in code are the least dangerous form of LL... by noisy_boy on Monday March 03, 2025 @06:43AM (#43240806)
Sure whatever works for you; my approach works for me
Re:Hallucinations in code are the least dangerous form of LL... by happymellon on Monday March 03, 2025 @07:12AM (#43241002)
But you don't explain how doing the hard part shortcuts needing to understand the LLVM code.
Re:Hallucinations in code are the least dangerous form of LL... by FiberBundle on Monday March 03, 2025 @05:53AM (#43240520)
In my experience you just don't keep as good a map of the codebase in your head when you have LLMs write a large part of your codebase as when you write everything yourself. Having a really good map of the codebase in your head is what brings you large productivity boosts when maintaining the code. So while LLMs do give me a 20-30% productivity boost for the initial implementation, they bring huge disadvantages after that, and that's why I still mostly write code myself and use LLMs only as a stackoverflow alternative.
Re:Hallucinations in code are the least dangerous form of LL... by MrMcCall on Monday March 03, 2025 @08:28AM (#43241511)
The evolution of a codebase is an essential missing piece of our development processes. Barring detailed design docs that no one has time to write and then update, understanding that evolution is the key to understanding the design intent (the "why") of the codebase. Without that why, there will be no consistency, and less chance of success.

"Short cuts make long delays." --Tolkien

Re:Hallucinations in code are the least dangerous form of LL... by simonw on Monday March 03, 2025 @10:44AM (#43242824)
I have enough projects that I'm responsible for now (over 200 packages on PyPI, over 800 GitHub repositories) that I gave up on keeping a map of my codebases in my head a long time ago - occasionally I'll stumble across projects I released that I don't even remember existing!

My solution for this is documentation, automated tests and sticking to the same conventions and libraries (like using Click for command line argument parsing) across as many projects as possible. It's essential that I can revisit a project and ramp up my mental model of how it works as quickly as possible.

I talked a bit more about this approach here: https://simonwillison.net/2022/Nov/26/productivity/

Re:Hallucinations in code are the least dangerous form of LL... by FiberBundle on Monday March 03, 2025 @03:56PM (#43246595)
You're an extreme outlier. Most programmers work with 1-3 codebases probably. Obviously you can't keep 800 codebases in your head, and you have to settle for your approach out of necessity. I find it hard to believe you get anywhere close to the productivity benefits of having a good mental map of a codebase with just good documentation and extensive test coverage. I don't have any data on this, but from experience I'd say that people who really know a codebase can be 10-50x as fast at fixing bugs than those with only a mediocre familiarity.
Re:Hallucinations in code are the least dangerous form of LL... by tokioyoyo on Sunday March 02, 2025 @07:51PM (#43237101)
The big argument against it is, at some point, there’s a chance, that you won’t really need to understand what the code does. LLMs writes code, LLMs write tests, you find bugs, LLM fixes code, LLM adds test cases for the found bug. Rinse and repeat.
Re:Hallucinations in code are the least dangerous form of LL... by SamPatt on Sunday March 02, 2025 @08:28PM (#43237342)
For fairly simple projects built from scratch, we're already there.

Claude Code has been doing all of this for me on my latest project. It's remarkable.

It seems inevitable it'll get there for larger and more complex code bases, but who knows how far away that is.

Re:Hallucinations in code are the least dangerous form of LL... by saagarjha on Monday March 03, 2025 @05:06AM (#43240215)
What do you do when the LLM doesn't fix the code?
Re:Hallucinations in code are the least dangerous form of LL... by amarcheschi on Monday March 03, 2025 @07:46AM (#43241221)
You tell it there's an error, and to fix the code (/s)
Re:Hallucinations in code are the least dangerous form of LL... by fuzztester on Sunday March 02, 2025 @08:00PM (#43237162)
>My fear is that LLM generated code will look great to me, I won't understand it fully but it will work.

puzzled. if you don't understand it fully, how can you say that it will look great to you, and that it will work?

Re:Hallucinations in code are the least dangerous form of LL... by Nevermark on Sunday March 02, 2025 @08:32PM (#43237362)
> if you don't understand it fully, how can you say that it will look great to you, and that it will work?

Presumably, that simply reflects that a primary developer always has an advantage of having a more reliable understanding of a large code base - and the insights into the problem that come about during development challenges - than a reviewer of such code.

A lot of important bug subtle insights, many sub-verbal, into a problem come from going through the large and small challenges of creating something that solves it. Reviewers just don't get those insights as reliably.

Reviewers can't see all the subtle or non-obvious alternate paths or choices. They are less likely to independently identify subtle traps.

Re:Hallucinations in code are the least dangerous form of LL... by raincole on Monday March 03, 2025 @01:04AM (#43238789)
It happens all the time. Way before LLM. There were countless times I implemented an algorithm from a paper or a book while not fully understanding it (in other words, I can't prove the correctness or time complexity without referencing the original paper).
Re:Hallucinations in code are the least dangerous form of LL... by fuzztester on Monday March 03, 2025 @02:30PM (#43245703)
imo, your last phrase, excerpted below:

>(in other words, I can't prove the correctness ... without referencing the original paper).

agrees with what I said in my previous comment:

>if you don't understand it fully, how can you say .... that it will work?

(irrelevant parts from our original comments above, replaced with ... , without loss of meaning to my argument.)

both those quoted fragments, yours and mine, mean basically the same thing, i.e. that both you and the GP don't know whether it will work.

it's not that one cannot use some piece of code without knowing whether it works; everybody does that all the time, from algorithm books for example, as you said.

Re:Hallucinations in code are the least dangerous form of LL... by rsynnott on Monday March 03, 2025 @08:03AM (#43241331)
I mean, depends what you mean by ‘work’. For instance, something which produces the correct output, and leaks memory, is that working? Something which produces the correct output, but takes a thousand times longer than it should; is that working? Something which produces output which looks superficially correct and passes basic tests, is that working?

‘Works for me’ isn’t actually _that_ useful a signal without serious qualification.

Re:Hallucinations in code are the least dangerous form of LL... by fuzztester on Monday March 03, 2025 @04:29PM (#43247005)
exactly.

what you said just strengthens my argument.

Re:Hallucinations in code are the least dangerous form of LL... by fuzztester on Wednesday March 05, 2025 @08:51PM (#43275331)
>‘Works for me’ isn’t actually _that_ useful a signal without serious qualification.

yes, and it sounds a bit like "works on my machine", a common cop-out which I am sure many of us have heard of.

google: works on my machine meme

Re:Hallucinations in code are the least dangerous form of LL... by upcoming-sesame on Monday March 03, 2025 @05:52PM (#43247810)
You write a decent amount of tests
Re:Hallucinations in code are the least dangerous form of LL... by fuzztester on Monday March 03, 2025 @08:08PM (#43248938)
Famous quote, read many years ago:

testing can prove the presence of errors, but not their absence.

https://www.google.com/search?q=quote+testing+can+prove+the+...

- said by Steve McConnell (author of Code Complete), Edsger Dijkstra, etc. ...

Re:Hallucinations in code are the least dangerous form of LL... by unclebucknasty on Sunday March 02, 2025 @07:21PM (#43236847)
All of this. Could have saved me a comment [0] if I'd seen this earlier.

When people talk about 30% or 50% coding productivity gains with LLMs, I really want to know exactly what they're measuring.

[0] https://news.ycombinator.com/item?id=43236792

Re:Hallucinations in code are the least dangerous form of LL... by hakaneskici on Sunday March 02, 2025 @08:36PM (#43237387)
When it comes to relying on code that you didn't write yourself, like an npm package, do you care if it's AI code or human code? Do you think your trust toward AI code may change over time?
Re:Hallucinations in code are the least dangerous form of LL... by sfink on Sunday March 02, 2025 @09:36PM (#43237702)
Of course I care. Human-written code was written for a purpose, with a set of constraints in mind, and other related code will have been written for the same or a complementary purpose and set of constraints. There is intention in the code. It is predictable in a certain way, and divergences from the expected are either because I don't fully understand something about the context or requirements, or because there's a damn good reason. It is worthwhile to dig further until I do understand, since it will very probably have repercussions elsewhere and elsewhen.

For AI code, that's a waste of time. The generated code will be based on an arbitrary patchwork of purposes and constraints, glued together well enough to function. I'm not saying it lacks purpose or constraints, it's just that those are inherited from random sources. The parts flow together with robotic but not human concern for consistency. It may incorporate brilliant solutions, but trying to infer intent or style or design philosophy is about as useful as doing handwriting analysis on a ransom note made from pasted-together newspaper clippings.

Both sorts of code have value. AI code may be well-commented. It may use features effectively that a human might have missed. Just don't try to anthropomorphize an AI coder or a lawnmower, you'll end up inventing an intent that doesn't exist.

Re:Hallucinations in code are the least dangerous form of LL... by gunian on Sunday March 02, 2025 @11:46PM (#43238390)
what if you

- generate - lint - format - fuzz - test - update

infintely?

Re:Hallucinations in code are the least dangerous form of LL... by sfink on Monday March 03, 2025 @12:01AM (#43238455)
Then you'll get code that passes the tests you generate, where "tests" includes whatever you feed the fuzzer to detect problems. (Just crashes? Timeouts? Comparison with a gold standard?)

Sorry, I'm failing to see your point.

Are you implying that the above is good enough, for a useful definition of good enough? I'm not disagreeing, and in fact that was my starting assumption in the message you're replying to.

Crap code can pass tests. Slow code can pass tests. Weird code can pass tests. Sometimes it's fine for code to be crap, slow, and/or weird. If that's your situation, then go ahead and use the code.

To expand on why someone might not want such code, think of your overall codebase as having a time budget, a complexity budget, a debuggability budget, an incoherence budget, and a maintenance budget. Yes, those overlap a bunch. A pile of AI-written code has a higher chance of exceeding some of those budgets than a human-written codebase would. Yes, there will be counterexamples. But humans will at least attempt to optimize for such things. AIs mostly won't. The AI-and-AI-using-human system will optimize for making it through your lint-fuzz-test cycle successfully and little else.

Different constraints, different outputs. Only you can decide whether the difference matters to you.

Re:Hallucinations in code are the least dangerous form of LL... by pixelfarmer on Monday March 03, 2025 @02:18AM (#43239125)
> Then you'll get code that passes the tests you generate

Just recently I think here on HN there was a discussion about how neural networks optimize towards the goal they are given, which in this case means exactly what you wrote, including that the code will do stuff in wrong ways just to pass the given tests.

Where do the tests come from? Initially from a specification of what "that thing" is supposed to do and also not supposed to do. Everyone who had to deal with specifications in a serious way knows how insanely difficult it is to get these right, because there are often things unsaid, there are corner cases not covered and so on. So the problem of correctness is just shifted, and the assumption that this may require less time than actually coding ... I wouldn't bet on it.

Conceptually the idea should work, though.

Re:Hallucinations in code are the least dangerous form of LL... by gunian on Tuesday March 04, 2025 @01:57AM (#43251223)
what if you thought of your codebase as something similar to human DNA and the LLM as nature and the entire process as some sort of evolutionary process? the fitness function would be no panics exceptions and latency instead of some random KPI or OKR pr who likes working with who or who made who laugh

it's what our lord and savior jesus christ uses for us humans if it is good for him its good enough for me. and surely google is not laying off 25k people because it believes humans are better than their LLMs :)

Re:Hallucinations in code are the least dangerous form of LL... by intended on Monday March 03, 2025 @01:03AM (#43238776)
Who has that much time and money when your boss is breathing down your neck?
Re:Hallucinations in code are the least dangerous form of LL... by whymeogod on Monday March 03, 2025 @04:10PM (#43246765)
> is about as useful as doing handwriting analysis on a ransom note made from pasted-together newspaper clippings.... >...Both sorts of code have value.

<snark> Yes, ransom notes have value </snark>

Re:Hallucinations in code are the least dangerous form of LL... by PessimalDecimal on Sunday March 02, 2025 @09:18PM (#43237605)
Publicly available code with lots of prior usage seems less likely to be buggy than LLM-generated code produced on-demand and for use only by me.
Re:Hallucinations in code are the least dangerous form of LL... by sunami-ai on Sunday March 02, 2025 @09:54PM (#43237808)
Worst part is that the patterns of implementation won't be consistent across the pieces. So debug a whole codebase that was authored with LLM generated code is like having to debug a codebase where ever function was written by a different developer and no one followed any standards. I guess you can specify the coding standards in the prompt and ask it to use FP-style programming only, but I'm not sure how well it can follow.
Re:Hallucinations in code are the least dangerous form of LL... by QuiDortDine on Sunday March 02, 2025 @11:22PM (#43238272)
Not well, at least for ChatGPT. It can't follow my custom instructions which can be summed up as "follow PEP-8 and don't leave trailing whitespace".
Re:Hallucinations in code are the least dangerous form of LL... by jampekka on Monday March 03, 2025 @04:32AM (#43239996)
In don't think they meant formatting details.
Re:Hallucinations in code are the least dangerous form of LL... by johnisgood on Monday March 03, 2025 @05:13AM (#43240256)
It is supposed to follow that instruction though. When it generates code, I can tell is to use tabs, 2 spaces, etc. and the generated code will use that. It works well with Claude, at least.
Re:Hallucinations in code are the least dangerous form of LL... by 6r17 on Monday March 03, 2025 @08:20AM (#43241447)
Formatting is like a dot on the i; there is 200 other small details that are just completely off putting to me : - naming conventions (ias are lazy and tent to use generic names with no meaning) such as "Glass" instead of "GlassProduct" ; - error management convention

But the most troublesome to me is that it is just "pissing" out code and has no after-tough about the problem it is solving or the person it is talking to.

The number of times I have to repeat myself just to get a stubborn answer with no discussion is alarming. It does not benefit my well-being and is annoying to work with except for a bunch of exploratory cases.

I believe LLM are actually the biggest data heist organized. We believe that those models will get better at solving their jobs but the reality is that we are just giving away code, knowledge, ideas at scale, correcting the model for free, and paying to be allowed to do so. And when we watch the 37% minimum hallucination rate, we can more easily understand that the actual tough comes from the human using it.

I'm not comfortable having to argue with a machine and have to explain to it what I'm doing, how, and why - just to get it to spam me with things I have to correct afterwards anyway.

The worst is, all that data is the best insight on everything. How many people ask for X ? How much time did they spend trying to do X ? What were they trying to achieve ? Who are their customers ? etc...

Re:Hallucinations in code are the least dangerous form of LL... by kadushka on Sunday March 02, 2025 @10:18PM (#43237956)
I wouldn't be great at finding bugs in it or logical flaws

This is what tests are for.

Re:Hallucinations in code are the least dangerous form of LL... by notepad0x90 on Monday March 03, 2025 @12:38AM (#43238611)
The tests are probably LLM generated as well lol
Re:Hallucinations in code are the least dangerous form of LL... by nradov on Monday March 03, 2025 @12:49AM (#43238682)
You can't test quality into a product.
Re:Hallucinations in code are the least dangerous form of LL... by ajmurmann on Monday March 03, 2025 @12:55AM (#43238722)
To fight this I mostly do ping-pong pairing with llms. After e discuss the general goal and approach I usually write the first test. The llm the makes it pass and writes the next test which I'll make pass and so on. It forces me to stay 100% in the loop and understand everything. Maybe it's not as fast as having the llm write as much as possible but I think it's a worthwhile tradeoff.
Re:Hallucinations in code are the least dangerous form of LL... by intended on Monday March 03, 2025 @01:02AM (#43238763)
I think this is a great line: > My fear is that LLM generated code will look great to me, I won't understand it fully but it will work

This is a degree of humility that made the scenario we are in much clearer.

Our information environment got polluted by the lack of such humility. Rhetoric that sounded ‘right’ is used everywhere. If it looks like an Oxford Don, sounds like an Oxford Don, then it must be an academic. Thus it is believable, even if they are saying the Titanic isn’t sinking.

Verification is the heart of everything humanity does, our governance structures, our judicial systems, economic systems, academia, news, media - everything.

It’s a massive computation effort to figure out what the best ways to allocate resources given current information, allowing humans to create surplus and survive.

This is why we dislike monopolies, or manipulations of these markets - they create bad goods, and screw up our ability to verify what is real.

Re:Hallucinations in code are the least dangerous form of LL... by eru on Monday March 03, 2025 @01:45AM (#43238978)
> But since I didn't author it, I wouldn't be great at finding bugs in it or logical flaws.

Alas, I don't share your optimism about code I wrote myself. In fact, it's often harder to find flaws in my own code, then when reading someone else's code.

Especially if 'this is too complicated for me to review, please simplify' is allowed as a valid outcome of my review.

Re:Hallucinations in code are the least dangerous form of LL... by otabdeveloper4 on Monday March 03, 2025 @03:03AM (#43239372)
> ...but it will work

You don't know that though. There's no "it must work" criteria in the LLM training.

Re:Hallucinations in code are the least dangerous form of LL... by JimDabell on Monday March 03, 2025 @03:39AM (#43239665)
> My fear is that LLM generated code will look great to me, I won't understand it fully but it will work.

If you don’t understand it, ask the LLM to explain it. If you fail to get an explanation that clarifies things, write the code yourself. Don’t blindly accept code you don’t understand.

This is part of what the author was getting at when they said that it’s surfacing existing problems not introducing new ones. Have you been approving PRs from human developers without understanding them? You shouldn’t be doing that. If an LLM subsequently comes along and you accept its code without understanding it too, that’s not a new problem the LLM introduced.

Re:Hallucinations in code are the least dangerous form of LL... by sarchertech on Monday March 03, 2025 @06:49AM (#43240848)
No one takes the time to fully understand all the PRs they approve. And even when you do take the time to “fully understand” the code, it’s very easy for your brain to trick you into believing you understand it.

At least when a human wrote it, someone understood the reasoning.

Re:Hallucinations in code are the least dangerous form of LL... by sgarland on Monday March 03, 2025 @08:56AM (#43241744)
> No one takes the time to fully understand all the PRs they approve.

I was appalled when I was being effusively thanked for catching some bugs in PRs. “No one really reads these,” is what I was told. Then why the hell do we have a required review?!

Re:Hallucinations in code are the least dangerous form of LL... by sarchertech on Monday March 03, 2025 @09:39AM (#43242162)
Cargo culting.
Re:Hallucinations in code are the least dangerous form of LL... by np- on Monday March 03, 2025 @07:20AM (#43241055)
Code reviews with a human are a two way street. When I find code that is ambiguous I can ask the developer to clarify and either explain their justification or ask them to fix it before the code is approved. I don’t have to write it myself, and if the developer is simply talking in circles then I’d be able to escalate or reject—and this is a far less likely failure case to happen with a real trusted human than an LLM. “Write the code yourself” at that point is not viable for any non-trivial team project, as people have their own contexts to maintain and commitments/projects to deliver. It’s not the typing of the code that is the hard part which is the only real benefit of LLMs that they can type super fast, it’s fully understanding the problem space. Working with another trusted human is far far different from working with an LLM.
Re:Hallucinations in code are the least dangerous form of LL... by madeofpalk on Monday March 03, 2025 @07:28AM (#43241112)
Do you not review code from your peers? Do you not search online and try to grok code from StackOverflow or documentation examples?

All of these can vary wildly in quality. Maybe its because I mostly use coding LLMs as either a research tool, or to write reasonably small and easy to follow chunks of code, but I find it no different than all of the other types of reading and understanding other people's code I already have to do.