[afro88]

> What this interaction shows is how much knowledge you need to bring when you interact with an LLM. The “one big flaw” Claude produced in the middle would probably not have been spotted by someone less experienced with crypto code than this engineer obviously is. And likewise, many people would probably not have questioned the weird choice to move to PBKDF2 as a response

For me this is the key takeaway. You gain proper efficiency using LLMs when you are a competent reviewer, and for lack of a better word, leader. If you don't know the subject matter as well as the LLM, you better be doing something non-critical, or have the time to not trust it and verify everything.

[donatj]

My question is kind of in this brave new world, where do the domain experts come from? Whose going to know this stuff?

[svara]

LLMs make learning new material easier than ever. I use them a lot and I am learning new things at an insane pace in different domains.

The maximalists and skeptics both are confusing the debate by setting up this straw man that people will be delegating to LLMs blindly.

The idea that someone clueless about OAuth should develop an OAuth lib with LLM support without learning a lot about the topic is... Just wrong. Don't do that.

But if you're willing to learn, this is rocket fuel.

[junon]

On the flip side, I wanted to see what common 8 layer PCB stackups were yesterday. ChatGPT wasn't giving me an answer that really made sense. After googling a bit, I realized almost all of the top results were AI generated, and also had very little in the way of real experience or advice.

It was extremely frustrating.

[roxolotl]

This is my big fear. We’re going to end up in a world where information that isn’t common is significantly more difficult to find than it is today.

[andersa]

It's going to be like the pre-internet dark ages, but worse. Back then you only didn't find the information. Now, you find unlimited information, but it is all wrong.

[koolba]

Content from before the AI Cambrian explosion is going to be treated like low-background steel.

https://en.wikipedia.org/wiki/Low-background_steel

[svara]

I don't know, this sounds a lot like in the late 90s when we heard a lot about how anyone could put information on the internet and that you shouldn't trust what you read online.

Well it turns out you can manage just fine.

You shouldn't blindly trust anything. Not what you read, not what people say.

Using LLMs effectively is a skill too, and that does involve deciding when and how to verify information.

[m11a]

The solution is kagi.com imo.

Before AI generated results, the first page of Google was SEO-optimised crap blogs. The internet has been hard to search for a while.

[endofreach]

It will dawn on non-tech people soon enough. Hopefully the "AI" (LLM) hypetrain riders will follow.

[skeeter2020]

>> LLMs make learning new material easier than ever.

feels like there's a logical flaw here, when the issue is that LLMs are presenting the wrong information or missing it all together. The person trying to learn from it will experience Donald Rumsfield's "unknown unknowns".

I would not be surprised if we experience an even more dramatic "Cobol Moment" a generation from now, but unlike that one thankfully I won't be around to experience it.

[threeseed]

Learning from LLMs is akin to learning from Joe Rogan.

You are getting a stylised view of a topic from an entity who lacks the deep understanding needed to be able to fully distill the information. But it is enough to gain enough knowledge for you to feel confident which is still valuable but also dangerous.

And I assure you that many, many people are delegating to LLMs blindly e.g. it's a huge problem in the UK legal system right now because of all the invented case law references.

[diogocp]

> You are getting a stylised view of a topic from an entity who lacks the deep understanding

Isn't this how every child learns?

Unless his father happens to be king of Macedonia, of course.

[kentonv]

I can think of books I used to learn software engineering when I was younger which, in retrospect, I realize were not very good, and taught me some practices I now disagree with. Nevertheless, the book did help me learn, and got me to a point where I could think about it myself, and eventually develop my own understanding.

[threeseed]

Learning requirements of a child are different from an adult.

They are fine with a lossy, imperfect version of how the world works.

[slashdev]

It depends very much on the quality of the questions. I get deep technical insight into questions I can't find anything on with Google.

[catlifeonmars]

I think what’s missing here is you should start by reading the RFCs. RFCs tend to be pretty succinct so I’m not really sure what a summarization is buying you there except leaving out important details.

