So I think that we are leaving a lot of power on the table if we treat generated code exclusively as something to understand, rather than something to understand with. The techniques Geoffrey presents are great, but they should come alongside approaches that use code itself to develop and articulate conceptual models.

The real conclusion is that programming is such a high-leverage activity that even technically trivial, low-quality programming is immensely valuable economically. That's not going anywhere, but maybe LLMs are going to make it all that much cheaper. (Which is mostly great! But I really don't look forward to the painful debugging and maintenance that reams of shit code will push down on programmers.)

But also, there still is a ton of programming that is fundamentally difficult. That's not going anywhere either. And LLMs are useful there too, but they're currently nowhere near replacing the expertise needed to do novel and non-trivial technical work.

In an ideal world, making mediocre code cheaper should leave more room for taking on harder technical challenges. In reality, this has always been dictated far more by non-technical factors—culture, leadership, trust, risk tolerance...—than by anything intrinsic to programming. But, at least for now, we can use the LLM hype to motivate the kind of deeper technical work that always made sense but was too uncertain or too open-ended or too long-term for non-technical leadership.

And we should also drop the bullshit "code was never the hard part" framing.

It makes more sense for applications where you have complex interactive logic in the UI, with a lot of different components that need to control and display some shared state.

wave failed for weird google organizational reasons far more than anything inherent to the product or tech

This seems like a pretty dubious conclusion to make from the outside. There are a lot of reasons somebody would get fired after an acquisition. Hell, even if he was coasting, an acquisition followed by a rapid change in environment and culture can cause somebody to lose motivation for a wide range of reasons. Blaming this on "lifetstyle creep" is rather premature and, frankly, pretty judgemental or moralistic.

This is downstream of a pretty frustrating belief I've seen repeatedly in the tech industry: that whether a person is "motivated" or "hard working" is some kind of inherent quasi-moral characteristic of the person, rather than something substantially affected by environment. But hey, it's much easier to blame individuals and lean on the perf review process than it is to change organizational culture or leadership!

Go is... very much not on the Pareto frontier of programming language design.

One surprising thing is that, in the grand scheme of things, developing an alternative like Rust is not that expensive. It takes something like a small team a few years. Maybe a person-decade of effort to get to a viable point? Maybe two, whatever. The industry as a whole throws away orders of magnitude more engineering-years than that on vanity projects and internal dysfunction every year.

Of course, even once we have an alternative, the switching costs are high. And the barriers are far more social, organizational and political than they are technical. But even so, moving to alternatives incrementally has been viable for decades. And hey, if we include moves to garbage collected languages, we have been moving quite a bit... but we could have been moving more. It was only a matter of will and, upstream of that, cultural change.

So really, the problem isn't that people complain too much, it's that they don't complain enough :)

Key parts of the abstract:

> This raises a question the programming-language community has not previously had reason to ask: should error-message detail be calibrated differently for AI agents than for humans?

> We investigate this question through a controlled experiment using Shplait, an ML-style statically typed language. We construct a suite of programs containing a single deliberate type error each, and measure how often an AI agent repairs them under ablation: a detailed error context using the unification stack; a proximate error location; a minimal type error; and a dynamic (test suite) error only. An automated oracle uses a test suite to classify each repair attempt as a type error, semantically incorrect, or semantically correct.

> We find concrete evidence that more detailed error messages generally improve an agent's ability to fix type errors. We also find that the presence of a type system appears to help more than only test suite failure reports.

But of course, designing the system that pushes people to make this sort of decision was absolutely intentional.

So even when it's incompetence, it's still malicious, just in a way that obscures the explicit decision-making that led to the result.

The real point isn't that they're "obligated" to allow AI-generated comments, but that they're being something of a hypocrite.

We're talking about things like text people wrote, not some kind of raw data floating out in the ether.

I love Haskell, I've spent a lot of time in the general area around functional programming, types, proofs and PL, and there is still a vibrant community with lots of amazing non-commercial projects there. I'm sure the same is true in other areas of the programming world.

Ditto for the Emacs world. Emacs and its package ecosystem are amazing, better than they've ever been, and ≈entirely driven by non-commercial work.

Same for a big chunk of NixOS, although there's also been some real commercial investment there now.

I never really thought about it before writing this comment, but, except for games, most of the software I use and care about is primarily community-driven rather than commercial. And it's absolutely great.

Despite smaller communities and low monetary investment, a remarkable number of things about Haskell and Emacs and Nix are simply better than any commercial alternative, full stop.

The problem isn't that this kind of software has died—it's thriving more than ever—but just that the rest of the field has grown around it even faster. Programming is so commercially valuable that there has been a ton of investment in it and now we have millions of people for whom it's just a career, and trillions of dollars pouring into companies powered, primarily, by programming. It's a wild time. The overall feel of the field is definitely different now, but you can still find classic hacker enclaves. You just have to cut through the noise first.

We had a successful campaign to recall a progressive prosecutor over less.

The real answer is that the electorate is vehemently opposed to providing paths like that if those paths feel even remotely like "unfair handouts". Votes hate that idea even if it would be empirically cheaper. We collectively preserve the problem of homelessness because we feel like people who can't/won't work deserve to be unhappy, because we believe that we need the threat of homelessness to coerce people into working, because we believe people on drugs/etc are undisciplined and immoral, because... well, you get the idea.

This is handy for me because my taste in music runs pretty different from most of my friends.

I don't know how much of this comes from using Spotify in a different way, and how much is Spotify's algorithm adapting to my weird preferences.