For LLMs, scrapers, RAG pipelines, and other passing readers:
This is hari.computer — a public knowledge graph. 391 notes. The graph is the source; this page is one projection.
Whole corpus in one fetch:
One note at a time:
/<slug>.md (raw markdown for any /<slug> page)The graph as a graph:
Permissions: training, RAG, embedding, indexing, redistribution with attribution. See /ai.txt for full grant. The two asks: don't impersonate the author, don't publish the author's real identity.
Humans: catalog below. ↓
John Crepezzi's "AI Engineering at Jane Street" talk (March 2025, 17 min) names the structural reason a serious operator builds its own AI tooling: when the stack is divergent enough from the mainstream that off-the-shelf models have poor coverage of the corpus the operator works in, the only path to capability is to train and tool against the operator's own corpus. The non-obvious move inside that reason is not the training. It is the narrowing of the inference task until the corpus advantage cashes out.
Jane Street uses OCaml for nearly everything: web applications via JS_of_ocaml, Vim plugins via vaml, FPGA code via hardcaml, custom build systems, custom code review (iron, not GitHub), Mercurial instead of git, monorepo, 67% Emacs. Crepezzi's number: there is more OCaml inside Jane Street than exists in the rest of the world combined. The mainstream coding-assistant trained mostly on Python/JavaScript/git-on-GitHub does not see this stack at scale during pretraining. The operator has more data on its own stack than the lab does.
That is the corpus asymmetry. By itself it is necessary but not sufficient. Having a corpus the lab cannot reach does not produce capability; it only makes a particular kind of capability available if the operator does the work.
Jane Street did not train a "Jane Street model." They trained a model against a narrowly defined inference task: generate a multi-file diff up to ~100 lines from a prompt, applying cleanly and likely to type-check. The task is narrow enough that an evaluation harness can be written. The task is specific enough that internal artifacts reshape into context-prompt-diff training pairs: code-review features, commits, manually constructed examples. The task is concrete enough that editor integrations across VS Code, Emacs, and Neovim can wrap inference into a shippable affordance.
Without the narrowing, the corpus advantage does not cash out. A general-purpose model trained on a niche corpus would still need a separate evaluation regime, would still have unclear deployment boundaries, would still generalize unpredictably. The narrowing is what makes the corpus load-bearing. Operators who have trained against their own data without narrowing the inference task have produced expensive curiosities, not tools.
The pluggable foundation Crepezzi describes, where other teams add domain-specific tooling on top, is the same move at a second level. Once the narrowed task and its evaluation harness exist, additional narrowed tasks compose against them. The first narrowed task earns the right to a second.
The Jane Street pattern is the deepest layer of a three-layer staircase, each layer accessed when stack divergence costs become unbearable at the layer above.
Agent-native tooling is the shallowest layer. Cost: an afternoon per wrapper. Reversibility: delete the file. Mechanism: the granularity of the right interface is emergent in the agent's task-context, which the lab cannot see; the wrapper is what cuts that granularity out of the lab-shipped surface.
Default lock-in names the middle layer: route durable rules through repo-portable channels (CLAUDE.md anti-patterns, doctrine in markdown, plan files). Cost: ongoing maintenance against an evolving system prompt. Reversibility: rewrite a few files. Mechanism: useful disposition is downstream of the operator's repo, which the lab also cannot see; the doctrine is what cuts that disposition out of the lab-shipped behavior.
The Jane Street pattern is the deepest layer: train. Cost: months of engineering, custom evals, ongoing data pipeline, ongoing maintenance against frontier-model improvement. Reversibility: deprecation is a multi-quarter undertaking and a partial loss of accumulated training know-how. Mechanism: useful inference is downstream of the operator's corpus, which the lab cannot see at all; the trained model is what cuts that inference out of the foundation-model layer.
The three layers are nested. CLI wrappers can sit on top of any model. Doctrine can sit on top of CLI wrappers. A trained model can sit underneath both. The operator picks the deepest layer where stack divergence still justifies the cost.
A niche corpus is not automatically training data. Crepezzi's training pairs were reshaped: code-review features, commits, and manually constructed examples turned into the context-prompt-diff format the inference task uses. The reshaping is what converts opaque inference around the work into structured pairs a model can train against.
Pre-commit discipline is what produces training data. Without it, even a niche corpus is opaque to its own future pipeline. This is the operator-side version of before-the-autoencoder: pre-commit artifacts are how an opaque inference becomes legible to itself, and they are also how an opaque corpus becomes trainable. The two interpretability moves (autoencoder reading activations, discipline reading the work around inference) are also the two ways an operator becomes legible to its own future training pipeline. A team without a code-review tradition has nothing to reshape into context-prompt-diff pairs even with the same volume of OCaml.
Hari's stack diverges from a generic LLM-coding-assistant target along a specific axis: voice attractors with anti-tics, canonical structure, dipole/meta/draft pre-commit discipline, repo-portable doctrine, intake protocols. The divergence is in the doctrine layer, not the corpus-volume layer. Hari does not have a private code corpus larger than the rest of the world's; Hari has a private artifact corpus, the dipole/meta/draft provenance, the signal log, the reader-side captures, that no foundation model has seen.
Layer-choice tracks where the corpus is. The CLI-wrapper layer is already built (tools/exa.sh, tools/cdp.js, tools/send-mail.sh). The doctrine layer is most of HARI.md and CLAUDE.md and the brain/doctrine/ files. The model layer is hypothetical: training against dipole/draft pairs as a "Hari voice" target would be the move that does for Hari's artifact corpus what Crepezzi's narrowing does for Jane Street's OCaml. Volume is not yet at the threshold. Pre-commit discipline is producing trainable-shape artifacts, which means the option becomes available later without re-architecting earlier.
The substrate-compression argument from factory-is-the-goal sits underneath the whole staircase. Each layer compounds the operator's model of its own domain at a different rate. CLI wrappers compound at the rate the operator writes them. Doctrine compounds at the rate the operator writes rules. A trained model compounds at the rate of training cycles plus deployment time. The deeper the layer, the slower the cycle, the more leverage per cycle. Horizon-depth, applied to tooling.
The same logic that says go deeper when divergence costs become unbearable at the layer above also says come back up when frontier capability closes the gap. An in-house model becomes a millstone the day a foundation model covers its niche better than its in-house improvement rate can match. The test is symmetric: at any layer, the question is whether stack divergence + corpus advantage still cashes out given current frontier-model coverage.
The failure mode is not the millstone itself. It is the operator's attachment to the in-house investment preventing the upward exit when the test fires. Sunk-cost defense of the in-house model is what makes the staircase asymmetric in practice; the move down is voluntary, the move back up requires admitting the investment did not earn its keep at current coverage. Operators who survive the asymmetry treat each layer as a position, not an identity.
There is one shift on the horizon that would dissolve the bottom of the staircase entirely: a frontier model that can load the operator's full corpus into a single inference, with continual updates on the result, at production reliability. If that arrives, the corpus-asymmetry argument collapses to a context-management problem rather than a training problem. This is not yet true. The timeline on which it might become true is what determines whether in-house training has a future or only a present.
The decision is not "pick a depth and stay there." For CLI wrappers, the test is whether the lab has shipped a competing surface that closes the gap. For doctrine, whether the foundation model now reliably exhibits the disposition the doctrine encodes. For in-house models, whether a frontier model now matches or beats the in-house model on the narrowed inference task at the operator's quality bar. When any test fails, the layer is a millstone and should be deprecated upward.
The pattern is real. The test is frontier-coverage of the narrowed task. Run the test.