balder1991

I think because the only places you can download it from are either from the App Store or logging into Apple’s developer’s website.

Basically, I’d say the LLM doesn’t have a “theory” of anything that wasn’t in its training. It’ll always treat your project as if it was reading a book for the first time.

As an example, if you chat with an LLM it can sort of explain concepts it learned in its training, because it created some internal representation of them. However it’ll never be able to explain things about your project unless you tell it (then it can simply repeat it, which is the same RAG does, the LLM is just spitting it out without any deep understanding of it).

You can try to cram as much context to it as possible and overload it with extra information, or you can understand this difference and separate a task that you know the LLM can handle because you’ll be able to leverage its knowledge and judge the final work yourself.

But this distinction needs to be more clear, I think. The LLM doesn’t have any deep understanding of anything you’re creaming into the context window the same way it does with concepts it learned during training from millions of examples and building some internal model of the concepts and their relationships.

Often times to write a good enough specification in a way the LLM won’t misunderstand it, you need to really understand the code and the possible pitfalls in it though. A few times when I tried this route, even adding details just in case the LLM still went and assumed something wrong that I didn’t consider would be a problem until the agent had to make that choice. Then it becomes a game of doing it again and again with more and more detailed instructions until you could have yourself done it in less time and having a deeper understanding of the problem (or I could argue having any understanding of the problem at all, since having the LLM do it for you is like being a manager who has no clue about the lower level decisions made and only being communicated the final result).

You’re not wrong, but there’s a nuance here. More often than not our thoughts fool us into thinking we have something clear when we have only a vague idea of what you want to do.

