DEV Community: Siddharth

BugProof: Making Bugs Reproducible

Siddharth — Sun, 18 Oct 2026 16:41:12 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

BugProof is a tool designed to make software bugs reproducible, portable, and easier to debug.

Every developer has experienced this frustrating situation: a bug appears on one machine, disappears on another, and refuses to reproduce in the environment where someone is trying to fix it.

The usual bug report contains a stack trace, a few screenshots, and a message saying, "It works on my machine." But reproducing the issue often requires much more context: source state, execution details, environment metadata, and the conditions that triggered the failure.

BugProof addresses this problem through portable .bug artifacts that capture the context needed to investigate and replay failures.

The idea is simple: instead of sharing only a description of a bug, share an artifact that helps another developer reproduce it.

The potential users include:

Freelance developers who need to investigate bugs reported by clients.
Small engineering teams that spend too much time reproducing issues.
Open-source maintainers who receive incomplete bug reports.
Teams using AI coding agents that need structured debugging context.

The commercial opportunity is straightforward: developers and small teams pay for engineering time saved. BugProof aims to reduce the time spent gathering missing information, reproducing failures, and communicating debugging context.

Demo

🌐 Website: https://bugproof.pages.dev/

🎬 Video demo: https://vimeo.com/1197136689

Code

💻 GitHub repository: https://github.com/sidinsearch/BugProof

BugProof is being developed around the idea that debugging context should be portable and reproducible rather than trapped in screenshots, terminal logs, and chat conversations.

Check the repository for the current implementation, setup instructions, and supported functionality.

How I Built It

BugProof's core concept is built around a portable .bug artifact that captures the information needed to investigate a failure.

The workflow is centered on three stages:

Capture: Collect relevant source state, execution context, environment metadata, and a failure fingerprint.
Share: Package the debugging context into a portable artifact that can be transferred between developers or environments.
Replay and investigate: Use the captured context to help reproduce the original failure and narrow down the cause.

The next layer is AI-assisted debugging.

Rather than treating an LLM as a generic chatbot, I want to give it structured, task-specific debugging context. An AI system can use the failure information to explain likely causes, identify relevant environment differences, suggest investigation steps, and help developers understand why a failure occurred.

Open-weight models and local inference are particularly interesting for this workflow because source code, stack traces, configuration, and execution logs can contain sensitive information.

The architectural direction is to keep the debugging artifact as the source of truth and make the AI layer replaceable. That means the debugging workflow does not have to depend on a single model provider.

Why Does Open Innovation Matter?

Debugging tools should not require developers to hand over their codebase to an external AI service just to understand a failure.

Open innovation creates several useful possibilities for BugProof.

1. Privacy by design

Source code, environment variables, stack traces, and logs can expose proprietary implementation details or sensitive information. Running a compatible open-weight model locally can allow AI-assisted analysis without uploading that context to a third-party inference API.

Local inference alone does not guarantee privacy, so the implementation must also handle artifact contents, secrets, telemetry, and network requests carefully.

2. Freedom to choose the model

Different debugging tasks have different requirements. A smaller model may be enough to summarize an exception, while a stronger coding model may be more useful for analyzing a complicated failure.

An open-model architecture makes it possible to evaluate and swap models based on quality, latency, hardware requirements, and licensing.

3. Predictable operating costs

A debugging workflow can generate many model requests while analyzing logs, comparing environments, and investigating repeated failures.

Local inference can eliminate per-request inference charges after the initial hardware and setup costs, making usage more predictable for developers who already have suitable hardware.

4. More control over the debugging workflow

The model should work with structured debugging artifacts rather than dictate how the entire product operates. This makes it easier to change prompts, add specialized analysis steps, experiment with different models, and integrate with developer tools.

5. Less dependence on a single provider

If a hosted API changes its pricing, rate limits, or availability, a provider-independent architecture gives developers more options.

The goal isn't to claim that open models always outperform closed models. Hosted models can be stronger at certain tasks, and local inference comes with hardware and maintenance trade-offs.

The advantage is control over where the data goes, which model runs, and how the system evolves.

That is particularly valuable in developer tooling, where the data being analyzed can be the most sensitive part of the application.

My Agent Session

I plan to use DevRelay to capture an agent session showing the implementation workflow, including how BugProof's debugging context can be used to investigate a failure.

I'll add the session link here once it is available.

Prize Categories

Open-source AI and developer tooling.

I'll update this section to reflect the applicable partner categories for the final submission.

Building BugProof has reinforced an idea I care about: debugging should be a reproducible engineering process, not a guessing game.

With portable failure artifacts and a flexible AI layer, I want to make it easier for developers to share failures, understand what went wrong, and spend less time asking, "Can you reproduce it on your machine?"

I Built SuperBrain: A Self-Hosted AI Second Brain That Remembers What You Save

Siddharth — Mon, 05 Oct 2026 11:23:53 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.

What I Built

SuperBrain is a self-hosted AI-powered second brain for everything you save online.

I built it around a simple problem: we constantly save things we find useful — Instagram posts, YouTube videos, Reddit posts, articles, recipes, tutorials, and ideas — but most of that information eventually disappears into platform-specific "Saved" folders.

You save it today and forget about it tomorrow.

SuperBrain turns those scattered saves into a searchable, organized personal knowledge base.

From Android, you can share an Instagram reel, YouTube video, Reddit post, or webpage directly to SuperBrain. The backend processes the content and uses AI to understand and organize it.

It can generate:

Meaningful titles
Summaries
Categories
Semantic tags
Transcriptions
Audio/music information
Searchable content

