# RAG Is Runtime Knowledge, Skills Are Compiled Knowledge > Source: > Published: 2026-07-08 21:19:08+00:00 Somewhere in your company's AI strategy deck is a slide that says "We implemented RAG over our internal knowledge base," and it's presented as an arrival, a line item you can check off and move past. It's not a destination. It's a rung, and a low one. ## RAG enters at Level 2, not the finish line[#](#rag-enters-at-level-2-not-the-finish-line) Mistaking it for the finish line is the single most over-claimed maturity signal in the enterprise. The [previous posts in this series](/amm-3-diagonal-law) put trust location on two axes: capability and verification. There's a third track running underneath both, knowledge, and it has its own ladder. Retrieval-augmented generation shows up early on that ladder, at Level 2, right alongside the copilots and the review dashboards that make an organization feel mature while its actual verification stays exactly where it was before AI arrived. The knowledge ladder, in full: **None (L0).** No sanctioned knowledge layer at all.**Personal context-pasting (L1).** Whatever an individual happens to paste into a chat window that session. Gone when the tab closes.**RAG over the organizational corpus (L2).**"Chat with our docs." Genuinely useful, genuinely necessary, and the point where most enterprise knowledge strategy stops.**Agentic retrieval plus a curated skill library (L3).** Retrieval becomes one tool among several an agent chooses to invoke, its quality measured rather than assumed, living alongside deliberate context engineering and a skill library someone actually curates.**The distillation loop (L4).** Stable knowledge migrates continuously out of retrieval and into skills, and RAG gets scoped down to what genuinely changes faster than that migration can keep up. The organizing idea for the whole track fits in one line: RAG is runtime knowledge. Skills are compiled knowledge. Distillation is the compiler. ## Compiled doesn't mean deterministic[#](#compiled-doesnt-mean-deterministic) Let us push on the compiler metaphor for a second, because it buys you less than it sounds like it does, and the gap matters. Compiling knowledge into a skill gets you repeatable *packaging*: a versioned, shared, reviewable artifact that bundles procedure, context, and constraints, cheaper to invoke than a retrieval call and legible to a human who wants to audit what the agent was told. What it does not get you is deterministic execution. A skill still runs on a non-deterministic model. Two agents loading the identical skill file can still produce different output, because the compiler here compiles the instructions, not the interpreter that reads them. That's why skills need version-pinned evaluation, the same discipline code needs tests, not a one-time authoring pass followed by faith. I built [a whole package to track this for my own skill collection](https://voodootikigod.com/your-agents-knowledge-has-a-shelf-life/?ref=voodootikigod.com). A skill nobody re-verifies is a skill quietly voting against itself. ## The maturity signal is migration, not corpus size[#](#the-maturity-signal-is-migration-not-corpus-size) Here's where a lot of enterprise knowledge strategy gets the measurement backwards. A growing retrieval corpus is not, by itself, evidence of anything. A legitimately growing business legitimately grows its corpus: new products, new regions, new tickets. Corpus size is not the tell. The real signal is migration. Stable, procedural knowledge, the stuff that gets asked the same way every time, should be leaving retrieval and landing in the skill library, continuously. An organization whose retrieval corpus keeps absorbing procedures that never compile into anything is hoarding, not learning. It's the knowledge-track equivalent of a wiki nobody prunes: technically searchable, actually a landfill. ## M4, the RAG Plateau (knowledge track stuck at stage 2, claimed as stage 4)[#](#m4-the-rag-plateau-knowledge-track-stuck-at-stage-2-claimed-as-stage-4) "We implemented RAG" gets presented as an AI strategy on its own, full stop. It's runtime retrieval hoarding wearing the costume of a finished capability, with no compilation into skills happening underneath it. The organization can genuinely answer more questions than it could a year ago and still be exactly as immature as it was before, because nothing it learned got compiled into anything durable. Every answer is re-derived, at retrieval cost, forever. The fix isn't ripping out RAG. It's the same discipline I described for [an individual codebase's skill mining loop](https://voodootikigod.com/skill-mining/?ref=voodootikigod.com): survey what keeps getting asked and answered the same way, and migrate the stable patterns into versioned skills instead of leaving them to be re-fetched on every request. RAG doesn't disappear at Level 4. It gets scoped down to what actually deserves runtime lookup: today's document, this week's ticket, the state of a system right now. Everything with a stable answer moves out. ## M7, Skill Rot (knowledge stage 3 without observability stage 4)[#](#m7-skill-rot-knowledge-stage-3-without-observability-stage-4) The opposite failure looks more mature and is arguably worse, because it comes *after* an organization did the hard part. A skill library gets authored, once, in a burst of real enthusiasm. Nobody re-mines it. Nobody versions it against the products it describes. It quietly decays into misinformation delivered with the full authority of an approved, sanctioned artifact, which is exactly the property that made it valuable in the first place. I've watched this happen to my own work at Vercel scale: twenty-two products, each shipping on its own cadence, fifty-seven skill files that don't update themselves. A skill that says `npm install @vercel/workflow` months after the package was renamed to `workflow` doesn't fail loudly. It fails quietly, sending a developer down a path that used to be right, and the fix is the same category of discipline code has had for a decade: a registry of what each skill claims to know, a checker that compares claims against what's actually shipping, and a `product-version` field that makes staleness visible instead of silent. [The full shape of that fix is here](https://voodootikigod.com/your-agents-knowledge-has-a-shelf-life/?ref=voodootikigod.com), and the pattern generalizes past any one company's products. Skill Rot is a knowledge-track trap, not a capability or verification one, which is why it doesn't show up as a cell on the [Diagonal Law's grid](/amm-3-diagonal-law). It lives one layer under the grid, in whether the compiled knowledge that grid's Level 3 and Level 4 quietly assume is actually still true. ## Knowledge needs a witness[#](#knowledge-needs-a-witness) Neither of these traps are caught by asking "do we have RAG" or "do we have skills." Both answers can be yes while the organization is actively decaying. What catches them is the same thing that catches every trap in this model: a specific, checkable fact, not a survey answer. Whether stable knowledge is actually migrating out of retrieval. Whether skills are actually being re-verified against what they claim. That fact doesn't produce itself. It's an observability question: what an organization can see about its own knowledge layer, and whether it's recording the kind of evidence that migration and rot both require to be caught early instead of discovered in production. That's the next track, and the next post.