neoden

Show some mercy. The team that supports the poor thing has their OKRs too.

was there a minority report?

then we wonder how are modern computers so slow?

They even kind of admit that themselves and offer a remote page turning accessory with buttons for Kobo readers)

what is the attack vector btw?

> is scoped to "… at work"

It should be but nothing guarantees you from meeting an interviewer that somehow misunderstands their role and then you will be in a situation when you need to choose what to do next: try to be open or resist. Once during an interview (for a software engineer position) I was asked if I had a family and when I replied that I didn't, I was asked why. You might be able to cut it down in an appropriate way but in a situation of stress (which a job interview represents of course) you might not.

what a nice way to write an article!

The issue is not AI. It's our incentives that make having contributions to a well known open source project a currency for getting a job.

Coding with AI assistants is just a completely different skill that one should not measure from the perspective of comparing it to the way human programmers write code. Mostly everything that we have: programming languages, frameworks, principles of software development in teams, agile/clean code/TDD/DRY and other debatable or well accepted practices — all this exists to overcome limitations of human mind. AI does not have them and have others.

What I found to be useful for complex tasks is to use it as a tool to explore that highly-dimensional space that lies behind the task being solved. It rarely can be described as giving a prompt and coming back for a result. For me it's usually about having winding conversations, writing lists of invariants and partial designs and feeding them back in a loop. Hallucinations and mistakes become a signal that shows whether my understanding of the problem does or does not fit.

So it's using Pro/Max subscription. Isn't this going to be stepping on the same rake as OpenCode?

> LLMs are just probabilistic next-token generators

How sick and tired I am of this take. Okay, people are just bags of bones plus slightly electrified boxes with fat and liquid.

Yes, I get your point and I think your arguments are valid, it's just not the whole story.

The thing about programming languages is that both for their creators and advocates a significant part of motivation to drive is emotions and not the rational necessity alone. Learning a new programming language along with its ecosystem is an investment of time and effort, it is something that our brains mark as important and therefore protected (I'm looking at Rust). Now when AI is going to write all the code, that emotional part might eventually dissolve and move to something else, leaving the question of choice of a programming language much less relevant. Like the list of choices Claude Code shows to you in planning mode: "do you wish to use SQLite, PostgreSQL or MySQL as a database for your project?" (*picking the "Recommended" option)

That said, I hope that Zig will make it to version 1.0 before AI turns all the tables and sweeps many things away. It might be my bias and I'm wrong and overestimating the irrational part, then I'll be glad to admit my mistake.

> would you expect a model (assuming it had the same expertise in each language) to make more mistakes in ASM, C, Zig, or Rust?

"assuming it had the same expertise in each language" is the most important part here, because the expertise of AI with these languages is very different. And, honestly, I bet on C here because its code base is the largest, the language itself is the easiest to reason about and we have a lot of excellent tooling that helps mitigate where it falls short.

> I imagine most would agree that ASM/C would be likely to have the most mistakes simply because fewer constraints are enforced as you go closer to the metal.

We need these constraints because we can't reliably track all the necessary details. But AI might be much more capable (read — scalable) in that, so all the complexity that we need to accumulate in a programming language it might just know out of the way it's built.