What it is
What MetricMine is, and what it is not.
A fast answer for anyone who arrives from dbt, Airbyte, or a Claude Code session and wants to know where this fits. Short version: it sits between the tools you already use, and it works alongside them.
It is
Four true sentences.
A contract-driven medallion pipeline that runs end to end on one machine: bronze lands raw, a deterministic profiler describes it, approved ODCS contracts shape silver and gold, and an auto-modeling engine emits the whole gold layer from the approved contract.
A governance loop for AI-assisted modeling. Two narrow agents draft contracts. A person approves by merging a pull request. Deterministic code and dbt execute. Every approved contract records in git who proposed it and which person merged it.
A reference implementation, built in the open, with forty-two binding decisions in a versioned register, sixty-six measured findings, and no claim without a reproducible command behind it.
A working demo: seven public sources, three fact categories, one star, served read-only over MCP, keyless, from a fresh clone in two minutes.
It is not
Six things people ask.
Not a replacement for dbt. It is a dbt project. The transforms are dbt Core models with enforced contracts, and the engine emits dbt model files, never DDL. Your dbt skills carry over unchanged.
Not a replacement for Airbyte. Bronze lands through PyAirbyte. MetricMine starts where the connector stops and never touches the source.
Not an alternative to Claude Code. It is a repository built to be worked on with Claude Code, and it ships the context layer to do it: CLAUDE.md, Oscar the read-only guide and reviewer, a review skill, a working-tree guard, and a GitHub Action.
Not a hosted product. There is no service, no signup, no account, and no pricing. The demo runs keyless on your machine, and the only database artifact the project publishes is the demo export attached to a release.
Not an autonomous agent. Each of the two agents makes one structured API call, holds no warehouse credential, writes only to an outbox, and never merges its own work. Autonomous multi-step agents are a standing non-goal.
Not a promise about scale. What scale means here is measured on stated machines and published with its environment in the repository, never as a claim on this site.
Alongside, not instead
What it adds to the tools you already run.
Each row names what stays yours and what MetricMine puts beside it.
| If you use | MetricMine adds | What stays yours |
|---|---|---|
| dbt Core | ODCS contracts enforced at build time, generated contract tests in CI, an engine-emitted gold layer under an ownership manifest, and a scan that adopts an existing model into the gates. | Your models, your properties files, your profiles. |
| Airbyte or PyAirbyte | A landing loop over a declared source list, a committed profile per landed table, and a cleanup contract per source that a person approves. | Your connectors and their configuration. |
| DuckDB | Three schemas in one local file, a read-only serving posture three layers deep, and a demo export verified content-equal by query. | Your data, on your machine. |
| Claude Code | Oscar, the resident guide and reviewer, a read-only subagent that answers from the repository's own files; CLAUDE.md with nineteen hard rules; the contract-review skill; the working-tree guard; and the GitHub Action for the authoring loop. | Your workflow, plan mode and all. |
| An MCP client | A server with five read-only tools over the gold star, and a context registry that keeps what was measured apart from what an expert wrote. | Your assistant. The demo guide wires Claude Desktop. |
The idea in one paragraph
The human decides meaning. The machine decides structure.
The human decides what the data means and how sources reconcile. The machine decides how that meaning is structured and served. Meaning is declared in two places, the silver cleanup contract and the gold mapping contract, and everything downstream of those two declarations is a mechanical, byte-reproducible function of them: 22 of the 31 dbt models on main are engine-emitted and never hand-written. The nine exceptions are silver, the human-owned plane, because silver is where meaning is decided. What the agent proposes for silver is the contract, not the SQL.
That split is what the design buys. A wrong number has an address: it traces to the silver logic or to the mapping declaration, never to a hand edit somewhere in the DAG. Determinism means the same inputs emit byte-identical model files, so a change is reproducible, diffable, and reviewable; it does not mean the models are right. Correctness comes from separate machinery: contracts enforced at build time, five conservation tests in CI, and a grain check that measures a declared grain rather than trusting it. The pipeline offers traceability and conservation, not observability, and regeneration lands as a pull request, never as an automatic update.
The gold layer is a generic content-addressed container by design, not an automated star schema. Its three measured trade-offs are recorded where a reader will look, each linked to the finding that measured it: the README carries them, and the gold layer spec carries the reading rules.