What teams use Aider for
Aider is one of the most established open-source AI coding tools. It runs in the terminal, reads your repo with a repo-map and a conventions file, and edits files directly from a chat-style interface. For engineers who prefer staying in the shell, Aider is fast, scriptable, and grounded in the actual repo.
The conventions file is the part most relevant to a governance comparison. It is a markdown file (typically at the repo root) that gives the model project-level context: preferred libraries, style choices, architectural notes. Combined with Aider’s repo map, it is one of the strongest prose-driven steering surfaces in the open-source coding-agent ecosystem.
- Open-source, terminal-first AI pair programming
- Repo map gives the model grounded structural context
- Conventions file for prose-driven project steering
- Direct Edit operations on files in the working tree
- Model-agnostic (Anthropic, OpenAI, local, others)
Mneme HQ is not in the same category. It does not generate code, and it does not run in the shell as a primary surface. It sits underneath any coding agent — Aider, Cursor, Claude Code, Copilot — and enforces architectural decisions on the edits the agent proposes. The two tools occupy different layers of the same workflow.
Read by Aider at session start, kept in context, interpreted by the model on each turn. Best for tone, preferred libraries, style. Suggestion-shaped: the model decides how to apply it.
Evaluated on every Edit/Write that any agent proposes. Best for architectural decisions, scope rules, dependency policies. Blocking-shaped: violations are stopped before they land.
The framing: Aider is one of the best open-source pair programmers. Mneme is not a competitor — it is the layer that makes whatever Aider produces compliant with your architectural decisions, regardless of how the conventions file was phrased.
Where they differ as layers in the stack
| Dimension | Aider | Mneme HQ |
|---|---|---|
| Layer in the stack | Coding agent (terminal pair programmer) | Governance enforcement at Edit/Write |
| Context mechanism | Repo map plus conventions file | Typed decision corpus with scope and precedence |
| Compliance model | Prose-driven, model decides per turn | Scope-matched, system decides per edit |
| Multi-agent portability | Aider-specific conventions | Any agent that triggers Edit or Write |
| Override semantics | No native concept | First-class decision records with rationale |
| Operating point | Per chat turn, in context | Per Edit/Write hook, out of band |
| Cross-session continuity | Reloaded each session, model interprets | Deterministic recall every session, every agent |
Three failure modes for the conventions file
The conventions file is well-designed for what it is. These failure modes are not Aider bugs — they are the cost of using a single prose document as the only enforcement surface for decisions that must hold every time.
1. The convention is in the file but not on this turn
A team adds an architectural convention to CONVENTIONS.md. Aider loads it. In a long session that touches many files, the convention is in context but the model’s attention is on the immediate task. The relevant constraint never fires for the edit that violates it. Mneme’s scope match runs on the edit, not in the context window, so the constraint fires whether the model was paying attention or not.
2. The convention is ambiguous about scope
A conventions file says “use SQLAlchemy 2.x typed queries.” The repo has a legacy admin tool in tools/admin/ that intentionally still uses raw SQL. The prose doesn’t encode this exception. Aider, doing its job, applies the convention everywhere — including the directory where it shouldn’t. A typed decision with explicit scope and an override record for tools/admin/** would have resolved this deterministically.
3. The team uses more than one tool
One engineer uses Aider in the terminal. Another uses Cursor. CI runs Claude Code for autonomous remediation. The conventions file is Aider-specific; Cursor reads .cursor/rules; Claude Code reads CLAUDE.md. Keeping three prose surfaces in sync is a permanent maintenance task, and any drift between them is a drift in actual architectural compliance. Mneme’s typed decisions are the single source of truth that all three agents resolve against.
Why governance is a different primitive from pair programming
Aider is a great pair programmer. Its core job is to help one engineer move quickly and stay grounded in the repo. The conventions file exists because that pair-programming loop benefits from project-level prose context. It works well at that job.
Architectural governance is a different job. The question is no longer “what is the best edit for this turn?” but “is this edit allowed by the decisions this codebase has already made?” The answer can’t depend on which file the model happens to have in its context window or how the conventions file was phrased on Tuesday.
Mneme answers the governance question with typed decisions: explicit scope, machine-evaluable predicates, precedence ordering. When any agent (Aider included) proposes an Edit or Write, Mneme matches the scope, resolves precedence, and either lets the edit through or blocks it with the specific decision that fired. Same edit, same verdict, every session, every agent.
This is not a richer conventions file. It is a different primitive: structured enforcement, designed for the property prose cannot offer — deterministic recall of decisions that must hold every time.
Using Aider and Mneme together
The two tools compose cleanly. Aider stays the productive surface for engineers who like the terminal; Mneme stays the enforcement layer that catches violations regardless of which agent is editing.
- Keep Aider for the in-flow coding loop. Repo map, conventions file, fast feedback — all of it. Aider is one of the best terminal pair programmers; Mneme has no quarrel with it.
- Move enforceable decisions into Mneme. Architectural rules, dependency policies, scope-bound conventions. Anything that must hold every time, regardless of which agent or session.
- Keep
CONVENTIONS.mdfor prose-shaped guidance. Tone, examples, things that improve average-case quality but aren’t literal blocking criteria. - Hook Mneme at the Edit/Write boundary. When Aider proposes an edit, Mneme matches by file scope and either allows it or blocks with the specific decision that fired.
- Encode exceptions as decisions, not as prose carve-outs. The
tools/admin/case above belongs in a typed decision record, not a paragraph in a conventions file.
In this architecture, Aider is the memory of how this engineer likes to work. Mneme is the memory of what this team has decided. Workflows that use both are faster than Aider alone and have harder compliance guarantees than the conventions file can provide on its own.