Bugsy

Your packages are fighting. Bring evidence, not excuses.

Comment

Bugsy

Inspiration

When I first started coding in Python, I discovered that sometimes the hardest part of building a project isn't writing the code — it's getting the dependencies to cooperate.

One package needs an older version, another needs a newer one, and suddenly I'm spending hours reading error messages, reinstalling libraries, and hoping the next version combination works.

Even as I continued learning Python, I kept encountering this problem. So I thought: What if I could build something that helps me understand exactly what's wrong, suggests a possible fix, and actually checks whether that fix works?

That's how Bugsy was born.

I wanted to explore how Nebius and NVIDIA's AI models could help solve a frustrating, everyday developer problem — without asking developers to blindly trust an AI-generated answer.

What it does

Bugsy is an AI-powered Python dependency compatibility and repair assistant that turns confusing dependency errors into understandable, evidence-backed repair proposals.

Developers can upload or paste a requirements.txt file and select their target Python version.

Bugsy then:

  1. Parses and validates the requirements.
  2. Retrieves package metadata from PyPI.
  3. Checks dependency compatibility using a real resolver in an isolated sandbox.
  4. Explains conflicts in understandable language.
  5. Generates a reviewable repair proposal using supported package versions.
  6. Lets developers approve and check the proposed requirements before downloading a revised file.

What makes Bugsy different is that an AI suggestion isn't considered proof. The resolver provides the compatibility evidence, and Bugsy reports exactly which verification stages have passed.

How I built it

I built Bugsy using a combination of modern web technologies, Python tooling, NVIDIA Nemotron, and Nebius infrastructure.

Frontend: React, TypeScript, and Vite provide an interactive interface for submitting requirements, viewing compatibility reports, reviewing proposed changes, and tracking verification results.

Backend: Python and FastAPI manage requirements parsing, package metadata retrieval, compatibility analysis, repair proposals, and verification workflows.

Dependency analysis: Bugsy uses Python's packaging library, the PyPI JSON API, and the uv dependency resolver to gather evidence and identify incompatible requirements.

AI integration: I integrated NVIDIA Nemotron through Nebius Token Factory to generate explanations and select repair candidates from a constrained, metadata-backed set of options.

Sandbox integration: I used Nebius ConTree to execute dependency-resolution checks in isolated environments. This allows Bugsy to test proposed requirements against an actual Python runtime instead of relying on model predictions.

The workflow also includes explicit user approvals. Bugsy constructs and displays the proposed changes, while developers decide whether to proceed with verification.

For deployment, I used Vercel for the frontend and Render for the FastAPI backend.

Challenges I faced

The biggest challenge was making the AI, dependency resolver, and sandbox work together reliably.

While integrating ConTree, I encountered sandbox timeouts and file-staging transport issues. These were especially challenging because a failed or interrupted sandbox operation doesn't necessarily mean the dependencies themselves are incompatible.

I had to design the workflow to distinguish between a genuine dependency conflict, a sandbox error, and a result that couldn't be confirmed.

Another challenge was ensuring that Nemotron's recommendations remained grounded in actual package evidence rather than invented versions or unsupported assumptions.

Deployment brought its own problems, including backend configuration and database file permissions.

These challenges pushed me to build clearer error handling, separate verification statuses, and explicit approval steps.

What I learned

Building Bugsy taught me that creating an AI-powered developer tool involves much more than connecting an LLM API.

I learned how to integrate NVIDIA Nemotron through Nebius Token Factory, execute isolated dependency checks with ConTree, work with package metadata, and connect AI-assisted reasoning to deterministic verification.

More importantly, I learned that a successful dependency-resolution check is not the same as proving an entire application works.

Resolution, installation, imports, and project tests answer different questions. Bugsy keeps these results separate so developers can understand what has actually been checked.

This project also taught me that handling failures and uncertainty is just as important as designing the successful workflow.

What's next for Bugsy

The current MVP focuses on requirements.txt analysis and dependency repair.

In the future, I'd like to expand it with broader environment support, more comprehensive installation and import verification, support for additional dependency formats, and project-level testing.

Ultimately, I want Bugsy to become a tool developers can turn to when their Python environment breaks — not just for another suggestion, but for a clearer understanding of the problem and evidence that supports the proposed solution.

Because when your dependencies start fighting, Bugsy brings receipts.

Built With

Share this project:

Updates

Submission history