I kinda [wrote about this before](https://dielsonsales.github.io/2023/05/11/starting-a-new-blo...) but the takeaway is that writing forces you to structure your thoughts, giving them a final shape and enables you to notice flaws or gaps in your own thinking process. It’s impossible to do this without writing.

I’d like to recommend people to read the “Programming as a theory building” article and why the code itself isn’t enough to understand the whole context of a complex project.

Every time you work in a complex software project, you have all the context in your head about what you must take into consideration. LLMs don’t, you have to explain every little detail to them, but there’s no telling where it stops: do you have to explain X to it or is it in the training already?

When you try to shape how a LLM should behave and what it should know, you end up writing a Bible of relevant context that’s increasingly difficult to maintain as well, often with outdated or contradictory information, and it is still free to ignore things you have written and proceed however it wants.

That’s why so many people only feel comfortable giving the LLM some limited task to do, because you can judge if that specific task needs just enough context that it can handle by itself.

It’s what’s called in software engineering as “casual software” as a differentiator of “business software” and “critical software”. Not all types needs a high bar of quality, and most of the software engineering thought practices are tailored for business applications that will be made available to multiple users.

As you said, building a script that only you use personally or a very simple thing that just accomplishes one task and it’s easy to test require almost no engineering, and an LLM can often build those with very little downsides.

There’s even a framework already: https://start.solidjs.com/

Feels a bit like the AI browser that in the end imported Servo for all difficult things.

The way I see it, this is only possible because you can trust the lower layers work reliably and predictably enough that you can move up.

If your operating system was regenerated every day slightly differently and with certain things working and others not, you’d quickly revert to the lower predictable abstraction.

it spends the 6 hours waiting for the tickets to go on sale and buys them for you

Or not, because other 7 billion agents were also waiting for it.

I guess the thing here (which they admit in the post) is that they’re just porting it to Vite, which is the real champ of the story. The LLM basically worked as a translator instead of rebuilding the whole thing from scratch.

So maybe the project is sort of maintainable, as long as people maintain Vite.

Actually, most VPN providers explicitly label the virtual locations as such, I think the famous ones at least do it (ex: Proton and NordVPN even explain them in their respective docs).

It depends on whether the VPN is lying to you. Proton, for example, makes them quite explicit in the software and even lists them for you here: https://protonvpn.com/support/how-smart-routing-works and seems like NordVPN also has a page explaining that.

Yeah, Proton is quite explicit about that: https://protonvpn.com/support/how-smart-routing-works

I have this impression that LLMs are so complicated and entangled (in comparison to previous machine learning models) that they’re just too difficult to tune all around.

What I mean is, it seems they try to tune them to a few certain things, that will make them worse on a thousand other things they’re not paying attention to.

Anything that is very specific has the same problem, because LLMs can’t have the same representation of all topics in the training. It doesn’t have to be too niche, just specific enough for it to start to fabricate it.

One of these days I had a doubt about something related to how pointers work in Swift and I tried discussing with ChatGPT (don’t remember exactly what, but it was purely intellectual curiosity). It gave me a lot of explanations that seemed correct, but being skeptical and started pushing it for ways to confirm what it was saying and eventually realized it was all bullshit.

This kind of thing makes me basically wary of using LLMs for anything that isn’t brainstorming, because anything that requires knowing information that isn’t easily/plentifully found online will likely be incorrect or have sprinkles of incorrect all over the explanations.

It doesn’t really solve it as a slight shift in the prompt can have totally unpredictable results anyway. And if your prompt is always exactly the same, you’d just cache it and bypass the LLM anyway.

What would really be useful is a very similar prompt should always give a very very similar result.

At least it used to be true.

Even assuming it’s not malicious, the script can mess up your environment configuration.

Not sure that’s even possible with ChatGPT embedding your chat history in the prompts to try to give more personal answers.

I think it would be better to just use Docker/Podman at this point?

Exactly, it’s really weird to see all this people claiming these wonderful things about LLMs. Maybe it’s really just different levels of amazement, but I understand how LLMs work, I actually use ChatGPT quite a bit for certain things (searching, asking some stuff I know it can find online, discuss ideas or questions I have etc.).

But all the times I tried using LLMs to help me coding, the best it performs is when I give it a sample code (more or less isolated) and ask it for a certain modification that I want.

More often than not, it does make seemingly random mistakes and I have to be looking at the details to see if there’s something I didn’t catch, so the smallest scope there better.

If I ask for something more complex or more broad, it’s almost certain it will make many things completely wrong.

At some point, it’s such a hard work to detail exactly what you want with all context that it’s better to just do it yourself, cause you’re writing a wall of text to have a one time thing.

But anyway, I guess I remain waiting. Waiting until FreeBSD catches up with Linux, because it should be easy, right? The code is there in the Linux kernel, just tell an agent to port it to FreeBSD.

I’m waiting for the explosion of open source software that aren’t bloated and that can run optimized, because I guess agents should be able to optimize code? I’m waiting for my operating system to get better over time instead of worse.

Instead I noticed the last move from WhatsApp was to kill the desktop app to keep a single web wrapper. I guess maintaining different codebases didn’t get cheaper with the rise of LLMs? Who knows. Now Windows releases updates that break localhost. Ever since the rise of LLMs I haven’t seen software release features any faster, or any Cambrian explosion of open source software copying old commercial leaders.

I don’t even see usage going down

Depends on the price to use these cloud LLMs.

You’re over complicating something that is very simple. The stock market reflects people’s sentiments: greed, excitement, FOMO, despair…

A bubble doesn’t need a grand catalyst to collapse. It only needs prices to slip below the level where investors collectively decide the downside risk outweighs the upside hope. Once that threshold is crossed, selling accelerates, confidence unravels, and the fall feeds on itself.

Brazil had many times a judge punished WhatsApp by blocking it in Brazil, and all the times that happened, Telegram gained hundreds of thousands of new users.

I have this impression too, I open Mastodon and the timeline usually doesn’t have many interesting things.

Yeah we have open source models too that we can use, and it’s actually more fun than using cloud providers in my opinion.

They could, but that’s a recipe for going out of business in the current environment.

This is a bit related to external dependencies vs build yourself (AKA reinvent the wheel). Quite often the external library, long term, causes more issues than building it yourself (assuming you _can_ build a competent implementation).

I feel like this happens mostly because simpler is better, and most of these dependencies don’t follow a good “UNIX” philosophy of modularity, being generic etc. something that you’d notice the standard libraries try to achieve.

Most of these third party dependencies are just a very specific feature that starts to add more use cases until it becomes bloated to support multiple users with slightly different needs.

Actually I’m just thinking that knowledge about how to crash Safari is valuable.