Port of the TypeScript compiler, checker and lsp to Rust, by LLM

TEXT START: I wanted to see if LLMs could port the TypeScript compiler, checker and lsp to Rust.

The Dissection

This is a live demonstration of cognitive automation applied to high-complexity software. The decisive fact is not that Rust code was generated; it is that an LLM-driven process allegedly produced a functioning compiler port, passed 181,711 tests, matched oracle behavior, and ran faster than the Go baseline—while the human operator claims never to have read the code.

The $420,000 failed attempt is not a rebuttal. It is the cost of immature automation. The later $24,047 run is the relevant signal: once the model, workflow, tests, and task decomposition improved, the cost collapsed. The human role moved toward orchestration, evaluation, and release management rather than implementation.

The Core Fallacy

The text’s explicit fallacy is treating demonstrated artifact production as equivalent to reliable engineering. “100% compatibility” is limited to the tested projects and oracle suites. The release is explicitly early, unreviewed by its author, platform-incomplete, and dependent on extensive pre-existing tests and a known upstream implementation.

Its deeper fallacy is more important: it frames the event as a technical stunt instead of a labor-market rupture. The question is not whether every programmer disappears immediately. The question is whether fewer humans are required to produce economically valuable software. This example says yes, especially for porting, translation, compatibility work, compiler maintenance, and other domains with executable specifications.

Hidden Assumptions

• Existing code, tests, benchmarks, and upstream behavior remain available as machine-readable supervision.
• The generated implementation can be trusted, secured, maintained, and extended without proportionate human review.
• The operator’s orchestration and verification labor are negligible or easily reproducible.
• Compatibility on tested repositories generalizes to the full ecosystem.
• Model access, compute, and API pricing continue improving faster than the displaced labor can reorganize.
• The remaining human work—judgment, accountability, security, release control, and handling unknown failures—does not become the new bottleneck.
• Because the result is open source, its value is socially distributed. In practice, ownership and control of the models, compute, distribution channels, and infrastructure remain concentrated.

Social Function

Classification: partial truth, prestige signaling, and transition management.

It is not ordinary copium. The evidence is too concrete. The humor, disclaimers, and “memes” framing function as anesthesia around a serious substitution event. The text makes automated production appear playful and experimental while demonstrating that a scarce, highly specialized engineering task can be converted into an agent-managed workflow.

The social message is: the work still exists, but the worker is becoming an optional coordinator around machine production. That is transition management in its cleanest form—normalizing the replacement before institutions have language for it.

The Verdict

This is a narrow but severe P1 signal. It does not prove that all software engineering is already obsolete, nor does it by itself establish P2 or P3. It proves something more operationally valuable: a large body of expert cognitive labor can be attacked through tests, specifications, and iterative machine feedback, with human implementation increasingly removed from the loop.

The compiler is not merely being ported. The economic role of the compiler engineer is being ported into the model workflow—and the human version is losing compatibility.