Suggestion - How to spend $20,000 without embarassment.

[steampuker]

If you happen to have another $20,000 from your users, before wasting them on 2 billion input tokens of an AI model, consider donating to much more competent projects than yours:

• FSF Foundation - This doesn't need an explanation, your project is clearly useless without the use of the GNU Toolchain (The linker, the assembler, and the compiler itself). Luckily for you all, the FSF Foundation accepts donations.

• Rust Foundation - Despite making the most unreadable mess that is impossible to debug (thanks to all the comments), I've got to say the Rust programming carried here for not crashing and not frying people's hardware (yet).

• The LLVM Project - Although this is not a suggestion for your project, but a real compiler would probably use the well tested LLVM (in fact, rustc is driven by it). So yeah, next time, instead of using duct tape solutions involving GCC, at least do a proper research on the subject.

Lastly, I hope the entire idea of AI driven compilers dies out as fast as possible. You clearly do not know what you're doing.

[steampuker]

I forgot the last option, which is to give $20,000 to me, I wouldn't mind :)

[rollerozxa]

I would quite like $20,000 too

[huixue]

Honestly speaking, this project seems to be pushing the frontier of possibility, without knowing what could be indeed achieved ahead of time. I don't think the author need a big score anyway.

A working prototype of a C compiler, I think that's what it is at this moment. I tested it out a bit, I guess a linker would be nicer, if wants to claim total working prototype.

But it's not the end, keep working this way, specify whatever detailed requirements and keep the tab open for tokens, the prototype COULD turn into a real compiler.

However, the real question is:

1- That much detailed requirements, how much? It has to be as detailed as a real compiler engineer could point out, from lexer to optimization, it's almost a hand-written compiler anyway. The requirement specification, is going to be a thinking process, like a painting process for a painter, alter this and that, changes mind in between, and the thing may have a design "growing" out, instead of a recital of existing known "standard" design.

This calls for what? This calls for re-design, re-start from the middle, in between, of the whole working process.

Right, leetcode kind of thing is indeed out of need because if you can specify the algorithm and design its usage scenario clean-cut, knowing all the not-so corner cases, no "real" coding needed anymore.

But, you have to "know" from the start, or if not, you have to "redesign" in between, which could be even harder, for LLM.

2- A compiler has to be well-maintained. LLM may have that ability, by not making ANY mistake, which a clear mind, coffee powered engineer wouldn't make.

This is the same requirement for autonomous driving: yes, autonomous can be better than any single human driver, that is not what we ask for autonomous driving.

We need some kind of autonomous driving, which does NOT make mistakes that "normal" human would NOT make.

If contemplate a little bit on that requirement, one would see that's an insanely high requirement.

No need to say autonomous driving is never tired, no need to say autonomous driving covers more miles than all human combined, these are not what we ask for. We ask for mistake elimination.

Same thing for compiler: LLM can NOT make mistakes, which normal engineer would not make.

Right, it may code fast, it may make deep mistakes normal engineers also makes. But it should not make mistakes normal engineers would not make.

3- Sign-off. Compilers has to have someone sign it off. When things go wrong, someone has to be responsible.

People argue that someday, LLM will be responsible anyway. I don't see it that way. A doctor has to sign-off a surgery, a prescription, a death announcement.

People don't have to sign-off a grocery promotion web page. But for a compiler, I bet it deserve so.

If no one can keep up the coding pace, no one can sign-off.

Human engineers in this sense, becomes the bottleneck: their accumulated ability to understand the AI output is the bottleneck, given the assumption the AI stay non-malicious.

[steleman]

Writing a working C Compiler used to be a standard Homework Assignment for Undergraduate CS Students. Either in their Junior or Senior year.

Let me be a bit more precise about this Homework Assignment: it did not have to be an Optimizing Compiler. It just had to be correct, find the appropriate header files, emit an ELF, and then link the resulting executable into something that ran.

Hello, World! would have been the first test of the Homework Assignment.

So, Anthropic spent $20,000 on an Undegradudate-level Homework Assignment that would have gotten an F, because it doesn't work. Not even at a minimal level. Awesome.

If there ever was a need for proof that AI can't write minimally working, Undegraduate-level Homework, this must be it. Congratulations.

But hey, it made headlines. And the CEO of Anthropic is concerned that AI is becoming sentient:

https://www.nytimes.com/2026/02/12/opinion/artificial-intelligence-anthropic-amodei.html

[steampuker]

But it's not the end, keep working this way, specify whatever detailed requirements and keep the tab open for tokens, the prototype COULD turn into a real compiler.

@huixue As expected from a clanker, you are not just wrong, you are deceiving everyone, including yourself. This will never be a real compiler, because they did not follow the basic workflow of a real compiler, neither did they audit the output, verify it with the standard.

And look into the PRs, every single one of them creates lots of commits and changes ~100 files just to fix issues that shouldn't have happened in the first place. Gotta give it to you, you are very loyal towards those of your kind.

If you want a real compiler, prefer compilers that are made by real engineers, not this trash. And very nice of you to call them a 'bottleneck'. May your power outages be plenty.

For those who believe this project has any future (like this guy does), and that you need "a bit more tokens and it would be perfect", the article itself mentions:

"The resulting compiler has nearly reached the limits of Opus’s abilities. I tried (hard!) to fix several of the above limitations but wasn’t fully successful. New features and bugfixes frequently broke existing functionality."

(Yeah, "bugfixes" that break the entire software).

So, Anthropic spent $20,000 on an Undegradudate-level Homework Assignment that would have gotten an F, because it doesn't work. Not even at a minimal level. Awesome.

If a human being ever wrote something like this, they wouldn't just get a bad grade. The entire software engineering career would be over, and rightfully so.

Back in the day, one had to pay to get a compiler. Imagine this being a commercial product. Then, when you discover the bizzare features of it (e.g. dereferencing a struct, which is possible in CCC), and complain to the customer service, you receive;
"It sounds like you're really frustrated with the compiler experience. Let’s troubleshoot the issues you're facing. Common problems can include..."

Not surprising that it doesn't have any other purpose, aside from making headlines. Very disappointing. At least make an LLM that outputs illegal x86 instructions, it would've deserved more praise.

[lmee]

I went through "Suggestion - How to spend $20,000 without embarassment." plus the discussion thread and mapped the failing path.

Problem I see: If you happen to have another $20,000 from your users, before wasting them on 2 billion input tokens of an AI model, consider donating to much more competent projects than yours:.
Root-cause hypothesis: an auth/session state mismatch across validation steps.
Useful clue from comments: Writing a working C Compiler used to be a standard Homework Assignment for Undergraduate CS Students. Either in their Junior or Senior year. Let me be a bit more precise about this.
First patch plan: reproduce the flow with deterministic steps, inspect auth/session state transitions, patch validation around the wrong-code path, and add regression coverage for happy and failure flows.
If this aligns with maintainer expectations, I will post repro evidence first and then open the scoped patch.

[amyssnippet]

a virtual headless economy