Comment by cowl | Hacker News Reader

Comment by cowl | Hacker News Reader

Parent Full thread

>How is that different from how it worked without LLMs? The only difference is that we can now get a failing product faster and iterate.

The difference is that there is an engineer in the middle who can judge if the important information is provided or not as input.

1. for a LLM "the button must be blue" has the same level of importance as "the formula to calculate X is..."

2. failing faster and iterating is good thing if the parameters of failing are clear which is not always the case with vibecoding, especially when done by people with no prior experience in developing. plenty of POCs build with vibecoding have been presented with no aparent failure in their happy path but with disastrous results in edge cases or with disastrous Security etc.

3. where previously, familairity with the codebase and especially the "history of changes" gave you context about why some workarounds were put into place, these are things that are lost to a LLM. Vibecoding a change to an existing system risks removing those "special workarounds" that keep in mind much more than the current context of the specifications or prompt.

> 1. for a LLM "the button must be blue" has the same level of importance as "the formula to calculate X is..."

You can divide those into two prompts though, there is no point for the LLM to work on both features at the same time. This is why iterative is so useful (oh, the button should be blue, ... and later, the formula should be X).

> 2. failing faster and iterating is good thing if the parameters of failing are clear which is not always the case with vibecoding, especially when done by people with no prior experience in developing. plenty of POCs build with vibecoding have been presented with no aparent failure in their happy path but with disastrous results in edge cases or with disastrous Security etc.

This isn't about vibecoding. If you are vibecoding, then you aren't developing software, you are just wishing for good code from vague descriptions that you don't plan to iterate on.

> 3. where previously, familairity with the codebase and especially the "history of changes" gave you context about why some workarounds were put into place, these are things that are lost to a LLM. Vibecoding a change to an existing system risks removing those "special workarounds" that keep in mind much more than the current context of the specifications or prompt.

LLMs can read and write change logs just as well as humans can (LLMs need change logs to do updates, you can't just give it a changed dependency and expect the LLM to pick up on the change, it isn't a code generator). Actually, this is my current project, since a Dev AI pipeline needs to read and write change logs to be effective (when something changes, you can't just transmit the changed artifact, you need to transmit a summary of the change as well). And again, this is serious software engineering, not vibecoding. If you are vibecoding, I have no advice to give you.

> LLMs can read and write change logs just as well as humans can (LLMs need change logs to do updates, you can't just give it a changed dependency and expect the LLM to pick up on the change, it isn't a code generator). Actually, this is my current project, since a Dev AI pipeline needs to read and write change logs to be effective (when something changes, you can't just transmit the changed artifact, you need to transmit a summary of the change as well). And again, this is serious software engineering, not vibecoding.

This is the important part of the post to which you replied and remains unaddressed:

  The difference is that there is an engineer in the middle 
  who can judge if the important information is provided or 
  not as input.

The engineer decide what information to use as input to the update prompt. They don’t need to be in the middle of anything, it’s basically the level they are coding at.

> The engineer decide what information to use as input to the update prompt. They don’t need to be in the middle of anything, it’s basically the level they are coding at.

LLMs do not possess the ability to "judge if the important information is provided or not as input" as it pertains to the question originally posed:

  How is that different from how it worked without LLMs?

Working without LLMs involves people communicating, hence the existence of "an engineer in the middle", where middle is defined as between stakeholder requirement definition and asset creation.

So you engineer the prompt. I’m still confused what the problem is, I’ve already stated that I’m not talking about vibe coding where the LLM somehow magically figures out relevant information on their own.

> So you engineer the prompt. I’m still confused what the problem is ...

The problem is stakeholders are people and they define what problems are needed to be solved. For those tasked to do so requires understanding of the given problems. Tooling (such as LLMs) does not possess this type of understanding as it is intrinsic to the stakeholders (people) whom have defined it. Tools can contribute to delivering a solution, sure, but have no capability to autonomously do so.

For example, consider commercial dish washing machines many restaurants use.

They sanitize faster and with greater cleanliness than manual dish washing once did. Still, there is no dish washing machine which understands why it must be used instead of not. Of course, restaurant stakeholders such as health inspectors and proprietors understand why they must be used.

As far as the commercial dish washer is concerned, it could just as easily be tasked with cleaning dining utensils as it could recycled car parts.

Reply on news.ycombinator.com