CodeLore

Inspiration

I have been a vibe coder for about a year. As my Rust and Tauri projects became larger and more complex, I began losing the mental model I once had: why a module existed, how different parts were connected, whether I was moving in the right direction, and what an AI coding agent might accidentally break.

The code continued to grow, but my understanding did not grow with it.

I needed a tool that could look at a real project from several perspectives and explain difficult engineering concepts in language that an ordinary person could understand. It also needed to preserve that understanding between sessions, so neither I nor an AI agent would have to rediscover the entire repository before every task.

That personal problem became CodeLore.

What CodeLore does

CodeLore is a local-first memory and interpretation layer for software projects. It helps people without deep software-engineering knowledge build ambitious products while retaining understanding and control.

It scans the real codebase and creates:

• A living project brief explaining what the project is, why it exists, and its current state.
• Explanations at five levels, from precise technical language to plain language, analogies, and narrative.
• A human-readable Architecture Atlas showing systems, frontend and backend boundaries, capabilities, dependencies, risks, and areas requiring attention.
• Learning routes that teach programming and architecture through the user's own project.
• Persistent notes, project history, documentation, drift detection, diagnostics, and supervised build-and-run checks.
• Evidence-backed Task Capsules that turn a non-technical intention into a precise, bounded prompt for Codex, including relevant files, dependencies, invariants, risks, acceptance criteria, and verification steps.

CodeLore itself does not write the project code. It remembers and explains the project, then prepares accurate work for the coding agent. This allows Codex to begin with focused context instead of repeatedly consuming tokens while reconstructing the repository from scratch.

A user who wants to learn can use CodeLore as a teacher. A user who does not want to study engineering details can still manage the project through plain explanations and one-click workflows.

The Build Week story

CodeLore was started before OpenAI Build Week, but development had been paused while I worked on other projects.

Three days before the submission deadline, I learned about Build Week during a conversation with GPT. After discussing my projects and the competition, GPT specifically suggested that CodeLore was the right project to submit.

I returned to it with only three days remaining.

During those three days, GPT-5.6 Sol and I completed an enormous amount of work together. We transformed CodeLore from a personal engineering tool into a much clearer product for people: a redesigned human-first workspace, persistent project memory, the Architecture Atlas, improved explanations and learning, task preparation for Codex, post-change verification, Git safety, runtime diagnostics, supervised build and run, project management, automated tests, and the Windows release.

Roughly 80% of the codebase was developed collaboratively with Codex—initially with GPT-5.5 and, during the decisive Build Week push, with GPT-5.6 Sol.

GPT-5.6 Sol proved to be an exceptionally capable coding partner. It could work across Rust, TypeScript, React, Tauri, product design, tests, documentation, and release preparation while preserving the larger product intent. The most important improvement was not simply faster code generation, but its ability to reason about the whole product and turn an ambitious vision into coherent, working systems.

How it was built

CodeLore uses a reusable Rust core for scanning, parsing, knowledge extraction, retrieval, project memory, task preparation, and verification. The desktop interface is built with Tauri, React, and TypeScript.

The architecture is local-first and privacy-first. Project knowledge is stored locally, and CodeLore contains no product analytics or user-data collection. Users can connect a custom OpenAI-compatible endpoint or a local model. For the Build Week version, CodeLore also integrates with the official Codex CLI through the user's ChatGPT subscription, so prepared tasks can run with GPT-5.6 Sol without requiring a separate Platform API key.

Challenges and lessons

The hardest challenge was not drawing a graph or calling an LLM. It was deciding what context the model actually needed.

Sending an entire repository is expensive, noisy, and often less accurate. CodeLore instead decomposes the project, retrieves only relevant evidence, preserves human decisions, and clearly separates verified facts from unknowns. I learned that high-quality decomposition and evidence grounding matter more than the size of the prompt.

Another challenge was designing the same project knowledge for two very different audiences: a person who needs clarity and an agent that needs exact technical boundaries. CodeLore uses one evidence layer, then translates it into different forms without changing the underlying facts.

What is next

The next step is broader language support, deeper local-model integration, provider-specific prompt strategies, richer architectural visualizations, voice input, and long-lived project workflows that make advanced software creation accessible to many more people.

The goal remains the same: make complex software understandable, controllable, and easier to create—for people and for the AI agents working with them.

Built With

• agents
• ai
• codex
• git
• gpt-5.6
• knowledge
• llm
• local-first
• mcp
• openai
• react
• rust
• tauri
• typescript