(One thing that might be useful is use the LLM as a search engine to find the relevant RFCs since sometimes it’s hard to find all of the applicable ones if you don’t know the names of them already.)

I really can’t stress this enough: read the RFCs from end to end. Then read through the code of some reference implementations. Draw a sequence diagram. Don’t have the LLM generate one for you, the point is to internalize the design you’re trying to implement against.

By this time you should start spotting bugs or discrepancies between the specs and implementations in the wild. That’s a good sign. It means you’re learning

[blibble]

how do you gain anything useful from a sycophantic tutor that agrees with everything you say, having being trained to behave as if the sun shines out of your rear end?

making mistakes is how we learn, and if they are never pointed out...

[svara]

It's a bit of a skill. Gaining an incorrect understanding of some topic is a risk anyway you learn, and I don't feel it's greater with LLMs than many of the alternatives.

Sure, having access to legit experts who can tutor you privately on a range of topics would be better, but that's not realistic.

What I find is that if I need to explore some new domain within a field I'm broadly familiar with, just thinking through what the LLM is saying is sufficient for verification, since I can look for internal consistency and check against things I know already.

When exploring a new topic, often times my questions are superficial enough for me to be confident that the answers are very common in the training data.

When exploring a new topic that's also somewhat niche or goes into a lot of detail, I use the LLM first to get a broad overview and then drill down by asking for specific sources and using the LLM as an assistant to consume authoritative material.

[blibble]

this "logic" applied across society will lead to our ruin

[svara]

Say more?

[perching_aix]

> from a sycophantic tutor that agrees with everything you say

You know that it's possible to ask models for dissenting opinions, right? Nothing's stopping you.

> and if they are never pointed out...

They do point out mistakes though?

[belter]

> But if you're willing to learn, this is rocket fuel.

LLMs will tell you 1 or 2 lies for each 20 facts. Its a hard way to learn. They cant even get their urls right...

[diggan]

> LLMs will tell you 1 or 2 lies for each 20 facts. Its a hard way to learn.

That was my experience when growing up with school also, except you got punished one way or another for speaking up/trying to correct the teacher. If I speak up with the LLM they either explain why what they said is true, or corrects themselves, 0 emotions involved.

> They cant even get their urls right...

Famously never happens with humans.

[belter]

You are ignoring the fact that the types of mistakes or lies are of a different nature.

If you are in class, and you incorrectly argue, there is a mistake in an explanation of Derivatives or Physics, but you are the one in error, your Teacher hopefully, will not say: "Oh, I am sorry you are absolutely correct. Thank you for your advice.."

[diggan]

Yeah, no of course if I'm wrong I don't expect the teacher to agree with me, what kind of argument is that? I thought it was clear, but the base premise of my previous comment is that the teacher is incorrect and refuse corrections...

[signatoremo]

And you are saying human teachers or online materials won't lie to you once or twice for every 20 facts? no matter how small. Did you do any comparison?

[skeeter2020]

it's not jsut the lies, but how it lies and the fact that LLMs are very hesitant to call out humans on their BS

[brookst]

Is this the newest meme?

Me: “explain why radioactive half-life changes with temperature”

ChatGPT 4o: “ Short answer: It doesn’t—at least not significantly. Radioactive Half-Life is (Almost Always) Temperature-Independent”

…and then it goes on to give a few edge cases where there’s a tiny effect.

[belter]

You are missing the point. See my comment to @diggan in this thread. LLMs lie in a different way.

[elvis10ten]

> LLMs make learning new material easier than ever. I use them a lot and I am learning new things at an insane pace in different domains.

With learning, aren’t you exposed to the same risks? Such that if there was a typical blind spot for the LLM, it would show up in the learning assistance and in the development assistance, thus canceling out (i.e unknown unknowns)?

Or am I thinking about it wrongly?

[sulam]

If you trust everything the LLM tells you, and you learn from code, then yes the same exact risks apply. But this is not how you use (or should use) LLMs when you’re learning a topic. Instead you should use high quality sources, then ask the LLM to summarize them for you to start with (NotebookLM does this very well for instance, but so can others). Then you ask it to build you a study plan, with quizzes and exercises covering what you’ve learnt. Then you ask it to setup a spaced repetition worksheet that covers the topic thoroughly. At the end of this you will know the topic as well as if you’d taken a semester-long course.