You can then search your saved knowledge, organize it into collections such as Travel, Gym, Recipes, Design, or Watch Later, and receive reminders for things you actually want to revisit.

I built SuperBrain around a real problem faced by someone close to me: constantly saving useful content without having a practical way to find or use it later.

Instead of building another generic chatbot, I wanted to build something that could become a personal memory layer around the information they already consume.

Demo

Live Project: https://superbrain.sid0x.me/

The core workflow is simple:

Find something → Share it → SuperBrain understands it → Find it later.

Saving content

The main workflow starts from something people already do: finding something interesting and hitting Share.

Instead of saving it into another platform-specific folder, the content can be sent directly to SuperBrain.

Once received, SuperBrain processes the content in the background.

AI-powered understanding

SuperBrain doesn't simply store the URL.

It extracts and processes the available content and turns it into structured knowledge.

This means that months later, I don't have to remember which account posted something or which video contained the information.

I can search for the idea itself.

Search Your Own Knowledge

The real value of a second brain isn't saving information.

It's being able to retrieve it when you actually need it.

SuperBrain provides search across the saved knowledge base so content can be discovered without relying on remembering the original URL.

I can also organize saved content into collections.

This turns a growing collection of saved content into something closer to a personal knowledge base.

Smart Reminders

Another problem with saving content is that saving something doesn't mean you'll ever return to it.

SuperBrain includes reminders so useful content can resurface instead of becoming another forgotten bookmark.

How I Built It

SuperBrain is built as a self-hosted Android application backed by a Python API server.

Architecture

                    Android App
               React Native + Expo
                        │
                  Share any URL
                        │
                        ▼
                 FastAPI Backend
                        │
              ┌─────────┴─────────┐
              │                   │
       Content Extraction      AI Router
              │                   │
              │          ┌────────┼────────┐
              │          │        │        │
              │        Groq     Gemini  OpenRouter
              │                             │
              │                           Ollama
              │
              ├── Web pages
              ├── Instagram
              ├── YouTube
              └── Reddit
                        │
                        ▼
                    SQLite
                        │
                        ▼
              Search / Collections
                        │
                        ▼
                 Smart Reminders

The mobile application is built with React Native, Expo and TypeScript.

The backend uses Python, FastAPI and Uvicorn, with SQLite for persistent storage.

AI Model Router

One of the more interesting engineering pieces in SuperBrain is the custom AI model router.

Instead of hard-coding the application to a single AI provider, SuperBrain supports multiple providers and fallback paths.

Text:
Groq → Gemini → OpenRouter → Ollama

Vision:
Gemini → Groq → OpenRouter → Ollama

Transcription:
Groq Whisper → Local Whisper

The idea is simple:

The application should not completely break because one model provider is unavailable.

If a provider fails or becomes unavailable, the router can fall back to another available provider.

This also makes the system easier to experiment with because the underlying model can be changed without rebuilding the entire application.

Multimodal Processing

SuperBrain isn't limited to plain text.

Depending on the content, the system can work with:

Text
Images
Video
Audio
Speech
Web pages
Instagram content
YouTube content
Reddit content

Video and audio processing allow SuperBrain to extract useful information from content that would otherwise be difficult to search.

Self-Hosting

One of the goals of SuperBrain is to make the backend deployable on infrastructure that the user controls.

It can be run on a personal computer, Linux server, Raspberry Pi, or cloud VM.

The project also supports Docker-based deployment.

npx -y superbrain-server@latest

This makes it possible to run the system without requiring a permanently hosted proprietary backend.

Why Does Open Innovation Matter?

A personal second brain contains some of the most sensitive information a person can have:

Personal notes
Saved content
Ideas
Documents
Interests
Search history
Knowledge accumulated over time

That makes control over the AI stack particularly important.

SuperBrain is designed so that the AI layer doesn't have to belong to one closed provider.

The system can use different models and includes Ollama and local Whisper fallbacks, allowing parts of the AI workload to run locally.

Privacy

Personal knowledge can remain on infrastructure controlled by the user.

Model freedom

The underlying model can be changed without redesigning the entire application.

Self-hosting

The backend can run on hardware or infrastructure that the user controls.

Resilience

If one AI provider becomes unavailable or reaches a rate limit, the application can fall back to another provider.

Experimentation

Open models make it possible to experiment with different models and inference setups without locking the entire product to a single vendor.

For me, that's the biggest value of open innovation here:

The AI is a component of the system, not the system itself.

The application controls the ingestion, processing, storage, retrieval, routing, fallback logic, notifications, and user experience.

What I Learned

Building SuperBrain taught me that the difficult part of an AI application isn't simply calling an LLM.

The interesting engineering problems appear around it:

Reliable content extraction
Multimodal processing
Model fallbacks
Rate limits
Provider failures
Local inference
Persistent storage
Mobile-to-server communication
Background processing
Search
Notifications
Self-hosted deployment

The result is something much closer to a real product than a simple AI wrapper.

Code

The complete source code is available on GitHub:

github.com/sidinsearch/superbrain

The repository contains the application, backend, deployment configuration, and supporting infrastructure.

Prize Categories

I'm entering only partner categories whose technology is genuinely used by SuperBrain.

Open-source AI / open innovation
[Add applicable partner categories here]

Try SuperBrain

Live: https://superbrain.sid0x.me/

GitHub: https://github.com/sidinsearch/superbrain

If you've ever saved hundreds of things online and then completely forgotten where they were, that's exactly the problem SuperBrain is trying to solve.