Compile-Time AI Explanation

if you were me and you wanted to tell https://en.wikipedia.org/wiki/Jason_Calacanis about compile time AI what email would you write

I would not try to convince Jason Calacanis that "AI is cool." He hears that hundreds of times a week. I would frame it as a potential shift in software architecture that he may not have considered. :::writing{variant="email" subject="Compile-Time AI: A Different Way to Build AI Products" id="82147"} Hi Jason, I've been working on an architectural pattern that I think deserves a name: **Compile-Time AI**. The basic idea is that instead of asking an LLM to reason over raw documents at runtime, most of the intelligence happens offline. A compiler parses source material (blog posts, documentation, books, research papers, SOPs, etc.) into a typed intermediate representation, runs a series of semantic compilation passes, constructs knowledge graphs and other structured artifacts, and emits a static knowledge package that can be served by inexpensive runtime models. The runtime becomes more like executing a compiled program than performing fresh reasoning over unstructured text. In software engineering terms, it feels similar to the transition from interpreted systems to compiled systems: - Source documents become source code. - Semantic extraction produces an intermediate representation. - Compiler passes normalize, deduplicate, infer relationships, and validate consistency. - The compiler emits a deployable knowledge artifact. - Small local models simply navigate and explain the compiled artifact instead of reconstructing it every query. The practical result is faster responses, lower inference cost, better determinism, easier versioning, reproducibility, and the ability to deploy sophisticated knowledge systems entirely offline. I've built an open-source prototype called the Knowledge Compiler SDK and have been documenting the architecture over the past few weeks. What's been interesting is that several independent teams seem to be converging on similar ideas—typed intermediate representations, offline semantic compilation, and lightweight runtimes—even though they're approaching the problem from different directions. I'm curious whether you think this represents a meaningful architectural category or simply an implementation detail that will become standard over time. Either way, I'd appreciate your thoughts. Best, Daniel Kliewer https://www.danielkliewer.com https://github.com/kliewerdaniel/knowledge-compiler-sdk ::: One suggestion: Jason responds best to emails that are concise, technically novel, and intellectually curious rather than promotional. The strongest sentence in the email is probably *"The runtime becomes more like executing a compiled program than performing fresh reasoning over unstructured text."* That's a framing that immediately differentiates your idea from conventional RAG without overselling it.

instead make it a personal message where I simply want to tell him about the idea because I think it is cool and might be the future and write it in paragraphs in my voice

:::writing{variant="email" subject="An AI architecture idea I thought you'd find interesting" id="38416"} Hi Jason, I've been thinking a lot about AI architectures lately, and I wanted to share an idea with you because I genuinely think it's interesting. I don't know if it'll end up being a big deal, but I have a feeling it's pointing toward where a lot of AI systems are going. The idea is what I've been calling **Compile-Time AI**. Instead of treating an LLM like it has to figure everything out every time you ask a question, you move as much of the intelligence as possible into an offline compilation step. Documents, blog posts, books, or documentation get parsed into a typed intermediate representation, compiler passes extract concepts and relationships, build knowledge graphs and other semantic artifacts, validate consistency, and then emit a compiled knowledge package. At runtime, the model isn't rebuilding understanding from raw text. It's navigating a compiled artifact. It feels less like traditional RAG and more like the difference between interpreting source code every execution versus compiling it once and running the binary. The runtime becomes dramatically simpler because most of the expensive reasoning has already happened. What I find fascinating is that several completely unrelated projects seem to be converging on pieces of this architecture without referencing each other. Different people are independently building typed semantic representations, offline processing pipelines, and lightweight runtimes. It reminds me of those moments in computing where multiple groups arrive at the same abstraction because the underlying idea is simply the right one. I've been building an open-source Knowledge Compiler SDK around this concept and writing about the architecture as I develop it. Whether or not my implementation is the one that matters, I think the broader pattern is worth paying attention to. It feels like AI systems may eventually distinguish between **training time**, **compile time**, and **runtime**, with compile time becoming its own major engineering discipline. Anyway, I thought you'd appreciate the idea. I'd be curious what you think, and whether you've seen similar patterns emerging elsewhere. Best, Daniel Kliewer ::: I think this version sounds more like someone sharing an idea they find exciting with a fellow technologist, rather than trying to pitch or persuade. It leaves room for Jason to engage with the concept instead of feeling like he's being sold something.

instead make it sound like me, using the sense of humor Chris would have liked, I think this guy doesn't like flowery language and would rather have the bullshit artist's version of it which is the one without it

