We could fix that, but it requires a political will to change the law.

Emacs, vim/nvim, intellij, etc… pretty much all vulnerable to such an attack

Reality is most devs wouldn’t be satisfied with the limitations proper sandboxing would create.

I'm not sure that's true. We've actually seen several open source projects that were vibe coded literally fold up and disappear because they ran into issues that the AI couldn't solve and no one understood them well enough to solve.

There's a reason openai/anthropic and friends are hiring shitloads of software engineers. You still need people that can understand and fix things when the AI goes off hte rails, which happens way more often than any of those companies would like to admit. Sure, "fixing things" often involves having the AI correct itself, but you still have to understand the system enough to know how/when to do that.

We can actually address problems when we want to. It's just pretty slow and requires people to actually give a shit and put in the effort to build support.

Apple doesn't even sell a model. They just have a deal to use Googles. They can't "protect" their cloud version of a model they don't have.

It couldn't exist without engineers.

There's always people for management to blame. That's the great part of being management.

By definition, there's someone/thing you're managing that you can pass the blame onto.

The local models don’t really compete with the flagship labs for most tasks

But there are things you may not want to send to them for privacy reasons or tasks where you don’t want to use tokens from your plan with whichever lab. Things like openclaw use a ton of tokens and most of the time the local models are totally fine for it (assuming you find it useful which is a whole different discussion)

Fighting the standard often creates it's own set of problems and nightmares that just aren't worth it. Especially true in C++ where yhou often have to integrate with other projects and their build systems. Way easier if you just use cmake like everyone else.

Even the old hold outs, boost and google open source, now use cmake for their open source stuff.

If you're deploying the binary to more than one machine, you quickly run into issues where the CPUs are different and you would need to rebuild for each of them. This is feasible if you have a couple of machines that you generally upgrade together, but quickly falls apart at just slightly more than 2 machines.

That's actually highly doubtful to me.

Tons of studies and writing about how reading and debugging code is wildly more time consuming than writing it. That time goes up even more when you're not the one that wrote the code in the first place. It's why we've spent decades on how to write readable/maintainable code.

So either all this shit about reading/maintaining code being difficult was lies and we've spent decades wasting our time or AIs can only improve productivity if you stop verifying/debugging code.

So I find it very unlikely that it would have taken more than a couple hours to just write it the first time.

A combination of being in the right place at the right time and connections to people with money

Just very basic type substitution is one of the most useful uses of templates and is useful in pretty much all software

They’re also useful when you can’t use virtual dispatch. Concepts help a lot in making that tolerable.

Sure they can get stupid complicated and ugly as hell, but you don’t have to do that. Even their basic form is very useful

That said, RAII is probably the must useful thing

This is the assumption that has almost always failed and thus has lead to the banning of AI code altogether in a lot of projects.

At my company, I use them all the time with the fancy models and everything. Preplanning does not solve the problem they're describing.

When claude is doing a complex task, it will regularly lose track of the rules (in either the .rules stuff or CLAUDE.md) and break conventions.

It follows it most of the time, but not all of the time.

Maybe one day it will be.. And then people can reevaluate their stance then. Until that time, it's entirely reasonable to hold the position that you just don't

This is especially true with how LLM generated code may affect licensing and other things. There's a lot of unknowns there and it's entirely reasonable to not want to risk your projects license over some contributions.

I use them all the time at work because, rightly or wrongly, my company has decided that's the direction they want to go.

For open source, I'm not going to make that choice for them. If they explicitly allow for LLM generated code, then I'll use it, but if not I'm not going to assume that the project maintainers are willing to deal with the potential issues it creates.

For my own open source projects, I'm not interested in using LLM generated code. I mostly work on open source projects that I enjoy or in a specific area that I want to learn more about. The fact that it's functional software is great, but is only one of many goals of the project. AI generated code runs counter to all the other goals I have.

A year ago, the "state of the art" models were total turds. So this isn't exactly good news

Not to mention the performance of local LLMs makes them utterly unusable unless you have multiple tens of thousands to invest in hardware (and that was before the recent price spike). If you're using commodity hardware, they're just awful to use.

ZMK (or it's free software cousin QMK) are super flexible and you can create lots of custom behaviors for keys (tap/hold behaviors, double press, layering, etc...). It takes some time and effort to learn how to set it all up. Some of the more complicated behaviors require using their dsl for mapping the keys instead of their GUI editor. Considering the ridiculous amount of hours I spend at my computer using a keyboard, I felt it was worth the investment in learning.