The future of software is AI‑native.
Understanding the past is
how you build it.
Promin builds the missing layer between what your software is supposed to do and what it actually does — a knowledge graph that both engineers and AI agents can read.
You automated the doing.
Nobody automated the understanding.
The gap between documented intent and actual implementation is where bugs, rework, and wasted effort live. Modern stacks have four disconnected layers — and none of them talk to each other.
Jama, DOORS, PRDs — they record what you wanted. Then the doc rots while the code moves on without it.
Copilot, Cursor, Devin — they write code fast. But they have no idea what the code is for or what it might break.
Tests confirm behaviour. They can't tell you whether that behaviour should exist at all.
Amplitude, Mixpanel, PostHog — they show what happened. Not what was supposed to happen.
A queryable directed graph that connects requirements to code to tests to data. Discovers contradictions, traces impact, and finds orphaned goals — automatically.
Every new capability is matched against the existing graph. Promin surfaces overlap, missing goals, and confidence gaps before a single line is written.
Bidirectional mapping between features and code. When they diverge, Promin flags the drift with affected features, severity, and suggested resolution.
The Conductor monitors every codebase change, checks it against the knowledge graph, and surfaces divergences. Autonomous system oversight without manual dashboard checking.
From AI‑assisted
to AI‑native.
AI-assisted development keeps humans as the relay between intent and code. AI-native development puts structured intent at the centre — and lets agents execute from it.
- Requirements written, then forgotten
- Developer translates intent to code
- AI autocompletes without context
- Tests verify what, not why
- Drift discovered in production
- Requirements live in a graph
- Agents execute from readable intent
- Every change checked for coherence
- Drift flagged before it ships
- Developers govern, not translate
Your code says what.
Promin finds why.
An archaeology layer for your codebase. Promin Analyse ingests your git history and surfaces why code exists — so engineers and AI agents stop breaking things they don't understand.
- Method signatures & structure
- Test assertions & coverage
- Call graphs & dependencies
- Git blame & file history
- Runtime behaviour
- Original design intent
- The constraint this enforces
- What would break if removed
- The decision that was rejected
- The author who understood it
Archaeology findings,
delivered automatically.
Every time Promin ingests a commit, it runs the signal engine. These are the patterns it looks for.
Tests with no matching source code. The code they guarded was deleted or moved, but the tests stayed behind — asserting things about ghosts.
A feature has evolved away from its original commit rationale. The code says one thing, the history says another. The gap is where bugs hide.
High-confidence feature, zero explanatory context anywhere in the history. Someone knew. Now nobody does.
Dormant feature, no recent activity, no external references, no tests. Probably dead — but verify before deleting.
Two modules that co-evolve in 70%+ of commits but have no documented relationship. Hidden debt with blast radius nobody has mapped.
An explicit decision from history no longer matches the current implementation. The constraint was forgotten. The code moved on without it.
One person wrote 80%+ of a feature's commits. If they leave, nobody else understands the code. Knowledge concentrated in a single head.
Heavily mutated code with no documented rationale. Changed dozens of times, nobody wrote down why. The most dangerous code in your repo.
Test file untouched for months while the code it covers kept changing. The assertions are frozen in time — probably testing yesterday's behaviour.
An explicit architectural decision exists but no test verifies it holds. The constraint lives only in a commit message — one refactor away from gone.
Test files that don't map to any source file. Might be integration tests, might be leftovers from a deleted module. Worth investigating either way.
MCP tools.
One archaeology layer.
Promin runs as an MCP server. Your agent, your IDE, your CI pipeline — all query the same archaeology layer.
A single 0–1 scalar measuring how legible your codebase's intent is — to humans and agents alike. Not code quality. Not smells. How well is the why preserved?
Interactive knowledge map, commit timeline, signal browser, and full audit view. Six pages, one command, zero configuration.
Get early access
to Promin.
Bring a repo, get an archaeology report. We're onboarding early users now.