Hacker News Reader

> I'm an engineer, my job is to deal with and reduce complexity not accept it blindly without soberly weighing all the pros and cons after building a solid understanding.

But LLMs dont prevent you from doing this? If it does it probably is an organisational issue.

If you generate code you’ll never understand it as deeply as if you’d wrote it. Anyone who has done lots of code review knows this

If you use a compiler instead of writing assembly by hand you’ll never understand the underlying assembly as deeply as if you’d wrote it.

It’s not hard to swap “LLM” speak and make it sound like arguments made about ever higher-level language.

We are all operating at a couple of layers up the stack and 99% of us would be lost at N-1 let alone N-2/N-3 but we don’t bemoan that. I really don’t see how LLMs are different.

With a compiler I actually know pretty well what instructions will be generated by every high-level statement that I write, and when in doubt the compiler will list them for me to examine.

Coding with an LLM could be at most compared with some kind of non-deterministic and non-documented compiler, where you could not predict in any way how it will generate assembly code, so every time when you compile a program you have to also list the generated assembly code and then you must read carefully the assembly code and think hard to determine if it really does what you want.

Of course that does not mean that an LLM is useless for coding or that there are no tasks that can be vibe-coded without worries.

But for anything of long-term importance, like a product delivered to a customer, reviewing carefully a lot of LLM-generated code is not guaranteed to be a simpler task than writing that code yourself. In some cases it may be more productive to partition the new code into code generated by an LLM according to your instructions and code that you write yourself.

> I really don’t see how LLMs are different.

Output from compilers is already verified - after all they have an extensive suite of tests.

With LLMs you're getting into the role of someone who keeps validating the compiler over and over, because its output is not deterministic.

That's a bad analogy because your prompt is not an abstraction of the generated code

But eventually, do you really care? Are you using only software that you developed? For decades we outsourced software development to third parties, to place where people have never seen a line of code, without code review and dubious software development practice. Whole F100 organizations were running on that type of software development.

That's a really good point that is often missed. We go through life using software which we don't know their code at all. Like... The vast majority of it, all people basically. We just trust the people who did it. Not saying that LLMs don't deserve oversight, but how different is that from what we've done previously?

I had faith in the people.

They had jobs and reputations and self-images about being "good" at what they did and psychological needs. And further, they had the same incentives as me to not ship bugs when they could avoid it. And I could see, in general, the conversations humans were having, first on usenet and listservs and then on all the little situations on the larger internet.

I didn't trust them blindly, but if a bunch of us all seemed to be okay with the software for the mysql database or the apache webserver. And while I certainly have no idea who those specific folks were I do know how human communities work. When folks found malicious things in, say, a ruby yaml parser or a node package, it was loud.

And like all human scale things, the pacing was much slower so that things like a person's situation in a community and the human trust associated with that trust were things we could evaluate.

I can't evaluate the output of an LLM in the same way. It does not have the same incentives or needs. And it's not deterministic- if you recall comparing checksums between what you downloaded and what the folks putting the software published, then you understand what I mean here when I note that we could trust-but-verify a lot of things.

With the output of an LLM, it actually is important to check over, much of the human-level surface of how we review software is stripped out.

Correct, however, I'm a maintenance developer already. We rarely get to build whole brand new systems or programs. Most of work is maintaining crap from 20 years ago

Few people are thrown into a codebase that they understand because they wrote it. Not every developer is issued their own greenfield project and said go have fun.

Not sure if i get your take.

"on that path with this garbage"

You mean with this the negative things you attribute LLMs? Limited understanding, function and risk, etc.?

Because what LLMs did is freeing the genie from the bottle. It showed what scaling and ML and Compute can do. It doesn't matter much if LLMs will be Frontier for one year or the next 10 years because VC to alternatives like World Models are available now thanks to LLMs.

The compute required and data required for any further progress through ML is also unblocked by LLM.

The economy is solving the memory wall issue today just because of AI.

I had so many issues with our build system because not a lot of people cared about scaling stateful workloads which need a lot of data shared between, now tx to AI y problems got solved.

LLMs are the ultimate "pin-headed manager who wants to pay programmers by the line and starts yanking cables that they don't understand"

Agreed. LLMs are really bad at software engineering at the moment and those who disagree are those people who think more lines of code are good. The only argument against it is the unjustified guess that one day they’ll be better. My feeling is that they very fact they show us things we missed makes them liable to increase tech debt, and that they in general reduce human understanding of the code base. I don’t see how those things will ever not be true

I've found that LLM helps me to write good code. It essentially works like a colleague who can review my code. It spotted many issues which I wouldn't spotted before. It also helps to free me from some mundane work.

In the end, my immediate productivity with LLM is a lot lower than before. But I assume that quality is a bit higher, at least in the long run, because issues fixed early saves a lot of time later.

I guess I don't use LLMs like a lot of other people. In fact I continue to write most code myself and I just use LLM to aid me or to generate something that's very similar to existing entity and just requires careful copy&paste&replace. My only fear is that this approach to work is not very popular and I might be asked one day to switch to wipe code, which I don't enjoy at all.

This is just not true. LLMs are good at some development.

You may caveat what type of software you are talking about, like complex or out-of-the-ordinary, and say that llms are still bad at that. Fine. But LLMs are actively being used for developing thousands of websites all the time - you can see several examples of them on hackernews every week.

Amount of lines is irrelevant when talking about a landing page or a huge number of internal tools that people are building at the moment. At least until a certain point.

Building a landing page is not something you require a software engineer for.

Any programmer should be able to hack one up. LLMs are good at _programming_, but I haven't seen evidence they are good at engineering yet. But then again, many people with the title "software engineer" are not great at it either.

I wholeheartedly agree with this.

Engineering normally requires thinking long term and if you want to use LLMs it needs to be way more structured. For this use-case LLMs are on way more shaky ground.

Thousands of websites like Garry Tan's amateur pile of garbage?

No.. Like my barbers new website is great and he used AI for it.

Or like the internal tool I whipped up in a few days to try out how we can structure some specific data we have internally in our company.

Well you’re just saying here you don’t care about tech debt or software quality. Of course lines of code is relevant, it’s generally bad to add code and makes the software harder to maintain. I would agree that software development standards in web development can be poor though

Yes that's true - for a lot of use cases I don't care about software quality.

When pouring concrete, I'm not going to use expensive hardwood to frame the concrete base, I'm gonna use stuff that's just strong enough. It's going down the bin anyway.

A lot of internal tools are fine if they are just good enough, they don't really need to be that maintainable if 2 people are gonna use it every once in a while