One big technique it sounds like the authors of the OAuth library missed is that LLMs are very good at generating tests. A good development process for today’s coding agents is to 1) prompt with or create a PRD, 2) break this down into relatively simple tasks, 3) build a plan for how to tackle each task, with listed out conditions that should be tested, 3) write the tests, so that things are broken, TDD style and finally 4) write the implementation. The LLM can do all of this, but you can’t one-shot it these days, you have to be a human in the loop at every step, correcting when things go off track. It’s faster, but it’s not a 10x speed up like you might imagine if you think the LLM is just asynchronously taking a PRD some PM wrote and building it all. We still have jobs for a reason.

[evnu]

> Instead you should use high quality sources, then ask the LLM to summarize them for you to start with (NotebookLM does this very well for instance, but so can others).

How do you determine if the LLM accurately reflects what the high-quality source contains, if you haven't read the source? When learning from humans, we put trust on them to teach us based on a web-of-trust. How do you determine the level of trust with an LLM?

[perching_aix]

> When learning from humans, we put trust on them to teach us based on a web-of-trust.

But this is only part of the story. When learning from another human, you'll also actively try and devise whether they're trustworthy based on general linguistic markers, and will try to find and poke holes in what they're saying so that you can question intelligently.

This is not much different from what you'd do with an LLM, which is why it's such a problem that they're more convincing than correct pretty often. But it's not an insurmountable issue. The other issue is that their trustworthiness will wary in a different way than a human's, so you need experience to know when they're possibly just making things up. But just based on feel, I think this experience is definitely possible to gain.

[ativzzz]

Because summarizing is one of the few things LLMs are generally pretty good at. Plus you should use the summary to determine if you want to read the full source, kind of like reading an abstract for a research paper before deciding if you want to read the whole thing.

Bonus: the high quality source is going to be mostly AI written anyway

[kentonv]

I did actually use the LLM to write tests, and was pleased to see the results, which I thought were pretty good and thorough, though clearly the author of this blog post has a different opinion.

But TDD is not the way I think. I've never been able to work that way (LLM-assisted or otherwise). I find it very hard to write tests for software that isn't implemented yet, because I always find that a lot of the details about how it should work are discovered as part of the implementation process. This both means that any API I come up with before implementing is likely to change, and also it's not clear exactly what details need to be tested until I've fully explored how the thing works.

This is just me, other people may approach things totally differently and I can certainly understand how TDD works well for some people.

[perching_aix]

When I'm exploring a topic, I make sure to ask for links to references, and will do a quick keyword search in there or ask for an excerpt to confirm key facts.

This does mean that there's a reliance on me being able to determine what are key facts and when I should be asking for a source though. I have not experienced any significant drawbacks when compared to a classic research workflow though, so in my view it's a net speed boost.

However, this does mean that a huge variety of things remain out of reach for me to accomplish, even with LLM "assistance". So there's a decent chance even the speed boost is only perceptual. If nothing else, it does take a significant amount of drudgery out of it all though.

[motorest]

> With learning, aren’t you exposed to the same risks? Such that if there was a typical blind spot for the LLM, it would show up in the learning assistance and in the development assistance, thus canceling out (i.e unknown unknowns)?

I don't think that's how things work. In learning tasks, LLMs are sparring partners. You present them with scenarios, and they output a response. Sometimes they hallucinate completely, but they can also update their context to reflect new information. Their output matches what you input.

[wslh]

Another limitation of LLMs lies in their inability to stay in sync with novel topics or recently introduced methods, especially when these are not yet part of their training data or can't be inferred from existing patterns.

It's important to remember that these models depend not only on ML breakthroughs but also on the breadth and freshness of the data used to train them.

That said, the "next-door" model could very well incorporate lessons from the recent Cloudflare OAuth Library issues, thanks to the ongoing discussions and community problem-solving efforts.