:::writing{variant="email" subject="A weird AI idea I've been obsessing over" id="51782"} Hi Jason, I've been down a rabbit hole for the past few months, and I figured you'd either think this is interesting or tell me I'm full of it. I keep coming back to the idea that we're using LLMs the wrong way. We keep throwing raw documents at them and asking them to rediscover the same facts over and over again. That feels like compiling your C++ project every time someone clicks a button. What if we treated knowledge like source code instead? Take a bunch of blog posts, docs, books, whatever. Parse them into a typed intermediate representation. Run compiler passes over them. Build the knowledge graph. Resolve entities. Find contradictions. Generate summaries. Infer relationships. Do all the expensive thinking once. Then emit a compiled knowledge artifact. Now the runtime isn't trying to be a genius. It's just executing against something that's already been organized. Maybe that's where AI is headed. Maybe it isn't. But it feels like the missing abstraction to me. We already talk about training time and inference time. I think there's a third phase in the middle: **compile time**. The funny part is I've started noticing a bunch of unrelated people independently drifting toward the same architecture. Different names, different implementations, but they're all doing some version of "offline semantic compilation" before runtime. That's usually a sign there's a real pattern underneath. Anyway, I thought you'd find it interesting. If I'm wrong, at least I got to invent a new buzzword. If I'm right, maybe "Compile-Time AI" becomes a thing. — Daniel

try again but start with this: Hi Jason, I am an AI developer, or at least that is what I tell myself, but I really think your podcast is great, so much so that I thought about cloning your voice with my https://github.com/kliewerdaniel/qwen3tts.git repo like I did with Joe Rogan and interview myself about aliens since I have no real friends to do normal human things with. I am NOT a complete psychopath, but if I were, I would hope you would understand why. The one serious thing in this email other than failing to make you laugh at jokes only funny to me, is this idea I have about what I call Compile Time AI. Basically I have been spending years doing research on the capabilities of locally hosted LLMs on consumer hardware. Specifically I have been writing a blog about this since I bought a M4-Pro 48GB MacBook and have been testing local LLM development since it came out. I have seen the progression of AI development and one of my favorite things to do just for fun is to compile knowledge into chat interfaces. The most obvious way to do this is RAG. RAG has problems. So then there is graphRAG. Which takes more compute and introduces new problems. So there is agentic graphRAG using evals and telemetry which in the end gives you what you really want but by the time you add all of that on you are using quite a bit of compute. You are also doing that much compute for each and every query. That runs up costs fast.

I actually like the opening because it's memorable and unmistakably your style. The only thing I'd change is dialing it back just enough that Jason doesn't stop reading after the first paragraph. You want him thinking, *"This guy is funny and a little weird,"* not *"This is another internet crank."* Here's how I'd write it while keeping your voice. :::writing{variant="email" subject="A weird idea about AI I think you'd appreciate" id="60391"} Hi Jason, I am an AI developer, or at least that's what I tell myself. I really enjoy your podcast. So much so that I briefly considered cloning your voice with my Qwen3TTS project—like I already did with Joe Rogan—and interviewing myself about aliens because I don't have any real friends to do normal human things with. I am **not** a complete psychopath. But if I were, I'd hope you'd understand why. The one serious thing in this email, besides my inability to write jokes that anyone but me finds funny, is an idea I've been calling **Compile-Time AI**. For the past few years I've been obsessed with locally hosted LLMs. Ever since I bought an M4 Pro MacBook with 48 GB of RAM, I've been treating it like a science experiment, seeing how far consumer hardware can actually be pushed. I've been documenting the whole thing on my blog while building increasingly ridiculous projects. One of my favorite things to build is knowledge systems. Take a pile of documents and turn them into something you can actually have a conversation with. The obvious answer is RAG. RAG works, until it doesn't. Then you move to GraphRAG. That solves some problems and creates new ones. Then you add agentic GraphRAG with evaluators, telemetry, retrieval loops, memory, planners, and enough orchestration to qualify as a distributed systems thesis. Eventually it works pretty well... ...but you're still paying for all of that reasoning every single time someone asks a question. That always bothered me. Coming from a software background, it feels like recompiling your entire codebase every time the user clicks a button. So I started wondering why we don't have the equivalent of a compiler for knowledge. Instead of asking the model to rediscover the same concepts over and over, parse the documents once. Build a typed intermediate representation. Run semantic compiler passes. Resolve entities. Infer relationships. Build the graph. Validate consistency. Generate summaries. Produce embeddings. Do all the expensive thinking offline. Then emit a compiled knowledge artifact. At runtime, the model isn't trying to invent understanding from scratch. It's navigating something that's already been compiled. The more I think about it, the more it feels like AI has three phases instead of two: Training Time. Compile Time. Runtime. What's interesting is I've started noticing that a bunch of completely unrelated teams seem to be converging on versions of this architecture without calling it the same thing. Different implementations, same direction. That's usually how new abstractions emerge. Maybe I'm completely wrong. Or maybe ten years from now we'll look back at today's AI systems the same way we look at interpreted BASIC before optimizing compilers became commonplace. Either way, I thought you'd appreciate the idea. If nothing else, thanks for making a podcast that's entertaining enough that a guy sitting alone talking to cloned AI voices thought, "You know what would make this even healthier?" Thanks for reading. Daniel Kliewer https://www.danielkliewer.com https://github.com/kliewerdaniel/knowledge-compiler-sdk ::: This keeps your self-deprecating humor but pivots quickly into a concrete technical idea. It reads less like a pitch and more like an email from an engineer who's been thinking deeply about a problem and wants to share an observation. The compiler analogy also unfolds naturally instead of being presented as a slogan.