CodeZero

Understand your codebase before you change it.

Comment

Inspiration

AI coding tools are getting very good at writing code, but writing code is only part of the problem.

Before changing an existing system, a developer still needs to understand where a feature lives, which repositories are involved, what depends on it, and what else could be affected.

In larger and multi-repository codebases, a lot of this context gets discovered only after implementation has already started.

We built CodeZero to move that understanding earlier in the workflow.

What it does

CodeZero is a VS Code extension that gathers context across repositories connected by an organisation.

It helps developers:

  • See relationships across repositories with the Code Graph
  • Trace how a feature is implemented using Feature Mapping
  • Understand dependencies and potential impact before changing code
  • Ask questions using context gathered across the codebase
  • Investigate and plan changes before implementation begins

The workflow is simple:

Understand → Plan → Build

CodeZero works alongside coding tools such as Claude Code rather than trying to replace the coding agent itself.

How I built it

We built CodeZero around repository indexing and a software graph that represents relationships across an organisation's codebase.

The VS Code extension brings that context directly into the development environment, allowing developers to move from a high-level view of the system down to individual repositories, features, files and dependencies.

The backend is primarily built with TypeScript and NestJS, with MongoDB for application data and Model Context Protocol support for exposing structured code context to compatible AI workflows.

When a repository is available locally, CodeZero can use the current working tree. Connected repositories that are not checked out can still contribute read-only indexed context.

Challenges I ran into

One of the biggest challenges was deciding how much context to provide.

Large software systems can contain huge numbers of files, functions and relationships. Giving an AI model everything would create more noise, use more tokens and often make the result worse.

Another challenge was making cross-repository relationships understandable. A complete graph can become overwhelming very quickly, so we needed ways to move from the overall architecture to the specific feature or dependency relevant to the task.

We also had to account for uncertainty. Some relationships can be resolved directly from source code, while others may be inferred from available evidence. CodeZero keeps that distinction visible rather than presenting every relationship as equally certain.

Accomplishments that I'm proud of

One of the things we're most proud of is making repository boundaries less important when trying to understand an existing system.

A developer can start from the full Code Graph, narrow down to a particular feature, trace relationships across repositories, and then use that same context while investigating a change.

We're also proud that CodeZero does not require every repository in an organisation to be checked out locally just to understand how they relate to each other.

What I learned

The biggest lesson was that more context is not automatically better context.

The useful part is identifying the small portion of a large software system that actually matters to the change being made.

That changed how we thought about AI-assisted development. Instead of focusing only on making an agent generate code faster, we started focusing on improving what the agent and developer understand before generation begins.

What's next for CodeZero

We're continuing to improve how CodeZero understands larger and more complex software systems.

The next areas we're working on include deeper coding-agent integrations, richer cross-repository context, stronger planning workflows, and connecting software context with infrastructure and runtime context.

The long-term goal is to give developers and coding agents a much more complete understanding of the system they are changing before the first line of code is written.

Share this project:

Updates