Architectural governance for AI-assisted development
The wrong question is "does Mneme support Python." The right question is whether Mneme governs AI-assisted Python development. Same for TypeScript, JavaScript, the framework ecosystems, and the infrastructure-as-code surface on this page.
Strongest coverage
Where Mneme has native runtime depth, benchmark coverage, and worked examples. These are the languages with the heaviest AI coding adoption and the easiest architectural drift demos.
Native CLI, real benchmark coverage, dogfooded in production repos. Backend services, FastAPI / Django / Flask, AI/ML pipelines, CLI tooling.
Python governance →Exact literal rules with path scoping (forbidden imports, banned APIs), plus retrieval guidance from recorded decisions. Semantic/AST depth is roadmap.
TypeScript governance →Vanilla JS, Node.js backends, legacy React/Vue codebases. Same repository-level governance as TypeScript without type-system assumptions.
JavaScript governance →Compatible via repo-level governance
Compatible today through exact literal and path-scoped rules plus retrieval guidance — no ecosystem-specific policy packs yet. Roadmap items where benchmark coverage and demand justify the depth.
cmd/, internal/, pkg/ boundaries via path-scoped rules; forbidden imports and commands as exact literals. go.mod-aware depth is roadmap.
See full matrix →Path-scoped rules over controller/service/repository layouts; banned APIs and packages as exact literals. Spring-aware semantic packs are roadmap.
See full matrix →.NET solution layout via path scoping; namespace and package rules as exact literals. Roslyn-assisted depth is roadmap.
See full matrix →Workspace and crate paths via path-scoped rules; forbidden crates/APIs as exact literals. Clippy/rustc-assisted depth is roadmap.
See full matrix →Frameworks & ecosystems
Framework-level governance pages. The same repo-native decision corpus, focused on the architectural surface of a specific ecosystem — policies expressible as literal/path rules and retrieval guidance; no framework-aware analysis today.
Policies expressible as exact literal rules and path scoping over router/service/repository/schema layers. Thin route handlers, dependency-injection discipline, and consistent auth dependencies as recorded decisions.
FastAPI governance →Policies expressible as exact literal rules and path scoping over controller/service/repository/domain layers. Approved starters, transaction boundaries, and Spring Security/Actuator policy as recorded decisions.
Spring Boot governance →Infrastructure as code
Agents don't only modify application code — they modify the infrastructure and configuration where architectural decisions become operational reality. Governed through the same repo-native corpus.
Integration support and language semantics are separate questions. Mneme's deterministic rule engine works across any text or code language. The integration matrix documents which agent surfaces enforce the corpus today. AST-, compiler-, and framework-aware semantics are not currently provided — that depth is roadmap, not shipped.
The codebase's language is downstream.
Cross-language governance before deep language specialization. The decision corpus is the constant; the language is downstream. Add semantic depth where benchmarks and demand justify it — not by default for every ecosystem at once.
More ecosystems coming
More framework-level governance pages are in progress. Next up: React, Next.js, and Django.