[paradox242]

The value of LLMs is that they do things for you, so yeah the incentive is to have them take over more and more of the process. I can also see a future not far into the horizon where those who grew up with nothing but AI are much less discerning and capable and so the AI becomes more and more a crutch, as human capability withers from extended disuse.

[conradev]

  Just wrong. Don’t do that

I’d personally qualify this: don’t ship that code, but absolutely do it personally to grow if you’re interested.

I’ve grown the most when I start with things I sort of know and I work to expand my understanding.

[a13n]

If the hypothesis is that we still need knowledgeable people to run LLMs, but the way you become knowledgeable is by talking to LLMs, then I don’t think the hypothesis will be correct for long..

[mwigdahl]

We need knowledgeable people to run computers, but you can become knowledgeable about computers by using computers to access learning material. Seems like that generalizes well to LLMs.

[svara]

You inserted a hidden "only" there to make it into a logical sounding dismissive quip.

You don't get knowledge by ONLY talking to LLMs, but they're a great tool.

[hammyhavoc]

> LLMs make learning new material easier than ever. I use them a lot and I am learning new things at an insane pace in different domains.

Sorry, but the the amount of bad information dispensed by models and the student's ability to go "hey, that's wrong" due to a lack of experience and knowledge means that this is going to lead to disaster very often.

People already dispensing terrible information on YouTube because they trusted an AI to generate their voice-over script to explain something when creating learning materials.

[therealpygon]

And yet, human coders may do that exact type of thing daily, producing far worse code. I find it humorous at how much higher of a standard is applied to LLMs in every discussion when I can guarantee those exact some coders likely produce their own bug-riddled software.

We’ve gone from skeptics saying LLMs can’t code, to they can’t code well, to they can’t produce human-level code, to they are riddled with hallucinations, to now “but they can’t one-shot code a library without any bugs or flaws” and “but they can only one-shot code, they can’t edit well” even tho recents coding utilities have been proving that wrong as well. And still they say they are useless.

Some people just don’t hear themselves or see how AI is constantly moving their bar.

[brookst]

And now the complaint is that the bugs are too subtle. Soon it will be that the overall quality is too high, leading to a false sense of security.

[maegul]

This, for me, has been the question since the beginning. I’m yet to see anyone talk/think about the issue head on too. And whenever I’ve asked someone about it, they’ve not had any substantial thoughts.

[PUSH_AX]

Engineers will still exist and people will vibe code all kinds of things into existence. Some will break in spectacular ways, some of those projects will die, some will hire a real engineer to fix things.

I cannot see us living in a world of ignorance where there are literally zero engineers and no one on the planet understands what's been generated. Weirdly we could end up in a place where engineering skills are niche and extremely lucrative.

[shswkna]

Most important question on this entire topic.

Fast forward 30 years and modern civilisation is entirely dependent on our AI’s.

Will deep insight and innovation from a human perspective perhaps come to a stop?

[brookst]

Did musical creativity end with synths and sequencers?

Tools will only amplify human skills. Sure, not everyone will choose to use tools for anything meaningful, but those people are driving human insight and innovation today anyway.

[Earw0rm]

No. Even with power tools, construction and joinery are physical work and require strength and skill.

What is new is that you'll need the wisdom to figure out when the tool can do the whole job, and where you need to intervene and supervise it closely.

So humans won't be doing any less thinking, rather they'll be putting their thinking to work in better ways.

[skeeter2020]

to use your own example though, many of these core skills are declining, mechanized or viewed through a historical lens vs. application. I don't know if this is net good or bad, but it is very different. Maybe humans will think as you say, but it feels like there will be significantly less diverse areas of thought. If you look at the front page of HN as a snapshot of "where's tech these days" it is very homgenous compared to the past. Same goes for the general internet and the AI-content continues to grow. IMO published works are a precursor to future human discovery, forming the basis of knowledge, community and growth.

[qzw]

No, but it'll become a hobby or artistic pursuit, just like running, playing chess, or blacksmithing. But I personally think it's going to take longer than 30 years.

