Andrei Alexandrescu wrote Modern C++ Design, the book that made template metaprogramming a thing people did on purpose. His ACCU 2026 keynote asks a narrower question than the title suggests: if a machine writes the code, is abstraction still worth anything? His answer is yes, and the reasoning has nothing to do with human comprehension.
The claim he is arguing against
The position under attack is the one where source code becomes a historical artifact — you hand over a vague specification and the machine emits something executable, skipping languages entirely.
"AI will write machine code. So essentially, you give the vibe code whatever specification, which is again a vague specification, and then the machine is going to generate directly executable code without going through the pesky languages, programming languages source and compilation and all that nonsense. I think that's wrong. I think that's wrong for an interesting reason. I think that's wrong because it's inefficient."
Not impossible. Inefficient. That distinction is the whole talk, and it is a better argument than the usual ones, because it does not depend on the model being bad at anything.
"Instantiation is going to delete the abstraction. By the time you're in the machine code world, there's no more classes and stuff... So AI may be able to restore the cow from the hamburger, but that would be very inefficient. And all of a sudden we care about this kind of inefficiency because tokens cost money."
The cost lands on the second edit, not the first:
"Let's say I want to change that project. The machine will have to read the hamburger, read the code, the assembler code, transform it back into the cow and say, I want the black spot right here. And then fine, I'll generate the hamburger once again, right? No bueno. We don't want that."
The experiment worth stealing
This is the part to take back to work. He took a working ~20-line softmax and renamed it, along with everything referring to it.
"I ran an experiment. You take a function, call it softmax... And softmax, I renamed it to foo. Everyone in the project, what happened? The AI was able to discover it was doing softmax because in embedded space the source of softmax looks a lot [like] what it knew already... the fact that I called it foo instead of softmax made it go slower, do more tokens, do more iterations, do more work for no good reason just because I changed the name."
The result is not that the model failed. It succeeded, and paid for the privilege.
"Use good names" has always been an aesthetic argument you could decline. Here it has a unit: tokens, iterations, wall-clock. A name the model already has a dense representation for is a compressed specification — you are citing a concept instead of describing one. A name it has never seen makes it reconstruct the concept from the body every time it reads the file.
His analogy for why substitution is expensive rather than merely ugly:
"Try to say in the conversation, whenever you say 'the', you say 'chair'. It's very difficult. It's very difficult. You won't believe it. Like, you know, you say like five sentences, you're already like, what did you mean? Right? You can't replace one symbol with another. Words have power and the same applies to AI."
Scale is the argument, not comprehension
The usual defence of abstraction is that human working memory is small. Alexandrescu explicitly gives that away and argues the point survives anyway.
"If we had perfect intellect, consider this. God only needs int main. One billion [lines] of main. God doesn't need modules, abstraction, all of these things, because they are for our weak minds. They're not for the perfect."
Then the turn:
"And the same applies to AI. No matter how good AI it is, it's going to be a project of a size that's big enough for AI to not be able to handle in int main. So as the size grows, AI would need abstraction. And don't forget that scale demand is elastic."
Elastic demand is what makes this more than a debating point. Current models look adept because current projects are the size they are. He expects that to move — "we're gonna move on to much bigger projects, friends, because we can" — and notes Windows sits around 100 million lines with nothing structural stopping a project from being far larger. Better abstractions, in his framing, "help AIs just as well as they help intelligent people."
The predictions
He puts five on the record, in descending order of how much the room agreed.
| Prediction | Status in the talk |
|---|---|
| AI will define its own abstractions, not just consume ours | His headline claim; asserted, not evidenced |
| Software projects grow to billions of lines | Argued from elastic demand; got the loudest agreement |
| Compilers detect larger patterns and lower them to instructions | Extrapolated from the C++ as-if rule |
| Warning and remark volume explodes, and that becomes fine | Because the consumer stops being human |
| Some form of the 1980s specification-language idea returns | Raised, then left open |
Where to push back
The renamed-function experiment is one function, one project, one model, reported from the stage with no numbers attached. It is a good demonstration of a mechanism that is independently plausible; it is not a measurement, and he does not present it as one. If you want it to change how your team names things, run it on your own repo with your own token counts.
The "AI will define its own abstractions" headline is the least supported claim in the talk. Every concrete example he gives is of a model using abstractions that already exist — idioms, templates, library vocabulary — and he concedes the gap himself when he says AI is "very good at picking up new idioms with templates, but it's not going to discover many of its own."
There is also a survivorship problem in the framing. The talk is delivered to a C++ conference and concludes that the language work in flight — contracts, reflection — remains worthwhile. That is the conclusion this audience wanted, and the argument for it is thinner than the argument against machine-code generation.
And the padding is real. The first half is printing presses, hockey broadcasts, and the methodology fads of the 1980s. Some of it sets up the "every universal solvent gets absorbed" shape, but the ratio is poor.
Worth watching
Eighty-two minutes, and the load-bearing section is 56 to 70. Start there if you want the abstraction argument and the experiment without the history. The single idea to carry out of it is the cheapest one to act on: the names in your codebase are part of the prompt now, and vague ones are billed per token on every read.
Originally published at pickuma.com. Subscribe to the RSS or follow @pickuma.bsky.social for new reviews.
Top comments (0)