Landing page (continued)
Exploring catalog of the repo indexed
Dashboard
Available chunks
Import repo feature
Landing page
Answers any query regarding the codebase

Inspiration

The idea for CoDNA came from a problem we ran into ourselves.

One of our teammates was exploring the Sharp repository to understand how its image processing pipeline worked. Like most developers, we opened ChatGPT and started asking questions. It was great at explaining individual functions, but every new question meant copying more files, adding more context, and manually following function calls across the repository.

We realized we were spending more time giving the AI context than actually understanding the code.

That made us wonder:

What if the AI already understood the repository before we asked the question?

That simple idea became CoDNA.

Instead of making developers search through hundreds of files or repeatedly explain the repository to an AI, we wanted an assistant that could understand how the project is structured, how execution flows through the codebase, and what happens when something changes.

What it does

CoDNA is an AI-powered repository intelligence platform that helps developers understand unfamiliar codebases much faster.

You can import a GitHub repository, let CoDNA index it, and ask questions in plain English such as:

How does authentication work?
Where is this API configured?
What calls this function?
What happens if I modify this class?
Explain the architecture of this module.

Instead of simply retrieving similar code snippets, CoDNA combines semantic search with a graph of symbols and dependencies to reason about execution flow, architecture, and change impact. The goal isn't just to find code—it's to help developers understand how everything connects.

How we built it

We built CoDNA as a full-stack application focused on repository intelligence.

On the backend, we used FastAPI, PostgreSQL, Redis, Celery, and SQLAlchemy to handle repository ingestion, background processing, and indexing.

The frontend is built with React, TypeScript, and Tailwind CSS.

Once a repository is imported through GitHub OAuth, CoDNA clones it, parses the source code, generates semantic chunks and embeddings, and builds a symbol-level dependency graph capturing imports, function calls, references, and inheritance relationships.

When a developer asks a question, we combine hybrid retrieval with graph reasoning so the AI answers using actual repository relationships instead of isolated code snippets.

One feature we're particularly proud of is our incremental indexing pipeline. Instead of rebuilding everything whenever a repository changes, CoDNA only processes modified files and updates the affected parts of the graph, making the system much faster and more efficient.

Challenges we ran into

The hardest part wasn't integrating an LLM. It was making sure the AI actually understood the repository.

Building a reliable symbol graph across thousands of files required careful handling of imports, references, inheritance, and dependency relationships.

Another challenge was keeping the AI grounded. We wanted answers to come from real repository evidence rather than confident guesses, so we spent a lot of time refining retrieval and prompt engineering to encourage reasoning instead of summarization.

Scaling was another challenge. Re-indexing an entire repository after every change wasn't practical, so we designed an incremental indexing system that updates only what has changed while keeping the dependency graph consistent.

Accomplishments that we're proud of

Reduced AI costs by over 80% through embedding reuse, intelligent answer caching, and incremental indexing, ensuring unchanged code is never reprocessed unnecessarily.
Built a graph-based repository intelligence engine that reasons over symbols, imports, calls, references, inheritance, and dependency relationships, allowing the AI to explain architecture, execution flow, and code impact instead of simply retrieving similar code.
Successfully analyzed large open-source repositories such as the OpenAI Python SDK and Sharp, indexing thousands of symbols, relationships, and code chunks while providing accurate, graph-backed reasoning across complex production codebases.

What we learned

This project completely changed how we think about AI for software engineering.

We learned that retrieval alone isn't enough. Developers don't just want to know where something is—they want to understand why it exists, how execution reaches it, and what will happen if they change it.

Building CoDNA also gave us hands-on experience with graph-based program analysis, retrieval systems, asynchronous processing, prompt engineering, and designing AI systems that stay grounded in real repository evidence.

What's next for CoDNA

This is just the first version of what we hope becomes a much more capable developer tool.

Next, we want to support more programming languages, build IDE extensions for VS Code and JetBrains, add interactive architecture visualizations, and make pull request impact analysis part of the development workflow.

Long term, we want CoDNA to become an AI teammate that understands a repository as deeply as the engineers who built it, helping developers spend less time searching through code and more time understanding, building, and shipping software.

We're also excited about the future of AI-assisted software engineering and hope to grow CoDNA as part of the OpenAI ecosystem. By building on OpenAI's models and developer platform, we want to continue pushing the boundaries of repository intelligence and create tools that make developers significantly more productive.