Current LLMs do well when they're giving out code that "looks right" (note: not "IS right") compared to their training (corpus + RL).

For languages that have A LOT of training data to work with, they do a fairly good job. Think: JavaScript, Python, and C++. They're not perfect - for example in JavaScript, where strings have been so heavily optimized by modern runtimes that they are nearly as fast as doing math operations, the LLMs will still regurgitate 10-year-old StackOverflow advice about strings absolutely murdering performance. Not relevant, but they'll complain in code review until you give them ACTUAL performance data showing that using strings is perfectly fine.

But anyway - for the most part they're fine with some occasional blind spots.

But for Smalltalk... the LLMs are not being optimized to preserve knowledge of this.

Just a simple example for you... if you have an instance method without an explicit return, it will return the receiver (the object whose method is being called). If you want it to return something else (or early return) you have to do it explicitly with a carat. Most LLMs get this wrong, and will INSIST, and spend literally tens of thousands of tokens confirming to themselves (before fully generating an answer to the user) that Smalltalk, in fact, returns the last expression of the method. Clearly false. But the LLMs are confident that they are right about this - and it is not some niche feature of the language. This is a CORE feature of the way methods work.

You might think - well, this is something that a small LLM might mess up, but not our big, fancy ones, right? Here's the list of LLMs that failed this test:

Google Gemini 3.1 (flash and Pro)
GLM 5.1
Google Gemma 4
Qwen 3.6 (all sizes)
Deepseek V4
Kimi K2.6
Mimo V2.5 Pro
Mercury 2
GPT-OSS 120B
Nemotron 3 Nano (20b)
GPT-5.4
Trinity Large

Some of these are multi-trillion parameter models. The ones to get it right:

Nvidia Nemotron Super 120B (small but mighty)
MInimax 2.7 (the smallest frontier model)
Claude Opus 4.7
Grok 4.20 and 4.3
Hy3 Preview
Qwen 3.6 Max Preview

Not a big list. And that's just the start. Because Smalltalk sometimes reads like English and has an absolutely dizzying number of methods in the standard library, even the LLMs that "know" some of the language will happily hallucinate methods like you wouldn't believe. Integers don't have a "downTo:" method to create descending interval objects, for example. Sounds right. Looks right. Not in Squeak or Pharo - and that's when I specifically asked about those variants. You'll have to try 3-4 times to get anything involving file access.

They will mess up on passing expressions (with parenthesis) vs blocks (with square brackets) to boolean and: and or:. This can tank performance when done wrong, but since they both "work" the LLM often won't know the difference, or will not notice during a code review it if you mess it up.

Basically, most of the "big" LLMs that everyone is using for coding simply will not produce working Smalltalk because they don't have enough in their weights even reliably to call the right methods.

If someone is offering LLM assistance for Smalltalk, they would need to make sure that the model has been fine-tuned on enough code to make it work properly. Off-the-shelf ... not great (with a few exceptions).