- AI coding agents often repeat mistakes because they lack memory of team decisions and established conventions.
- Lore is an open-source tool that functions as a decision base, storing team choices for AI agents to reference.
- By querying Lore, agents can apply agreed-upon rules, leading to more consistent code generation and fewer errors.
- Lore supports spec-driven development by formalizing team decisions, complementing agent instructions.
- The tool integrates with agent workflows, offering a structured alternative to easily outdated natural-language documentation.
- Key benefits include reduced code review time, easier onboarding for new team members (human and AI), and improved agent consistency.
You have been there. You ask your AI coding agent to write a new module, and it picks the wrong library. Or it uses a formatting style no one on the team agreed on. You fix it manually, shake your head, and move on. But the next day, the same agent makes the same mistake. It feels like you are stuck in a loop.
The root cause is simple. Your coding agent does not know what your team has already decided. It starts fresh every time, with no memory of past discussions or shared rules. As teams grow and codebases get more complex, this problem only gets worse. A new open-source tool called Lore aims to solve this. It gives your coding agent a way to access and apply the Lore coding agent decisions your team has already made.
Why Coding Agents Repeat Mistakes
AI coding agents can generate code, fix bugs, and suggest improvements, but they operate in a vacuum. When you prompt an agent, it does not know that last week your team decided to use the “requests” library for HTTP calls instead of “urllib.” It does not know you agreed on camelCase for function names or that you always put unit tests in a specific folder. This gap leads to wasted time: you write the same instructions repeatedly, catch the same mistakes in pull requests, and explain the same conventions to new team members and agents.
Traditional documentation tries to solve this with wikis or READMEs, but agents do not read them easily, and documentation often goes out of date. A decision made six months ago might be buried in a Slack thread, so the agent keeps guessing.
What Is Lore? A Decision Base for Your Team
Lore fills this gap. It is an open-source project hosted on GitHub under the name “rac-core.” The idea is straightforward: Lore acts as a shared memory for your team’s decisions. When your team makes a choice, you record it in Lore. Then, when a coding agent needs to make a similar choice, it checks Lore and follows the existing rule. Think of it as a decision base, not just a knowledge base, storing both the rule and the reasoning behind it.
Lore is designed to be simple. You add decisions in a structured format that both humans and machines can read. The tool indexes those decisions so agents can query them quickly. According to the project’s GitHub page, the goal is to give coding agents “the decisions your team made” directly.
How Lore Captures Team Knowledge for Agents
Imagine your team decides to use Python’s FastAPI for all new APIs. You create a Lore entry: “For all new Python API endpoints, use FastAPI. Do not use Flask or Django REST Framework.” You add a note explaining why (better performance and automatic OpenAPI documentation). When you ask an agent to “create a new endpoint for user login,” it queries Lore, finds the FastAPI rule, and generates code accordingly. No guessing needed.
This approach scales. You can store decisions about testing frameworks, project structure, naming conventions, and more. Every time the agent encounters a matching situation, it applies the stored decision. If the team changes its mind, you update the Lore entry, and the agent gets the new rule. This keeps the system current, unlike stale wiki pages.
Lore’s Role in the AI Agent Ecosystem
Lore focuses on capturing team decisions for reuse, fitting into a larger trend called spec-driven development. Spec-driven development formalizes what an AI agent should do; Lore formalizes what the team has decided. Augment Code offers a guide on this approach, and GitHub Blog describes how Squad runs coordinated AI agents inside a repository. For such coordination, each agent needs shared rules, and Lore can provide that knowledge layer. Salesforce Headless 360 enables AI interactions via APIs, where agents need programmatic access to knowledge-Lore fits that model. O’Reilly Media also emphasizes writing good specs for AI agents; Lore takes this to the team level, collecting decisions made over time.
Getting Started with rac-core on GitHub
The core Lore project is available on GitHub as “rac-core.” The repository is early stage but addresses a real pain point. To start, clone the repository and set up the decision base. Define decisions in a simple format; the tool creates an index agents can query. Integration depends on your agents-some call a local API, others need a file or database connection. Being open-source, you can adapt it to your workflow.
Impact of Lore on Your Development Workflow
Adopting Lore makes coding agents more consistent, saving time in code reviews and reducing bugs. It encourages a culture of documenting decisions-creating a Lore entry forces clarity. Onboarding new team members (human or AI) becomes easier as they can consult the decision base.
Trade-offs include maintenance effort: someone must add and update decisions. If neglected, the decision base becomes outdated, but Lore’s simple format makes updates easier than traditional documentation. Another challenge is handling conflicting decisions; for now, teams must check for conflicts manually. Lore can integrate with CI/CD pipelines to verify agent output matches stored decisions, creating a safety net.
Spec-Driven Development and Agent Coordination with Lore
Lore is part of a shift from generating code to controlling it. Spec-driven development formalizes what the agent should do; Lore formalizes what the team has decided. Together, they make agents act more like team members. Coordinated agents, as described by GitHub Blog’s Squad post, need a shared context-Lore can be that layer. Salesforce Headless 360 points to API-first agents that need programmatic knowledge access, which Lore provides. O’Reilly Media’s guide on specs reinforces the need for clarity; Lore forces specificity into concrete rules.
Real-World Use Cases for Lore
Because Lore is early, case studies are limited. Early adopters use it for consistency. One team stored a decision about using boto3 for AWS calls, and their agent always chose the right library, cutting review time. Another team enforced a folder structure via Lore, so agents placed files correctly without instruction.
Potential Pitfalls and How to Avoid Them
Information overload can slow agents; focus on high-impact decisions. Outdated decisions require periodic review-set a calendar reminder. Conflict resolution needs care: check for contradictions before adding new decisions. Trust is also important-Lore should be a guide, not a replacement for judgment; agents should fall back to asking humans when needed.
Lore vs. Traditional Documentation for AI Agents
Traditional documentation uses natural language for humans, which agents struggle to parse. Lore uses a structured format machines can read quickly. Documentation often lives in a separate system; Lore integrates into the agent’s workflow. Documentation tends to go stale; Lore’s simple format makes updates easier, but responsibility remains. Lore enforces rules consistently-the agent never forgets. However, documentation can be more expressive for complex trade-offs. A hybrid approach is best: use Lore for agent rules and a wiki for broader explanations.
Keeping Lore Decisions Up to Date
Lore relies on the team to update decisions, but it makes the process easier with a structured format. Teams can build automation-for example, a script that checks the decision base against the codebase. Storing Lore decisions in Git provides an audit trail and allows reverting problematic changes.
Handling Conflicts in Lore Decisions
Conflict handling is an area where Lore could improve. For now, teams should manually check for contradictions before adding new decisions. In the future, automated conflict detection may be added. The key is to use Lore thoughtfully, keeping the decision base lean and consistent.
Frequently Asked Questions
What problem does Lore solve for AI coding agents?
Lore solves the problem of AI coding agents repeatedly making the same mistakes, such as choosing the wrong libraries or using inconsistent formatting. This happens because agents typically lack memory of past team decisions and agreed-upon conventions.
How does Lore help AI agents make better decisions?
Lore acts as a shared memory or decision base for a team. When a team makes a decision, it's recorded in Lore in a structured format. AI agents can then query Lore to find and apply these existing rules, ensuring they follow team conventions.
What is the difference between Lore and traditional documentation like wikis?
Traditional documentation is often in natural language, which AI agents struggle to parse effectively. Lore uses a structured format that machines can read quickly and integrates directly into the agent's workflow, making it more actionable for AI.
Is Lore difficult to set up and use?
Lore is designed to be simple. The core project, 'rac-core,' is available on GitHub. Teams define decisions in a straightforward format, and the tool creates an index for agents to query. Integration methods vary depending on the specific agents used.
What are the main benefits of using Lore in a development workflow?
The primary benefits include increased consistency in code generated by AI agents, reduced time spent on code reviews and bug fixing, and easier onboarding for new team members or AI agents. It also encourages a culture of documenting decisions.
What are the potential challenges or trade-offs when using Lore?
Challenges include the ongoing effort required for maintenance (adding and updating decisions) and the need for teams to manually check for conflicting decisions. If neglected, the decision base can become outdated.
How does Lore fit into broader AI development trends?
Lore aligns with the concept of spec-driven development, where AI agent behavior is formalized. It provides a crucial knowledge layer for coordinated AI agents and enables programmatic access to team knowledge, which is important for API-first AI interactions.
