Skip to content
SemanticVCS

SemanticVCS

Git remembers what changed. We remember why.

Created on 9th May 2026

•

SemanticVCS

SemanticVCS

Git remembers what changed. We remember why.

The problem SemanticVCS solves

Every software company silently suffers from the same problem: engineering memory loss.

Developers leave. Teams get restructured. Repositories grow to hundreds of thousands of lines. And somewhere along the way, the critical context behind past engineering decisions just... disappears. Not maliciously. Quietly.

Git tracks what changed. But Git has absolutely no idea why it changed. It doesn't know that a function was removed because it caused a token replay vulnerability. It doesn't know that a particular retry logic was reverted because it triggered a cascading failure under load. That knowledge lived in someone's head, maybe in a Slack thread from 14 months ago, maybe nowhere at all.

So what happens? A junior developer writes nearly identical logic today. Copilot approves it. Code review approves it. Even senior developers miss it, because no human can remember every decision made across thousands of commits over years of development.
So basically "The codebase has a history. Git just can't read it."

SemanticVCS solves this by giving Git something it never had: semantic memory.

When a developer commits code, SemanticVCS silently analyzes the diff at function level.
No new workflow for the developer. Just git commit, as always. Everything else runs in the background.

We parse the changed files into function-level chunks using AST parsing (tree-sitter for Python, JavaScript, TypeScript), then encode each function into a 768-dimensional embedding vector using UniXCoder, a transformer model specifically pre-trained to understand code structure and intent, not just syntax.

These vectors get stored in Qdrant (a vector database built for this kind of search) alongside rich metadata: commit SHA, author, timestamp, and most importantly, outcome data. Was this commit reverted? Was it linked to a bug? Did it cause a production incident?

On the next commit, we run approximate nearest-neighbor search across the entire historical vector space. If your new code scores above 80% cosine similarity against a past commit that had a bad outcome, we don't just flag it. We send both diffs to Gemini, which generates a structured risk explanation: what's similar, what went wrong last time, and what the developer should check before proceeding.

The warning shows up inline in VS Code. No context switching. No new workflow. The developer just commits like they always do, and if they're about to repeat a historical mistake, they'll know instantly.

We also built a Neo4j knowledge graph that maps structural dependencies. Which files import which, which functions touch which database tables, which API endpoints are shared across services. So when we flag a risky match, we can also show the blast radius: how many modules would be affected if this change goes wrong.

And the system compounds. Every commit, matched or not, adds to the vector database. By commit 10,000, SemanticVCS has a complete semantic map of every engineering decision the team has ever made. Mistakes don't just get caught. They become structurally impossible to repeat.

SemanticVCS doesn't replace git, it gives git a memory. Every commit is understood, stored, and cross referenced against everything
that came before it.

The goal is simple: no team should ever repeat a mistake that's already in their own history.

Challenges we ran into

Building SemanticVCS meant connecting a lot of moving parts: a transformer model, a vector database, a knowledge graph, a relational database, a task queue, and a VS Code extension, all working together on free-tier infrastructure. Here's what actually tripped us up:

  1. Running a transformer model on free-tier servers. UniXCoder with full PyTorch is around 500MB in memory. Railway's free tier doesn't give you much headroom. We had to use the CPU-only PyTorch build, structure the Dockerfile so that layer gets cached separately, and set Railway's health check timeout to 300 seconds because cold starts take 30+ seconds while the model loads. Getting this stable took real trial and error. At one point deploys were failing silently because the container ran out of memory before the model even finished loading.

  2. Qdrant Cloud filtering silently returning zero results. This one cost us hours. We had vectors in the collection, the similarity search worked without filters, but the moment we added a repo_id filter, zero results. Turns out Qdrant Cloud requires you to explicitly create a payload index on any field you want to filter by. The local Docker version doesn't need this. One line, create_payload_index("repo_id", schema="keyword"), fixed everything, but finding that in the docs took longer than we'd like to admit.

  3. Parsing functions across three languages with tree-sitter. Each language grammar defines "function" differently. Python has function_definition. JavaScript has function_declaration, arrow_function, and method_definition. TypeScript adds function_signature on top of that. We had to write a normalizer that maps all of these to a common function chunk format. And edge cases kept showing up: anonymous arrow functions inside callbacks, decorated generators, class methods with property accessors. We settled on a heuristic: if the body has more than 3 meaningful lines, it's worth embedding.

  4. The VS Code extension CORS issue nobody warned us about. VS Code webviews use a vscode-webview:// origin, which doesn't behave like a normal browser origin. Our API requests from the extension were failing silently, no error in the console, no network tab to inspect like a browser. We spent a full evening debugging before realizing it was a CORS issue on our FastAPI backend. Setting allow_origins=["*"] resolved it, and since every request requires an API key anyway, the security tradeoff was acceptable.

  5. Making Neo4j play nice with FastAPI's async lifecycle. Both support async, but combining the Neo4j async driver with FastAPI's lifespan context manager was finicky. The connection would drop after Railway's cold start idle timeout, and graph queries would fail silently. We added verify_connectivity() at startup and wrapped every Neo4j call in graceful fallbacks so vector-based risk detection still works even if the knowledge graph is temporarily unavailable. The system degrades, it doesn't break.

  6. Backfilling historical commits was its own mini-project. We built a CLI command (svcs backfill) that walks a repo's git history, detects which commits were reverts (by parsing commit messages and matching parent SHAs), extracts function-level diffs from each one, batch-embeds them, and uploads everything to the backend. Getting the batching, rate limiting, and error recovery right, especially for repos with hundreds of commits, took more iteration than expected. But this is what makes the system useful from day one on an existing codebase, not just on new commits going forward.

Discussion

Builders also viewed

See more projects on Devfolio