NRRV: a reality-driven product-development ecosystem

The problem

Most product teams decide on assumptions and find out later whether reality agreed. Feedback arrives slowly, the learning between iterations leaks away, and the gap between what we intended and what actually happened is never written down anywhere a tool can act on it.

"Another framework" was never the goal. The more useful, harder problem is to make the feedback loop itself the architecture: reality over assumptions, feedback over features, iteration over perfection, and human agency over automation. NRRV is the system I built to do that, end to end, from the governing philosophy down to the bytes on disk that record every decision.

My role

I own NRRV end to end as its founder, architect, and engineer: the governance framework, the execution methodology, the AI engine, the web platform, the documentation pipeline, and the IDE tooling. The most interesting work sits exactly where product judgment meets engineering, which is the same place this site argues a technical product leader should live: deciding what to model as a first-class signal, what to enforce versus what to merely surface, and how a tool can apply pressure toward reality without taking the decision away from the human.

Architecture

NRRV is three layers over one spine. Signals are the source of truth. Every meaningful event, a phase transition, a completed task, a guardrail violation, an acknowledged warning, is written as an immutable, append-only YAML file under .nrrv/signals/, named by timestamp plus a UUID v7 so the stream is naturally time-ordered. Those signal files are committed to git. The current state (.nrrv/loop.yaml) is derived, regenerated by replaying the signals, and is itself gitignored, because it is never the truth, only a projection of it.

Because every emitter, the nrrv CLI, the Crew engine, and CI, writes into the same signal bus rather than calling each other, the tools stay decoupled. A signal emitted by CI is read the same way as one emitted by a human at the command line, which is what lets the system span multiple tools without any of them owning the others.

What it actually does

NRRV is one ecosystem with three layers and the surfaces that make it usable:

• NRRV framework (governance). Navigate → Reason → Realize → Validate. It applies pressure, not gates: validation is soft, so a warning shows what's missing but never blocks, and choosing to proceed anyway records a waiver signal with the reason. The tool informs; the human decides.
• SAIL methodology (execution). Scope → Architect → Implement → Learn. Specs are structured documents validated against JSON Schema, with TDD anchors linking requirements to the tests that prove them and explicit phase-completion tracking.
• Crew (AI engine). Multi-provider AI dispatch across Claude, OpenAI, and Gemini, governed by a guardrails engine with three rule types: regex pattern blocks, metric thresholds (file size, line and function counts), and TypeScript AST checks, with built-ins like no-secrets and no-any. AI here is an accelerant, not a requirement: code is written by hand or AI-assisted, and the engineer stays the author.
• The surfaces. A Next.js 16 + FastAPI portal hosting a four-tier certification ladder (Foundations → Practitioner → Team → Organization); a Docusaurus documentation site that syncs into a GitHub Wiki through a custom transform; and a VS Code extension with live signal and spec browsers backed by filesystem watchers.

Decisions that mattered

• Signals as the spine. Event-sourcing the whole lifecycle, immutable append-only signals with derived state, buys audit, time-travel, and decoupling for free, and makes "what actually happened" a first-class, queryable record rather than tribal memory.
• An open-core addon architecture. The CLI is a persistent host with an addon API; the framework, SAIL, and Crew all ship as addons onto that host. Proprietary cloud features integrate as addons without forking the open (Apache-2.0) platform, so open-core never means a divergent codebase.
• Soft validation by design. Pressure, not gates, with waivers recorded as signals, keeps humans in charge while still capturing every override as data the system can learn from.
• One shared bus across tools. The nrrv CLI, Crew, and CI interoperate through signals instead of direct calls, which is what makes a multi-tool ecosystem cohere.
• AI as accelerant, not dependency. Nothing in NRRV requires AI to run; the Crew engine speeds up work streams when it helps, while a human stays the author and the decision-maker.

Outcomes

• A coherent ecosystem spanning roughly a dozen repositories, framework spec, CLI platform, AI engine, methodology spec, web portal, docs site, and IDE extension, under an explicit open-core model: a CC BY 4.0 framework and Apache-2.0 tooling with a proprietary hosted layer (nrrv-cloud).
• An event-sourced foundation where state is always reconstructable from committed signals, giving audit and time-travel by construction and letting independent tools cooperate without coupling.
• A full product story, philosophy, methodology, engine, platform, and tooling, designed and built end to end by one person. The same product-thinking-plus-full-stack-execution thesis this site is built to demonstrate, applied to a system whose entire job is keeping product work anchored to reality.