[paradox242]

The implication is that they are hoping to bridge the gap between current AI capabilities and something more like AGI in the time it takes the senior engineers to leave the industry. At least, that's the best I can come up with, because they are kicking out all of the bottom rings of the ladder here in what otherwise seems like a very shortsighted move.

[risyachka]

Use it or lose it.

Experts will become those who use llm to learn and not to write code for them or solve tasks for them so they can build that skill.

[kypro]

In a few years hopefully the AI reviewers will be far more reliable than even the best human experts. This is generally how competency progresses in AI...

For example, at one point a human + computer would have been the strongest combo in chess, now you'd be insane to allow a human to critic a chess bot because they're so unlikely to add value, and statistically a human in the loop would be far more likely to introduce error. Similar things can be said in fields like machine vision, etc.

Software is about to become much higher quality and be written at much, much lower cost.

[sarchertech]

My prediction is that for that to happen we’ll need to figure out a way to measure software quality in the way we can measure a chess game, so that we can use synthetic data to continue improving the models.

I don’t think we are anywhere close to doing that.

[mock-possum]

Agreed, chess is for all intents and purposes a ‘solved’ game, it’s merely a matter of processing power, and even then we have shortcuts that are easily ‘good enough’ to play perfectly against human opponents.

But how do you reduce the requirements for software to something so simple and elegant as chess rules? Is it foolish to assume that if we could have, we already would have? Even for humans, the process of writing software includes a lot of guess-and-check most of the time - the idea that you could sit down and think through every aspect of software, then describe it immaculately, then translate that description to a working solution with no bugs or review or need for course correction is just… it’s a pipe dream.

[kypro]

Not really... If you're an average company you're not concerned about producing perfect software, but optimising for some balance between cost and quality. At some point companies via capitalist forces will naturally realise that it's more productive to not have humans in the loop.

A good analogy might be how machines gradually replaced textile workers in the 19th century. Were the machines better? Or was there a was to quantitatively measure the quality of their output? No. But at the end of the day companies which embraced the technology were more productive than those who didn't, and the quality didn't decrease enough (if it did at all) that customers would no longer do business with them – so these companies won out.

The same will naturally happen in software over the next few years. You'd be an moron to hire a human expert for $200,000 to critic a cybersecurity optimised model which costs maybe a 100th of the cost of employing a human... And this would likely be true even if we assume the human will catch the odd thing the model wouldn't because there's no such thing as perfect security – it's always a trade off between cost and acceptable risk.

Bookmark this and come back in a few years. I made similar predictions when ChatGPT first came out that within a few years agents would be picking up tickets and raising PRs. Everyone said LLMs were just stochastic parrots and this would not happen, well now it has and increasingly companies are writing more and more code with AI. At my company it's a little over 50% at the mo, but this is increasing every month.

[sarchertech]

Almost none of what you said about the past is true. Automated looms, and all of the other automated machinery that replaced artisans over the course of the industrial revolution produced items of much better quality than what human craftsman could produce by the time it started to be used commercially because of precision and repeatability. They did have quantitative measurements of quality for textiles and other goods and the automated processes exceeded human craftsman at those metrics.

Software is also not remotely similar to textiles. A subtle bug in the textile output itself won’t cause potentially millions of dollars in damages, they way a bug in an automated loom itself or software can.

No current technology is anywhere close to being able to automate 50% of PRs on any non trivial application (that’s not close to the same as saying that 50% of PRs merged at your startup happens to have an agent as author). To assume that current models will be able to get near 100% without massive model improvements is just that—an assumption.

My point about synthetic data is that we need orders of magnitude more data with current technology and the only way we will get there is with synthetic data. Which is much much harder to do with software applications than with chess games.

The point isn’t that we need a quantitative measure of software in order for AI to be useful, but that we need a quantitative measure in order for synthetic data to be useful to give us our orders of magnitude more training data.

[mock-possum]

Same place the previous generation came from - college courses, DIY hackers, and learn-on-the-job training and apprenticeships.

Why would that change?

[marcusb]

