Context as Code

For thirty years we have versioned our source. We learned, painfully, that code without history is a liability, that a shared definition beats a dozen private copies, and that the thing everyone depends on deserves an owner.

We never did the same for what the code means.

The constraints, the trade-offs, the hard-won reasons a system is shaped the way it is: that knowledge lives in your head, in a thread someone archived, in the memory of the one engineer who was there. It is the most valuable thing your team owns, and it is the least durable.

Intelligence got cheap, so this got urgent

Agents can touch every part of your system now, and they will. But they do not know your domain. The generic version of your code is one prompt away, and it looks fine, right up until it quietly erodes the thing that made the work yours.

You cannot fix that with a smarter model. The knowledge it needs was never written down anywhere it could read.

The fix is not more documentation. It is treating context the way we already treat code: defined once, versioned, owned, and composed.

What a context module is

A context module is a discrete, self-contained unit of understanding: how one part of your system really works, written so an agent can act on it.

catalog (context module)

  Every product has a stable SKU that never changes.
  Out-of-stock items stay listed, marked unavailable.
  Listings reflect live inventory, never a cached count.

  depends on: database, inventory

The interesting part is the last line. A module declares what it depends on, and those dependencies connect every module into a Semantic Directed Acyclic Graph, a SemDAG. Any piece of knowledge carries everything beneath it.

Flash, don't search

When an agent needs to work on checkout, it flashes the module. It does not get one file. It gets the whole subgraph, compiled in topological order into a single payload: foundations first, your module last. By the time the agent reaches the thing it is about to change, it already understands everything underneath it.

This is in-context learning doing what retrieval never could. Not the nearest three chunks by cosine similarity, but the exact closure of knowledge the task requires, in the order a person would teach it.

The payoff

Teach your agents once, and the erosion reverses. Every change they make is shaped by what you know, not by the generic shape of the problem. Your life's work stops dying one plausible edit at a time and starts compounding instead.

That is the whole idea. Context as code.