This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.
What I Built
NoBugs AI is an AI-powered log investigation tool designed to help developers understand application failures without manually searching through thousands of log lines.
Debugging can be time-consuming. A single application failure can produce hundreds of related errors, making it difficult to identify the underlying problem and determine what to investigate next.
NoBugs AI aims to transform raw application logs into structured, evidence-backed incident reports using open-weight AI.
Key Features
- Flexible log input: Drag and drop log files or paste log content directly.
- Automatic error detection: Identify exceptions, failures, warnings, and suspicious events.
- Error correlation: Group potentially related errors to help uncover common causes.
- Severity classification: Organize incidents into Critical, High, and Mild categories.
- AI-powered diagnosis: Generate context-specific root-cause hypotheses and debugging recommendations for individual incidents.
- Incident timeline: Explore how errors evolve over the available three-to-four-hour log history.
- Privacy protection: Redact sensitive information, including API keys and access tokens, before AI analysis.
- Excel reporting: Export incident summaries, supporting log events, severity, status, and recommended fixes.
The goal is to go beyond displaying errors and help developers understand what happened, why it might have happened, and what they should investigate next.
Who Would Pay for It?
NoBugs AI is intended for independent developers, freelancers, startups, and small software engineering teams that need practical debugging assistance without investing in expensive enterprise observability solutions.
By reducing the time spent manually investigating logs, the product aims to make debugging more efficient and accessible.
Demo
Live Demo: https://trideep091.github.io/nobugsai/
The planned demonstration follows a simple workflow: upload a log file, detect and correlate errors, inspect AI-generated diagnoses, explore the incident timeline, and export a structured report.
Code
GitHub Repository: https://github.com/Trideep091/nobugsai
The project is being developed as a modular application with separate components for log ingestion, parsing, incident analysis, AI integration, privacy protection, and reporting.
How I Built It
The core idea behind NoBugs AI is to make open-weight AI an essential part of the debugging workflow rather than simply adding a chatbot to a log viewer.
The planned architecture separates deterministic log processing from AI-powered reasoning.
AI at the Core
The open-weight model is intended to handle tasks that require understanding technical context, including:
- Interpreting complex error messages and stack traces.
- Identifying possible relationships between failures.
- Distinguishing symptoms from potential root causes.
- Generating incident-specific debugging recommendations.
- Explaining uncertainty and identifying missing evidence.
- Summarizing how an incident evolved over time.
For example, when a database timeout is followed by repeated API failures, the system should investigate whether the events are related rather than treating every error as an independent problem.
Every diagnosis should be grounded in actual log evidence, and uncertain conclusions should be clearly identified as hypotheses.
Technology Stack
The planned stack includes:
- React and TypeScript for the user interface.
- Python and FastAPI for the backend.
- Ollama for running a compatible open-weight model locally.
- Structured log-processing logic for parsing timestamps, stack traces, and events.
- OpenPyXL for Excel report generation.
Open-weight model: [Add the exact model name and version once integrated.]
The intention is to use deterministic code for tasks such as parsing, secret redaction, and report generation, while reserving AI for contextual interpretation, incident correlation, and remediation recommendations.
Why Does Open Innovation Matter?
Open innovation matters because debugging tools often process sensitive information about an application's internal behavior.
Logs can contain infrastructure details, request information, and accidentally exposed credentials. Local inference with a suitable open-weight model can help developers analyze this information without automatically sending it to a proprietary cloud AI service.
Open-weight models also give developers the freedom to experiment with different models, evaluate their performance on real debugging scenarios, and adapt the system to their needs.
For a student project, this creates an opportunity to explore how open AI can power a practical developer tool without making a closed API the only route to intelligent analysis.
The objective is to build something useful, transparent, and accessible to developers and small teams.
What's Next?
The next steps are to improve error correlation, evaluate the accuracy of AI-generated root-cause hypotheses, refine the incident timeline, and test the application against realistic log files.
I also want to gather feedback from developers to understand whether the tool can meaningfully reduce the time required to investigate application failures.
The long-term vision: Make debugging less about searching through thousands of log lines and more about understanding problems and finding evidence-backed solutions.
Top comments (0)