ForkSight

Predict what breaks next. Prevent what broke before. ForkSight analyzes GitHub changes to surface future risks and detect when old bugs may return.

Comment

Inspiration

Modern development moves fast, especially with AI-assisted coding. A change can look correct today while silently creating a new failure or bringing back a bug that was fixed earlier.

Git history already contains valuable information about what broke before, where it broke, and how it was fixed — but developers rarely use that context when planning the next change.

That inspired ForkSight.

Predict what breaks next. Prevent what broke before.

What it does

ForkSight is a pre-merge engineering intelligence tool for public GitHub repositories and pull requests.

A developer provides a repository or PR and describes a proposed change. ForkSight then analyzes real repository evidence and looks in two directions:

Future Risk

ForkSight identifies potential problems that the proposed change could introduce, including areas such as:

  • input validation
  • security boundaries
  • API reliability
  • compatibility and regressions
  • rate limiting
  • caching and stale data
  • error handling

Each finding includes severity, confidence, affected files, evidence, prevention guidance, and suggested tests.

Bug Resurrection

ForkSight also looks backwards through Git history for likely historical bug fixes.

If a proposed change touches the same files, concepts, or code areas as an old fix, ForkSight highlights a Potential Resurrection Risk.

During our own demo, ForkSight connected a proposed change to GitHub URL parsing with a real historical commit that fixed handling of non-standard ports.

ForkSight also includes:

  • Deep Evidence from relevant source files and historical patches
  • Failure Path visualization
  • Blast Radius analysis
  • What-If Simulator
  • Evidence Perspectives for Security, Reliability, QA, and Regression concerns
  • Guardrail Pack with pre-merge recommendations
  • Test Pack with suggested JavaScript/TypeScript test code
  • Copy and Download Markdown Reports
  • Scan History stored locally in the browser
  • Public GitHub Pull Request analysis

ForkSight never claims that a predicted bug will definitely happen. Findings are clearly presented as evidence-based heuristics, not proof.

How we built it

ForkSight was built with:

  • React
  • Vite
  • JavaScript
  • React Router
  • GitHub REST API
  • Lucide React
  • LocalStorage
  • Vercel
  • Agent Orchestrator

Agent Orchestrator was used as the actual development workspace throughout the hackathon.

We broke the project into focused AO tasks for:

  • frontend architecture
  • responsive UI
  • GitHub repository intelligence
  • historical bug discovery
  • Future Risk analysis
  • Bug Resurrection
  • Deep Evidence
  • Failure Path and guardrails
  • Scan History
  • risk-precision improvements
  • PR analysis
  • generated test suggestions
  • testing and final verification

AO workers operated in isolated worktrees, and completed changes were reviewed, tested, and merged into the main ForkSight repository.

Challenges we ran into

One major challenge was making ForkSight useful without presenting heuristic predictions as certainty.

We solved this by exposing confidence scores, repository paths, source evidence, commit history, and explicit disclaimers.

Another challenge was working within GitHub's unauthenticated public API limits. ForkSight therefore performs bounded repository inspection instead of downloading an entire repository.

We also encountered Agent Orchestrator worker and hook issues on Windows, including isolated worktree commits and merge conflicts. We worked through these while continuing to use AO as the main development workflow.

Accomplishments that we're proud of

We are especially proud that ForkSight is not just a UI prototype.

It can analyze a real public GitHub repository, inspect real commits and source files, detect historical fixes, predict evidence-backed risks, connect current changes to previous failures, generate prevention guidance, and suggest test code.

We also successfully used ForkSight to analyze ForkSight itself, including detecting a genuine historical URL-parsing fix as a possible regression risk for a related future change.

What we learned

We learned that a repository's history is part of its architecture.

A defensive line of code often exists because something failed before. Looking only at the current source can miss that context.

Combining forward-looking risk analysis with historical failure evidence can give developers a much clearer picture of what a change may affect before it is merged.

We also learned how useful agent orchestration can be for rapidly building, testing, reviewing, and iterating on a larger project under a tight hackathon deadline.

What's next for ForkSight

Next, ForkSight could expand with:

  • authenticated private repository support
  • GitHub App and automatic pull-request checks
  • CI/CD integration
  • persistent cloud scan history
  • richer multi-agent reasoning
  • architecture and dependency graph analysis
  • automatic regression-test generation and execution
  • team collaboration and shared reports

The long-term goal is simple:

Before developers ship the next change, ForkSight should help them understand both the failures ahead and the failures behind them.

Built With

Share this project:

Updates

Submission history