I’m puzzled when I hear people say ‘oh, I only use LLMs for things I don’t understand well. If I’m an expert, I’d rather do it myself.’

In addition to the ability to review output effectively, I find the more closely I’m able to describe what I want in the way another expert in that domain would, the better the LLM output. Which isn’t really that surprising for a statistical text generation engine.

[diggan]

I guess it depends. In some cases, you don't have to understand the black box code it gives you, just that it works within your requirements.

For example, I'm horrible at math, always been, so writing math-heavy code is difficult for me, I'll confess to not understanding math well enough. If I'm coding with an LLM and making it write math-heavy code, I write a bunch of unit tests to describe what I expect the function to return, write a short description and give it to the LLM. Once the function is written, run the tests and if it passes, great.

I might not 100% understand what the function does internally, and it's not used for any life-preserving stuff either (typically end up having to deal with math for games), but I do understand what it outputs, and what I need to input, and in many cases that's good enough. Working in a company/with people smarter than you tends to make you end up in this situation anyways, LLMs or not.

Though if in the future I end up needing to change the math-heavy stuff in the function, I'm kind of locked into using LLMs for understanding and changing it, which obviously feels less good. But the alternative is not doing it at all, so another tradeoff I suppose.

I still wouldn't use this approach for essential/"important" stuff, but more like utility functions.

[ipaddr]

Would you rather it be done incorrectly when others are expecting correctness or not at all? I would choose not at all.

[diggan]

Well, given the context is math in video games, I guess I'd chose "not at all", if there was no way for me to verify it's correct or not. But since I can validate, I guess I'd chose to do it, although without fully understanding the internals.

[_heimdall]

That's why outsource most other things in our life though, why would it be different with LLMs?

People don't learn how a car works before buying one, they just take it to a mechanic when it breaks. Most people don't know how to build a house, they have someone else build it and assume it was done well.

I fully expect people to similarly have LLMs do what the person doesn't know how and assume the machine knew what to do.

[marcusb]

> why would it be different with LLMs?

Because LLMs are not competent professionals to whom you might outsource tasks in your life. LLMs are statistical engines that make up answers all the time, even when the LLM “knows” the correct answer (i.e., has the correct answer hidden away in its weights.)

I don’t know about you, but I’m able to validate something is true much more quickly and efficiently if it is a subject I know well.

[_heimdall]

> competent professionals

That requires a lot of clarity and definition if you want to claim that LLMs aren't competent professionals. I assume we'd ultimately agree that LLMs aren't, but I'd add that many humans paid for a task aren't competent professionals either and, more importantly, that I can't distinguish the competent professionals from others without myself being competent enough in the topic.

My point was that people have a long history of outsourcing to someone else, often to someone they have never met and never will. We do it for things that we have no real idea about and trust that the person doing it must have known what they were doing. I fully expect people to end up taking the same view of LLMs.

[marcusb]

We also have a lot of systems (references, the tort system) that just don't apply in any practical way to LLM output. I mean, I guess you could try to sue Anthropic or OpenAI if their chat bot gives you bad advice, but... good luck with that. The closest thing I can think of is benchmark performance. But I trust those numbers a lot less than I would trust a reference from a friend for, say, a plumber.

I understand a lot of people use LLMs for things they don't understand well. I just don't think that is the best way to get productivity out of these tools right now. Regardless of how people may or may not be used to outsourcing things to other humans.

[_heimdall]

> I just don't think that is the best way to get productivity out of these tools right now.

Well that I completely agree with. I don't think people should outsource to an LLM without the skills to validate the output.

At that point I don't see the value, if I have the skills and will proofread/validate the output anyway it mostly just saved me keystrokes and risks me missing a subtle but very important bug in the output.

[bradly]

I've found llms are very quick to add defaults, fallbacks, rescues–which all makes it very easy for code to look like it is working when it is not or will not. I call this out three different places in my CLAUDE.md trying to adjust for this, and still occasionally get.

[pennomi]

Agreed, I’ve found that LLMs favor wrapping entire functions in broad try:catch structures, making it nearly impossible to identify and debug problems. Dangerous if you don’t correct it.

