I appreciate that people are calling stuff like this out on most AI articles/blogs posted in Tildes. It's almost always a post from someone at an AI company, usually the CEO, and they almost...
I appreciate that people are calling stuff like this out on most AI articles/blogs posted in Tildes.
It's almost always a post from someone at an AI company, usually the CEO, and they almost always focus on, or exaggerate, the positive while glossing over the negative. Although this article was more honest than most.
The author is right that as proof of concept it was impressive. Putting aside the code quality, imagine reading about this just 4 years ago... A swarm of AI agents, orchestrated by other AI agents, writing a (technically) working compiler? Maybe the craziest thing is how quickly it's becoming normal.
And also I don't think enough time was spent on the fact that it's not useful software, that it's not even close to being useful software. That the only path to it someday being useful software is humans in the loop or theoretical future model advances that do not follow linearly from the current progress.
For me LLMs are useful, but as a software that helps speed up the process rather than an automation software. Imo the problem is the insistence on trying to make it an automation tool. It’s not....
For me LLMs are useful, but as a software that helps speed up the process rather than an automation software.
Imo the problem is the insistence on trying to make it an automation tool. It’s not. It’s prone to mistakes, and these compound on each other the longer we let the agents run autonomously, much to the dismay of CEOs who want their companies to run only with bots that don’t need salaries
The real use for me came from me using it to build simple functions/scripts that complement what I’m doing. Like how a mathematician uses a calculator to help his calculations.
Like for example “I need a function that sums variables” or “I need a function that cleans up the string”, etc. I’ve been using it in this context for a long while now and it improved my performance quite a bit, I can make scripts in few hours that before would take days
From a blog post by Chris Lattner, who (according to Wikipedia) was the creator of LLVM, the Clang compiler, and the Swift programming language: [...] [...] [...] [...] [...]
From a blog post by Chris Lattner, who (according to Wikipedia) was the creator of LLVM, the Clang compiler, and the Swift programming language:
The Claude C Compiler is a milestone, showing progress at a different level. It shows an AI system maintaining coherence across an entire engineering system that can coordinate multiple subsystems, preserve architectural structure, iterate toward correctness over time, and operate within a complex feedback loop of tests and failures. AI is beginning to move from code completion toward engineering participation.
However, the deeper reason compilers align unusually well with modern AI systems is that compiler engineers build architectures that are highly legible and structured. Compilers have layered abstractions, consistent naming conventions, composable passes, and deterministic feedback (“it works” or “it doesn’t” - there is a clear success criteria). These properties make compilers unusually learnable for both humans and machine learning systems trained on large amounts of source code.
Seen this way, CCC is validation of decades of software engineering practice. The abstractions developed by compiler engineers turned out to be structured enough that machines can now reason within them. That is a remarkable milestone. However, it also hints at an important limitation.
[...]
The design choices throughout the repository consistently reflect well-established compiler practice - things taught in a university class and widely used by existing compilers like LLVM and GCC. The intermediate representation includes concepts that will look immediately familiar to LLVM developers, including instructions like GetElementPtr, basic block “terminators” and Mem2Reg. It appears to have strong knowledge of widely-used compiler design techniques.
LLVM and GCC code are clearly part of the training set - Claude effectively translated large swaths of them into Rust for CCC. The design docs show detailed knowledge of both systems, as well as considered takes on its implementation approach. Some have criticized CCC for learning from this prior art, but I find that ridiculous - I certainly learned from GCC when building Clang!
[...]
Taken together, CCC looks less like an experimental research compiler and more like a competent textbook implementation, the sort of system a strong undergraduate team might build early in a project before years of refinement. That alone is remarkable.
[...]
The most revealing parts of CCC are its mistakes. Several design choices suggest optimization toward passing tests rather than building general abstractions like a human would. A few examples:
The code generator is “toy” and the optimizer reparses assembly text instead of using an IR, and the code generators are poorly factored.
It appears that CCC doesn’t parse system headers (which are much more gnarly to deal with than application code) so it hard codes in things it needs for its tests.
[...]
Modern LLMs are extraordinarily powerful distribution followers. They learn patterns across vast bodies of existing work and generate solutions near the center of that collective experience. When trained on decades of compilers shaped by GCC, LLVM, and academic literature, it is entirely natural that the result reflects that lineage. This phenomenon closely aligns with Richard Sutton’s Bitter Lesson, where scalable methods rediscover broadly successful structures.
[...]
CCC shows that AI systems can internalize the textbook knowledge of a field and apply it coherently at scale. AI can now reliably operate within established engineering practice. This is a genuine milestone that removes much of the drudgery of repetition and allows engineers to start closer to the state of the art. But it also highlights an important limitation of this work:
Implementing known abstractions is not the same as inventing new ones. I see nothing novel in this implementation.
The author of this blog post is the CEO of Modular, a company that develops and sells generative AI products.
I appreciate that people are calling stuff like this out on most AI articles/blogs posted in Tildes.
It's almost always a post from someone at an AI company, usually the CEO, and they almost always focus on, or exaggerate, the positive while glossing over the negative. Although this article was more honest than most.
The author is right that as proof of concept it was impressive. Putting aside the code quality, imagine reading about this just 4 years ago... A swarm of AI agents, orchestrated by other AI agents, writing a (technically) working compiler? Maybe the craziest thing is how quickly it's becoming normal.
And also I don't think enough time was spent on the fact that it's not useful software, that it's not even close to being useful software. That the only path to it someday being useful software is humans in the loop or theoretical future model advances that do not follow linearly from the current progress.
For me LLMs are useful, but as a software that helps speed up the process rather than an automation software.
Imo the problem is the insistence on trying to make it an automation tool. It’s not. It’s prone to mistakes, and these compound on each other the longer we let the agents run autonomously, much to the dismay of CEOs who want their companies to run only with bots that don’t need salaries
The real use for me came from me using it to build simple functions/scripts that complement what I’m doing. Like how a mathematician uses a calculator to help his calculations.
Like for example “I need a function that sums variables” or “I need a function that cleans up the string”, etc. I’ve been using it in this context for a long while now and it improved my performance quite a bit, I can make scripts in few hours that before would take days
From a blog post by Chris Lattner, who (according to Wikipedia) was the creator of LLVM, the Clang compiler, and the Swift programming language:
[...]
[...]
[...]
[...]
[...]
And therein lies the rub. Ultimately, some human thinking magic will still be needed for the foreseeable future.
To be fair, this project wasn't trying to invent any new compiler techniques.