15 posts carrying this tag.
A technical note on what 'verifiable' actually means in a verifiable code IR. Not a machine that rebuilds your code from a document, but a derived contract that every change gets checked against. Here is what a single verification check consists of, why round-trip is a signal and never a promise, and the honest boundary of what it can and cannot catch.
A code graph takes a whole, coherent program and shreds it into a bag of symbols and edges. It is genuinely useful, but it is a teardown, and the meaning never survives the pieces. A verifiable intermediate representation is the opposite move. It lifts your code into a higher layer that keeps the intent intact, then checks every change against it. Here is the difference between shredding and preserving, and why it decides everything downstream.
Vector search and GraphRAG look like opposites, but they share the same final move. Parse the code, retrieve some of it, rerank it, and stuff it into the context window. That last step is where both of them rot, because a model that is handed a pile of chunks degrades the same way no matter how the pile was chosen. Here is why the retrieval layer is not the cure for context rot, and what is.
The claim that a verifiable IR beats vector search and GraphRAG only matters if the numbers hold up. So here is the run. 46 Kubernetes-ecosystem repositories, 150,000 files, 8 GB of code, measured end to end. What we tested, how we scored it, and why feeding the model 22x more context made it cheaper and more accurate at the same time.
Verifiable is the one word competitors cannot claim. A code graph extracts a shadow of your code and can never tell you whether the code still does what it is supposed to. A verifiable intermediate representation is a derived contract that every change gets checked against. Here is what verifiable actually means, why GraphRAG and vector search can only retrieve, and what continuous verification unlocks.
Your team uses Claude Code, Cursor, Copilot, and Windsurf, and each one rebuilds an understanding of your codebase from scratch and shares nothing with the others. MCP is the standard that lets you stop doing that. Compile your repos once into a verifiable IR and serve it to every tool over one MCP endpoint. Here is why the context layer belongs outside the tool, and what changes when it does.
The objection to compiling a codebase into a verifiable IR is always cost. It sounds like Opus pricing across every file. It isn't. At open-source-model rates it runs about $13.30 per 1,000 files, you pay it once, and per-file diffing means you only ever re-pay for what changed. Here is the real economics of the verifiable context layer, and why the expensive thing is not building the IR but living without one.
Every tool that feeds your codebase to an AI coding agent picks one of four representations. AST parsing, vector embeddings, code graphs, or a verifiable intermediate representation. Here is what each one keeps, what each one throws away, and why the first three are features of the fourth.
Specs and code drift apart the day after you write the PRD, because they are two separate documents that nobody keeps in sync. A verifiable context layer derives the spec a codebase actually implements and then continuously checks the code against it. Here is how spec-driven development works on a brownfield codebase, and why it needs a verifiable code IR that checks code against intent.
Context graph is a term people understand and reach for. But most things called a context graph are one-way extractions you can read and never check anything against. The version worth wanting is the one you can verify code against, and that single requirement is what separates an index from a verifiable code IR. Here is what verification demands, and why it is the only honest test of a context graph.
Code graph RAG fixed the biggest flaw in vector search. It follows real edges instead of guessing at similarity. But a graph of symbols is still not a graph of meaning, and it cannot tell you whether a change still does what the system is supposed to do. Here is how code graph RAG actually works, where it stops, and why a verifiable intermediate representation is the layer above it.
Semantic code search keeps getting better at finding the right code, and it keeps disappointing teams who expected better answers from their AI tools. The reason is that those are two different problems. Finding code is retrieval. Understanding code is representation. Better retrieval over a poor representation has a ceiling, and here is why a verifiable code IR raises it.
GraphRAG for codebases is a genuine step up from vector search. It follows real call edges instead of guessing at similarity, and it wins on architectural questions. But it breaks in three predictable places: cross-repo links that aren't call edges, the why behind the code, and anything that needs intent you can check changes against. Here is a clear-eyed map of what graph RAG for codebases solves, where it stops, and the verifiable context layer that sits above it.
Everyone building code intelligence ends up at a graph, and then they start calling it a context graph because plain code graph stopped feeling like enough. But adding the word context does not add meaning. A graph of symbols and a graph of meaning are different objects. Here is the line between them, and why crossing it requires a verifiable code IR, not more edges.
Vector embeddings treat code like english prose. AST parsers see structure but not meaning. Raw LLMs forget everything every session. Here is why the LLM compiler pattern with a persistent semantic graph is the only approach that actually works for cross-repository code intelligence, and why open source models at $7 per 1000 files make it practical today.