[ajmurmann]

I've been using an llm to do much of a k8s deployment for me. It's quick to get something working but I've had to constantly remind it to use secrets instead of committing credentials in clear text. A dangerous way to fail. I wonder if in my case this is caused by the training data having lots of examples from online tutorials that omit security concerns to focus on the basics.

[diggan]

> my case this is caused by the training data having

I think it's caused by you not having a strong enough system prompt. Once you've built up a slightly reusable system prompt for coding or for infra work, where you bit by bit build it up while using a specific model (since different models respond differently to prompts), you end up getting better and better responses.

So if you notice it putting plaintext credentials in the code, add to the system prompt to not do that. With LLMs you really get what you ask for, and if you miss to specify anything, the LLM will do whatever the probabilities tells it to, but you can steer this by being more specific.

Imagine you're talking to a very literal and pedantic engineer who argues a lot on HN and having to be very precise with your words, and you're like 80% of the way there :)

[quails8mydog]

Seems like this is the sort of thing the tooling should do for you. Maybe have a few preset prompts for different contexts. I shouldn't have to type in a magic phrase to get it to write code that follows basic professional practice.

[diggan]

> type in a magic phrase to get it to write code that follows basic professional practice

The thing is, there is no agreed upon "basic professional practice" that could be encoded. Ask 10 programmers what "basic professional practice" is and you're gonna get 10 different answers.

For me, simplicity, avoiding over-engineering and being deliberately slow are the best ways to program. But lots of people disagree with this, especially the last part, so why have a different model for every preference, when you can use system prompts to have one model that could follow all of it?

[ajmurmann]

Yes, you are definitely right on that. I still find it a concerning failure mode. That said, maybe it's no worse than a junior copying from online examples without reading all the text some the code which of course has been very common also.

[ants_everywhere]

> It's quick to get something working but I've had to constantly remind it to use secrets instead of committing credentials in clear text.

This is going to be a powerful feedback loop which you might call regression to the intellectual mean.

On any task, most training data is going to represent the middle (or beginning) of knowledge about a topic. Most k8s examples will skip best practices, most react apps will be from people just learning react, etc.

If you want the LLM to do best practices in every knowledge domain (assuming best practices can be consistently well defined), then you have to push it away from the mean of every knowledge domain simultaneously (or else work with specialized fine tuned models).

As you continue to add training data it will tend to regress toward the middle because that's where most people are on most topics.

[loandbehold]

Over time AI coding tools will be able to research domain knowledge. Current "AI Research" tools are already very good at it but they are not integrated with coding tools yet. The research could look at both public Internet as well as company documents that contain internal domain knowledge. Some of the domain knowledge is only in people's heads. That would need to be provided by the user.

[wslh]

I'd like to add a practical observation, even assuming much more capable AI in the future: not all failures are due to model limitations, sometimes it's about external [world] changes.

For instance, I used Next.js to build a simple login page with Google auth. It worked great, even though I only had basic knowledge of Node.js and a bit of React.

Then I tried adding a database layer using Prisma to persist users. That's where things broke. The integration didn't work, seemingly due to recent versions in Prisma or subtle breaking updates. I found similar issues discussed on GitHub and Reddit, but solving them required shifting into full manual debugging mode.

My takeaway: even with improved models, fast-moving frameworks and toolchains can break workflows in ways that LLMs/ML (at least today) can't reason through or fix reliably. It's not always about missing domain knowledge, it's that the moving parts aren't in sync with the model yet.

[SparkyMcUnicorn]

Just close the loop and give it direct access to your console logs in chrome and node, then it can do the "full manual debugging" on its own.

It's not perfect, and it's not exactly cheap, but it works.

[ghuntley]

See also: LLMs are mirrors of operator skill - https://ghuntley.com/mirrors

[jstummbillig]

You will always trust domain experts at some junction; you can't build a company otherwise. The question is: Can LLMs provide that domain expertise? I would argue, yes, clearly, given the development of the past 2 years, but obviously not on a straight line.