PBKDF2 is exactly what I'm using right now. The other reason for the extension is to prevent the host from ever having access to the key or the plaintext content. Sure, if you trust the host, the web code could be written to never send plaintext content back to the server. But I'm trying to eliminate that kind of trust requirement.
Did it win?
The best way I can describe the cerebral part of it is:
You are free to think deeply about many things that you normally take for granted and see them as you would with a child-like curiosity. You second guess societal abstractions that used to feel like common sense. You see more plainly the motivations for things and connections between them. You start to feel much more viscerally present in reality rather than caught up in your psychological habits of thinking. The world of metaphor and symbolism starts to feel much richer.
And by the fact of the longest part of programming being digesting code you didn’t write, in effect you’ve taken a long-cut and could have written it yourself faster.
The conclusion doesn't follow from the premise. Just because an LLM may need to tweak something doesn't mean it necessarily would have been faster to do it manually. Humans need to tweak things all the time, it's called revising, and it's an important part of improving code.
But I wouldn't claim that using LLMs is always faster than coding manually, nor the opposite. There are times when LLMs do slow me down. It's important to recognize when that risk is high.
But I'm quite certain that for prototyping specifically, i.e. building a desired UX to get a feel for it and experiment with whether the ideas are sound, LLMs are faster.
So you don’t get a valid answer, you just get a convincing one.
That's why you shouldn't trust an LLM's reasoning; it doesn't actually have sound reasoning abilities. You shouldn't rely on an LLM to reason about problems, you should use it to generate code quickly when the reasoning has either already been done by a human and/or it exists in its training set. LLMs are closer to a search engine than a problem solver.
When asking the person why they did it...
I see no reason why this process is mutually exclusive with using an LLM. You can use both human reasoning and LLM code generation.
No disagreement from me about trivial changes. I make them in my editor all the time, assuming I even have an editor in front of me. Sometimes I don't, and it's possible to use dictation to an LLM to make trivial changes without touching a keyboard.
That means that reviews of LLM outputted code by their nature are either invalid and/or non-optimal.
Not convincing. I've given my reasons
Again, no one suggested that I would prototype with the LLM and then completely trust what it tells me about the code and what it learned from writing it. That is stupid.
You get the LLM to write code quickly and then you review it and perform experiments manually.
You think extroverts are incapable of observing and listening?
What you did not create, you have not understood.
So just because I didn't write a book means I could never understand it from reading it? Are editors useless in the world of book publishing? Then what is the point of code review?
You act as if my LLM-assisted prototyping implies I made no decisions and didn't read any code. That's obviously a terrible way to use LLMs.
In the case of Rust, it makes sense both as a UX win and a way to abstract certain requirements of the build system. Languages don't agree on how to do things like linking packages into a binary or versioning packages. If Rust left all of that unspecified, we'd probably have multiple competing package managers and ecosystems.
I thought Bazel was just a build system, not a package manager.
Not always. Prototyping can be valuable in many circumstances when you don't know the shape you'd like the code to take. Sometimes you need to try something before you know if it's right. I'd rather throw away prototype code written by an LLM than code I had to write the hard way.
I don't think it's very hard to understand. It reduces the up-front cost of development.
That is the point. By making smaller PRs, you inevitably end up with dependencies between them. So you'd like to stack them.