# Every Repo Is a World Model

> Source: <https://dev.to/vystartasv/every-repo-is-a-world-model-97c>
> Published: 2026-07-09 20:23:27+00:00

**Part 1 — Mining lifecycle patterns from git history**

⚡ TLDR

What:A CLI tool (`hermes-harness`

) that mines git history for recurring failure/fix patterns and makes them searchable across repos. "Has this failure happened before?" → answer in milliseconds.

How:Reads full git history → extracts reverts, file coupling, topic clusters → compresses each pattern into a 128-dim vector → cosine similarity search. No AI at query time.

Who it's for:Tech leads and platform engineers managing 3+ repos who've said "we fixed this last quarter" and couldn't find the ticket.

Try it:`npm install -g hermes-harness && hermes-harness seed-query "your error"`

Contribute:github.com/vystartasv/hermes-harness

**This tool is useful in exactly one scenario: you have multiple repos that share failure patterns, and you can't keep track of them in your head.**

That's it. If you're a solo dev with one repo, your memory is enough. If you never revisit old tickets, the hints are noise. If every bug is novel with no precedent, you won't find matches.

The shape of a team that needs this:

The tool doesn't predict novel failures. It connects the dots between the ones you've already seen and fixed.

A few years ago, Yann LeCun published * A Path Towards Autonomous Machine Intelligence*. The core idea: an intelligent system doesn't need to model every pixel of the world. It needs a

Most people read that paper and thought about self-driving cars.

I read it and thought about git log.

Every project I've worked on has the same memory problem. You fix a bug, close the ticket, move on. Three months later, the same class of failure hits a different repo — different stack, different team, same root cause. Nobody connects them because nobody searches across repos for *lifecycle patterns*.

We have code search (Sourcegraph, GitHub Code Search). We have error tracking (Sentry, Datadog). We have observability (Grafana, Honeycomb).

We don't have **history search** — the ability to ask "has this failure pattern happened before?" and get answers from every repo, every ticket, every commit across your entire organization.

LeCun's Joint Embedding Predictive Architecture compresses high-dimensional observations into a latent space where prediction happens. Pattern → vector. Predict in vector space. Flag when prediction doesn't match reality.

A git repository isn't code. It's a **history of state changes** — commits, reverts, file co-changes, ticket reopens. Every revert is "we tried X and it didn't work." Every reopened ticket is "the first fix was incomplete." Every pair of files that always change together is "these are coupled."

That's a world model. It's already there. It just needs to be compressed and made searchable.

[ hermes-harness](https://github.com/vystartasv/hermes-harness) mines git history for lifecycle patterns and compresses them into a searchable world model.

```
npm install -g hermes-harness

# Query across 11 pre-indexed public OSS repos
hermes-harness seed-query "dependency version conflict"
# → 48% match: "Playwright version roll" (playwright-go)
# → 28% match: "dependency bumps and fixes" (chatbot-ui)

# Mine your own repos
hermes-harness mine-git
```

The extraction pipeline:

No AI at query time. Once trained, the entire model fits in 200KB and runs on a $5 VPS.

I ran it against 11 public repos: LangChain, Next.js, Svelte, Vite, Supabase, n8n, Biome, and others. 21 patterns surfaced from ~2,200 commits.

The seed is sparse. That's the point. It's a demonstration that the mechanism works — not a finished product. The model needs data.

The conceptual foundation comes from **Yann LeCun's** work on world models and the JEPA architecture:

The implementation is trivial by comparison. I just replaced neural embeddings with word-count vectors and pixels with git commits. The insight isn't the code — it's that every repo already contains a world model. The code just extracts it.

The world model gets better every time someone runs the harvester against a repo they care about. If this concept fits your narrow band:

`hermes-harness seed-harvest`

`hermes-harness seed-export`

and open a PRThe architecture is designed for contribution: one JSON file per world, a shared vocabulary, cross-repo search that doesn't care where the patterns came from.

This is **Part 1** of a series on world models built from everyday data:

*Package: *

`npm i -g hermes-harness`