Software Genome AI

Explainable Change Impact Before You Merge

Comment

Inspiration

Developers often need to change code they did not write, but cannot confidently answer one critical question: what else could this change break? Reading an unfamiliar repository file by file is slow, and a small change can have a hidden impact across many modules.

Software Genome AI was inspired by the idea of making software easier to understand like a biological genome: a connected map of relationships, risks, and dependencies.

What it does

Software Genome AI imports a public GitHub repository, analyzes its structure, and turns it into an explainable dependency graph.

A developer can select a file and immediately see:

  • Direct dependents
  • Transitive blast radius
  • A visual dependency map
  • Evidence explaining why every affected component is included
  • Repository-level statistics for files, classes, functions, and imports

How we built it

We built the backend with FastAPI, SQLite, Python AST parsing, lightweight TypeScript and JavaScript parsing, Git-based repository import, graph persistence, and reverse dependency traversal.

We built the frontend with Next.js, React, TypeScript, and an interactive SVG dependency visualization.

We used Codex and GPT-5.6 throughout OpenAI Build Week to analyze the original prototype, prioritize the architecture, implement secure repository-job workflows, build the dependency graph and impact engine, create the visual experience, improve error handling, and verify the project with regression tests and production builds.

Challenges we ran into

One major challenge was making repository import reliable on Windows. Large repositories can contain deeply nested paths, and cloning into a long OneDrive workspace path caused checkout failures.

We solved this by moving temporary repository analysis storage to a short local path, enabling Git long-path support, and using shallow filtered clones.

We also encountered a Next.js development manifest issue. We resolved it by clearing generated cache files and using a stable local development configuration.

Another challenge was keeping the impact analysis trustworthy. We chose deterministic graph traversal as the source of truth, rather than relying on an unsupported AI claim.

Accomplishments that we're proud of

We are proud that Software Genome AI became more than a static code statistics dashboard.

It now has:

  • Secure GitHub repository import
  • Background analysis jobs with status updates
  • Persisted graph snapshots
  • Python, TypeScript, and JavaScript structural analysis
  • Direct and transitive dependency impact analysis
  • Human-readable evidence for every impact result
  • Interactive graph visualization
  • Regression tests, CI configuration, and production build verification

Most importantly, the product gives developers a clear and visual answer before they merge a risky change.

What we learned

We learned that developer tools become more useful when they are explainable. A dependency graph is valuable, but it becomes actionable only when a developer can understand why a result appears and what to do next.

We also learned that reliability matters in hackathon products: secure path handling, background jobs, clear error states, and a repeatable demo experience are as important as the core idea.

Codex and GPT-5.6 helped us move quickly from an early prototype to a more complete, tested, and demo-ready product.

What's next for Software Genome AI

Next, we plan to add pull-request and commit comparison, test recommendations, code ownership signals, richer symbol-level dependency analysis, and automated impact reports before merge.

Our long-term goal is to help engineering teams make safer changes, onboard faster, and understand complex software systems without guessing.

Built With

Share this project:

Updates