16 comments

[ 6.8 ms ] story [ 37.9 ms ] thread
Author here! Coding agents kept reworking decisions we'd already settled - reviving an approach we ruled out in an ADR, redoing something a requirement already pinned. The context was in the repo; the agent had no current view of it.

Lore serves your team's durable knowledge - requirements, decisions, designs, roadmaps, prompts - all as typed Markdown, read-only to Claude Code / Cursor over MCP, so the agent cites your decisions instead of contradicting them.

The bet: retrieval is deterministic. No embeddings, no vector store, no model call to pick what's relevant — same query, same bytes, same result, offline. It's not a RAG competitor; it composes — recall fuzzily, then verify the EXACT, CURRENT decision in Lore (it declines the ones you've superseded). Runs in CI (rac validate / rac gate) too.

  pipx install rac-core
  rac quickstart
  claude mcp add lore -- rac mcp
What it isn't: a search index, a memory layer, or an AI feature — the engine makes no LLM calls, no telemetry unless you opt in. Early, and my corpus is small, so I'd like to hear where deterministic grounding breaks down for you vs. where fuzzy recall is enough.

(Lore is the product; the engine under it is RAC — Requirements as Code, the `rac` package.) Apache-2.0, typed.

How does this compare to CLAUDE.md and other Rules you can put in markdown?
I started building an app with similar goals but with the very different approach. I work on my own coding agent, https://github.com/brainless/nocodo, where I have been trying to build a provenance based engine that will generate or modify prompts to point to the decisions that a team has made. That work is in the branch: feature/praxis_agent_runtime

While working on this I figured what if I build a proxy for coding agents - Claude Code, opencode, Codex, etc. support a proxy. This proxy would edit prompts and tool_calls and feed context from an internal index it will maintain. That index will contain git logs, GitHub/JIRA/etc tickets/epics, PRD or other documents, tech stack setup.

It is just an idea and may not work but working at the proxy layer means this can be deployed at a team level, needs no MCP install and can re-shape prompts for everyone depending on the project. Wild idea perhaps.

1. Write ADRs (or get agents to write them)

2. Commit ADRs to git

3. Mention ADRs in AGENTS.md

Seems a bit similar to spec driven development. How does it differ?
What exactly does rac validate do? How is it deterministic? Is there an example somewhere?
great approach with dogfooding!

the failure I hit most is not that the agent forgets, it is that it re-opens things the team already closed. So treating ruled-out paths as first-class is the right instinct

quick question why mcp instead of cli tool? I'm mostly building the latter (less context burden), but help me understand your own ADR regarding this

why not both?

also after quick review on your doc I don't see where is ADR portal for humans? some plans for UX or this is inside git repo?

Interesting approach. I am curious how this information stacks up over time and how efficient it is at incorporating decision knowledge into active context.

I have taken a different approach: allow team members to sync all of their Claude Code and Codex transcripts on a project and give them a skill that lets them ask their AI why decisions were made.

The skill I've built, /total-recall is backed by a Swift-based CLI that provides efficient query tooling that coding agents can use however they see fit to arrive at the answer.

The corpus of data contextify queries is a SQL database managed by macOS and Linux clients. These clients ingest the jsonl files in realtime and optionally can sync transcript data through either a hosted or self-hosted server.

This allows any team member to simply invoke the skill: "Why did we switch over to allauth from aws cognito? /total-recall."

My experience is that Claude Code and Codex don't just land "near" a decision, but can assemble it from what is sometimes a winding pathway of research, benchmarking and experimentation.

Rather than codify requirements into a separate spec, Contextify lets agents pair the state of the code with the conversational record.

I have just released the free personal and source available self-hosted version of Contextify, I'd be glad for feedback.

https://contextify.sh/teams/, https://contextify.sh/self-hosted/

[dead]
this is the kind of memory i actually want: decisions and tradeoffs, not raw chat history. old chat logs make agents confidently wrong pretty fast.