The data on AI-generated code is in, and it's naming something a lot of teams have been feeling quietly: – 81% of enterprise leaders report more production incidents tied to AI-generated code. – 43% of AI-generated changes still need manual debugging in production — after passing QA and staging. – 0% of engineering leaders say they're "very confident" the code will behave correctly once deployed. Right now the industry seems split between two responses: add more AI agents to review the output, or add more human gates to catch it. Both feel, to me, like patches on the same gap. My own bias: this is an architecture problem, not a model problem — and architecture problems don't get solved by adding more intelligence on top. But I'm genuinely curious how it looks from inside other teams. So, honest question for anyone running this in production: Where's the line for you between "fast enough to ship" and "safe enough to trust" — and who actually gets to decide it on your team?

Linus Torvalds got visibly angry on a keynote stage recently. People were boasting that AI wrote 99% of their code. His answer cut deeper than the room probably realized: 100% of your code is already written by a compiler — and nobody ever brags about that. He's right. And I think it points somewhere bigger than he took it. Software has always been a ladder of compilers. Machine code. Then assembly, compiled down. Then C, compiled down to assembly. Then everything we write today, sitting on top of all of it. Every rung is the same move — a human expresses intent one level higher, and a deterministic compiler translates it down. Same input, same output. Every time. We climbed that ladder for sixty years. And not once did anyone say "that's not a real compiler" when a new rung appeared. It just worked one level higher. So here's the question Linus's comment opens but doesn't close: when an LLM generates a system, where is it standing on that ladder? It's standing where the human used to stand. Expressing intent. Which means a rung just opened up beneath it — a compiler that works one level of abstraction higher than anything before it. From a typed, inspectable representation of a system, down to real code, tests, and infrastructure. I tried the other way first. For months — getting LLMs to generate production systems directly. The output was architecturally incoherent. Riddled with security holes. And worst of all, non-deterministic: the same spec produced different code on every run. Nothing to validate against, no ground truth. That's not a model problem. It's a missing rung. So I spent three years building it. And the part that makes it a compiler — not "AI writing code" — is the part you can verify: below the line, zero model calls. Same representation in, same system out, byte for byte, with provenance you can hand to an auditor. Linus is right. Determinism lives in the compiler, not the model. I'm just saying the next compiler is already here — it compiles one level above where you're looking. Foundation models scale intelligence. Compilers scale trust. That's the bet behind DevMatrix. → devmatrix.dev

Check out my latest article: The Real Lesson Behind Anthropic’s C Compiler People misunderstood Anthropic’s “Claude built a C compiler” story. The interesting part isn’t that an LLM can write compiler code. It’s what it took to make that output trustworthy. linkedin.com/pulse/real-less… via @LinkedIn

AI didn’t make software engineering easier. It exposed that we were relying on human judgment where we should have been encoding guarantees. As systems become stochastic, the missing abstraction isn’t better prompts — it’s compilation, invariants, and verification around them. That’s the layer we’re all implicitly searching for.

Most of what we call “AI software generation” today is just very good text generation. That’s not a criticism. It’s an observation. But software is not text. And treating it as such has consequences. More on this soon.....

We keep treating AI-generated software as text. Software isn’t text. It’s a system with invariants, contracts, and consequences. When you skip the compilation layer, hallucinations aren’t a bug. They’re the expected outcome.