ChangeLens

ChangeLens uses Gemini 3’s 1M-token context and a multi-agent loop to map the hidden blast radius of code changes across your entire repo. Merge with grounded confidence, not guesswork.

Comment

Inspiration

  • Modern codebases are not collections of isolated files. They are systems of tightly coupled components, shared utilities, and implicit dependencies. Through personal experience, we noticed that even small changes, often triggered failures far away from the original edit.
  • The problem was not that developers did not understand their own changes, but that they could not reliably predict downstream impact across the entire repository.
  • ChangeLens was inspired the need for system-wide visibility into change impact before merge, not after something breaks in production.

What it does

ChangeLens analyzes a proposed code change and predicts its blast radius across a GitHub repository before the change is merged. Given a change request and a repository URL, ChangeLens:

  • Ingests the full repository structure
  • Identifies potentially impacted architectural areas
  • Verifies impact through direct code inspection
  • Generates an explainable impact report

The final report includes:

  • A high-level impact summary with metadata
  • Grouped lists of impacted files with clear reasoning
  • Recommended steps to safely implement the change
  • Explicitly listed unverified dependencies
  • Files confidently ruled out as unrelated
  • A downloadable JSON report

How we built it

ChangeLens is built around a three-agent reasoning architecture. At the core of the system is Gemini 3 Flash, chosen for its ability to reason over large codebases using its 1M-token context window, strong coding benchmark performance, and low latency.

  • Agent 1: The Architect utilizes Gemini 3’s 1M-token context window to ingest your entire repository tree. It predicts the "Blast Radius" by identifying architectural layers, and framework patterns strictly through file naming conventions and directory structures.
  • Agent 2: The Auditor fetches the actual source code of files identified by the Architect. It audits real imports, function calls, and shared state to explicitly confirm or reject the initial hypotheses, effectively eliminating LLM hallucinations.
  • Agent 3: The Planner reconciles the Architect’s structural guesses with the Auditor’s verified facts. It produces a high-fidelity implementation roadmap, categorizing findings into Confirmed Changes, Unverified Dependencies and Recommended Steps to ensure zero-blindspot deployments.

The application is built using Next.js (App Router) with Tailwind CSS and Shadcn UI for the frontend, GitHub’s REST API for repository access, and is deployed on Vercel.

Challenges we ran into

  • Avoiding hallucinations: Naively analyzing code with a single LLM pass often led to false positives. This required designing a multi-agent verification pipeline.
  • Balancing speed and depth: Gemini 3 Flash was chosen specifically to keep multi-agent reasoning fast enough for an interactive user experience.
  • Explaining impact clearly: Identifying impacted files was not enough. Each impact needed to be accompanied by clear reasoning so developers could trust and act on the results.
  • Handling uncertainty honestly: Some dependencies cannot be verified with full confidence. We chose to surface uncertainty explicitly rather than hiding it, which required careful report design.

Accomplishments that we're proud of

  • Successfully analyzing entire repositories in-browser without local setup
  • Designing a multi-agent system that reduces hallucinations instead of amplifying them
  • Producing explainable, structured impact reports rather than opaque AI output
  • Demonstrating a real, practical use of Gemini 3 Flash beyond simple chat or code generation

What we learned

  • Large context windows are only powerful when paired with structured reasoning
  • Multi-agent systems are essential for trust in developer-facing AI tools
  • Surfacing uncertainty builds more confidence than pretending certainty
  • AI tools for developers must integrate naturally into existing workflows to be useful

What's next for ChangeLens

  • Deeper integration with Github PR's
  • Impact visualization across dependency graphs and better visuals

Built With

Share this project:

Updates