promin.dev / deck
01 / 09
↑ ↓ to navigate
Promin · Pitch · 2026

Software archaeology
for AI‑native teams.

Understanding why code exists is how you stop breaking it.

01 — The shift

AI is rewriting the rules of software.

But the tools devs rely on haven't caught up.

AI writes code faster than ever
Copilot, Cursor, Devin — velocity is no longer the constraint.
But agents have no context
They see what code does. Not why it exists, or what it would break.
Teams are flying blind
More code, more churn, less understanding of the whole.
02 — The cost

Developers are burning out.

Not from shipping — from reviewing code they don't fully understand.

  • Reviewing PRs for code that duplicates something that already exists
  • Asking "why does this exist?" with no-one left who knows
  • Merging a feature that quietly conflicts with another
  • Fixing a bug — then discovering it broke a constraint nobody documented
42%
of engineering time is spent understanding existing code, not building new things. — Xin et al., IEEE TSE 2017
03 — The gap

The gap nobody owns.

Every team has four disconnected layers. None of them talk to each other.

Requirements
Written, then forgotten
Code
Executes without context
Tests
Verify what, not why
Analytics
Rearview metrics only
///This gap is where bugs live. Where rework hides. Where intent goes to die.
04 — Manifesto

This should not
be this way.

Software teams have more AI horsepower than ever — and less shared understanding of their own systems.

The problem isn't the code. It's that the why is invisible to both engineers and AI agents.

05 — The shift

Imagine a different future.

Developers move up one abstraction level — from how to what and why.

Today
AI-Native
Dev translates requirements into code
Devs define constraints & intent
AI autocompletes without intent
Agents execute from readable goals
Review = reading code line by line
Review = coherence, not line-by-line
Why discovered during outages
Why is preserved, versioned, queryable
06 — The model

Work on what and why.
Let agents handle how.

Business logic constraints that flow into code — not the other way around.

Feature
  └── implements ──→ Implementation
  └── constrains ──→ Constraint ──→ verifies ──→ Implementation
07 — Product

Introducing Promin.

A knowledge graph that both engineers and AI agents can read.

Pre-Alpha
Promin Analyse
Software archaeology layer. Ingests your git history and surfaces why code exists — so engineers and AI agents stop breaking things they don't understand.
  • Orphaned invariant detection
  • Intent drift signals
  • MCP server — works with any IDE
  • Archaeology Debt Score (0–1)
WIP
Promin AI-Native
Full infrastructure layer. Requirements, code, tests, and data connected in a living knowledge graph. AI agents execute from readable intent.
  • Intake gate — no feature unquestioned
  • Drift detection in real time
  • Autonomous coherence monitoring
  • Bidirectional req ↔ code mapping
08 — Get started

Bring a repo.
Get an archaeology report.

We're onboarding early users now.

Request Early Access →