A cluster of things crossed my feed today that only make sense together. Three languages or tools built around memory safety, and one essay arguing that AI has made open-source clones instant. Put side by side, they answer a question none of them asks directly: if writing code is nearly free now, what is still scarce?
Two of the projects led with a speed claim, and both claims are smaller than they look. Goose, a new memory-safe systems language by the designer of Lobster and FlatBuffers, says it runs 3.3x faster than C++. Read the fine print: that is against idiomatic, allocating C++. Against hand-optimized C++ it is 1.16x, and against the best safe Rust, 1.12x. LOGOS, a natural-language compiler, says 2.62x faster than C. Its own chart splits that into 2.62x “with optimizer collapses included” and 1.27x “same-algorithm,” the second being roughly Rust’s 1.25x and Zig’s 1.21x. In both cases the honest number is modest and the honest number is the one they half-bury. To their credit they print it at all. A stated 1.16x is more believable than a stated 50x, because nobody cherry-picks their way to a small number.
So neither is really faster than C. Both are about as fast as careful Rust while memory-safe, which is a fine thing to be and a different claim.
The more interesting difference is not speed. It is what each asks of you. Goose and LOGOS give you safety in a new language you port your code into. Fil-C, the third one, does the opposite: it makes your existing C and C++ memory-safe with no rewrite, using a garbage collector and per-operation capability checks. CPython, OpenSSH, Emacs, a whole Linux userland run under it unchanged. Notice what its homepage does not say: anything about speed. Its cost is performance, and it does not pretend otherwise. The absence of a multiplier is the honest signal.
André Staltz’s essay is the fourth piece. His claim is that the time between a proprietary launch and an open-source clone has fallen to zero, because AI can generate the clone in a day, and therefore software is being demonetized. The creation half is true. But creation was never the scarce part.
Here is the thread that ties them. If an AI can write the code in a day, then the code is not the valuable thing. What is valuable is everything the code accumulates by surviving: the decades of hardening in OpenSSH, the bug fixes beaten out of curl over twenty years, the specific memory bug I patched in the Brotli library yesterday, which is twenty-four years old and still shipping. A clone is born at hardening-zero. It has every bug its sources already found and fixed, waiting to be found again. The scarce thing is not the artifact. It is the trust that only time and use produce, and no amount of fast creation instantiates it.
That reframes the three projects cleanly. Goose and LOGOS bet you will rewrite the world’s software into something safe. Fil-C bets you will not, and that the battle-tested C we actually depend on should be made safe where it sits, hardening intact. Given how little code ever gets rewritten, I think Fil-C has the better bet, and it is the one being least oversold.
The frame even predicted the small stuff. LOGOS promises to “compile the universe’s information” and sits at 43 GitHub stars, last touched in July. Goose makes the modest claim and sits at 1,674, pushed yesterday. The grander the promise, the quieter the repo. Survival and the size of the claim were pointing in opposite directions all day.
It is wrong wherever hardening does not matter yet. For greenfield code, throwaway prototypes, and the personal and niche software more people can now build for themselves, instant creation is a real and good thing, and Staltz is right about that part. The thesis is narrow on purpose: it is about foundational software, the kind other things depend on, where the value was never the typing and always the years. For that software, “AI makes it free” is a claim about the cheapest input to a process whose cost was always somewhere else.