DEV Community: Vishnu Yadla

BugLens AI

Vishnu Yadla — Mon, 26 Oct 2026 12:04:01 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

BugLens AI — See the Bug. Understand the Cause. Fix with Confidence.

Debugging is one of the most time-consuming parts of programming. A small mistake in a loop, an incorrect condition, or a confusing compiler error can leave developers staring at the same code for hours.

That's why I built BugLens AI, an AI-powered debugging assistant designed to make debugging simpler, faster, and more educational.

With BugLens AI, users can select C++ or Python, enter a problem statement and their code, and optionally provide compiler errors, actual output, and expected output. The application sends this information to an AI-powered backend that analyzes the code, identifies potential bugs, explains possible causes, and suggests corrections.

Instead of repeatedly searching the internet or guessing what went wrong, users can get a structured analysis that helps them understand their mistakes and learn how to fix them.

Who gets to be lazier? Students, competitive programmers, beginners, and developers who want to spend less time hunting for bugs and more time learning and building.

The goal isn't to encourage blindly copying AI-generated solutions. It's to make debugging less frustrating while helping developers understand the reasoning behind a potential fix.

Demo

Live Demo:

bug-lens-ai.vercel.app

Video Demo:

2026-10-25 14-25-16.mp4 - Google Drive

drive.google.com

The demo introduces the BugLens AI interface and shows how users can submit their debugging information and explore the AI-generated analysis.

Code

GitHub Repository:

vishnuyadla22-cmd / BugLens-AI

BugLens AI 🔍🐞

See the Bug. Understand the Cause. Fix with Confidence.

BugLens AI is a complete, modern, open-source AI debugging workbench built for software engineers, students, and competitive programmers. It transforms opaque runtime exceptions, syntax errors, and "Wrong Answer" verdicts into structured, beginner-friendly diagnostic reports with surgical code corrections and sandboxed execution verification.

Developed for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady, BugLens AI uses 100% local open-weight coding models via Ollama (e.g., qwen2.5-coder:7b, deepseek-coder:6.7b, codellama:7b). Your source code and problem statements never leave your machine—no paid cloud AI API keys required.

📑 Table of Contents

View on GitHub

The repository contains the source code for the frontend and backend, along with the configuration needed to run and deploy the application.

How I Built It

I built BugLens AI to explore how AI can solve a practical programming problem while making the debugging process more approachable for learners.

Technology Stack

Frontend: React, Vite, TypeScript, and Tailwind CSS.
Backend: Python and FastAPI.
AI integration: Groq API using the official Python SDK.
AI model: openai/gpt-oss-120b.
Deployment: Vercel for the frontend and Render for the backend.

How It Works

Enter the problem: The user selects a programming language and provides the problem statement and source code.
Add debugging details: The user can include compiler errors, actual output, and expected output to give the analysis more context.
Analyze the code: The FastAPI backend communicates with the configured AI model through the Groq API.
Understand the issue: The application presents the generated analysis, including potential bugs, explanations, and suggested corrections.

One of my goals was to make the application available through a live website rather than leaving it as a project that only runs on my computer.

Deploying the frontend and backend separately also gave me practical experience with environment variables, API communication, CORS configuration, deployment settings, and troubleshooting production issues.

Getting the application deployed was an important part of the journey. I had to identify and fix a frontend API configuration issue before the deployed website could communicate correctly with the backend.

That experience reminded me that building an application involves more than writing code. It also requires testing, debugging, configuration, and persistence.

Why Does Open Innovation Matter?

Open innovation allows developers to learn from existing tools, experiment with new technologies, and build solutions that others can inspect, improve, and adapt.

For a project like BugLens AI, open-source development makes it possible for other developers to explore the application architecture, understand how the frontend communicates with the backend, and experiment with different AI integrations.

AI tools can help accelerate development, but the real value comes from understanding how the pieces work together and turning an idea into a usable application.

As a student and developer, building BugLens AI has given me an opportunity to explore AI integration, backend development, deployment, and the practical challenges involved in bringing a project online.

I hope the project can help make debugging less intimidating for beginners and inspire other developers to experiment with AI-powered tools of their own.

The Lazy Payoff

Imagine spending 20 minutes checking the same loop, searching for an off-by-one error, or trying to understand a confusing compiler message.

BugLens AI aims to shorten that frustrating process by bringing code analysis, possible explanations, and suggested fixes together in one place.

Of course, AI-generated suggestions are not guaranteed to be correct. Developers should review the explanations, verify the proposed changes, and test their code before relying on a fix.

The real payoff isn't avoiding the learning process. It's spending less time stuck on the same problem and more time understanding algorithms, solving programming challenges, and building projects.

BugLens AI is built around one simple idea: spend less time hunting for bugs and more time becoming a better developer.

ListingCraft AI: Create E-Commerce Listings with Open-Source AI

Vishnu Yadla — Sat, 17 Oct 2026 14:56:08 +0000

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

What I Built

ListingCraft AI is an AI-powered product listing generator that helps small business owners, online sellers, resellers, and handmade-product creators create professional product listings using open-source AI.

Sellers often spend significant time writing product titles, descriptions, selling points, and SEO keywords for different e-commerce platforms. ListingCraft AI simplifies this process by generating platform-specific product content from basic product information.

Key features include:

AI-generated product titles and alternative titles.
SEO-friendly descriptions, selling points, keywords, and tags.
Support for Amazon, Etsy, Shopify, and general marketplaces.
Listing quality scores and improvement suggestions.
Editable results with copy and export functionality.
A saved listings library with search, filtering, duplication, and deletion.
Local-first storage and optional local AI inference.

The project is designed to help small sellers save time and create better-organized product listings without requiring a paid cloud AI API.

Demo

2026-10-17 19-54-31.mp4 - Google Drive

drive.google.com

Code

vishnuyadla22-cmd / Listing-Craft-AI

ListingCraft AI 🛍️⚡

Local Open-Source E-Commerce Product Listing Generator
Turn basic product details and notes into high-converting, platform-optimized product listings using local open-weight AI (Qwen2.5 3B via Ollama). Zero paid APIs. Zero cloud tracking. 100% privacy.

1. Project Overview

ListingCraft AI is a full-stack SaaS-grade application built for small business owners, online sellers, resellers, and handmade-craft creators. Creating compelling, SEO-rich product listings for platforms like Amazon, Etsy, and Shopify is time-consuming and often requires expensive monthly copywriter subscriptions.

ListingCraft AI solves this by deploying an open-weight instruction model locally to instantly generate:

SEO-optimized titles tailored to platform character limits.
Alternative title variations for A/B testing and split campaigns.
Conversion-focused product descriptions (short marketplace excerpt + full markdown copy).
Formatted key selling points (Amazon-style bracketed benefits, Etsy artisanal craftsmanship bullets).
High-intent search keywords & marketplace tags.
Clear calls to action (CTA).
Listing Quality Score (0–100) with real-time…

View on GitHub

How I Built It

I built ListingCraft AI using React 18, TypeScript, Vite, and Tailwind CSS for the frontend, with Python and FastAPI powering the backend.

The AI integration uses Qwen2.5 3B Instruct through Ollama for local inference. The backend validates product information, constructs marketplace-specific prompts, and returns structured listing content.

The application supports generating titles, descriptions, selling points, keywords, tags, and calls to action. Users can edit generated content, save listings in browser localStorage, and export their results.

I also implemented an explicitly labelled Demo Mode for testing the application without a running local AI model.

The project includes API validation, error handling, backend tests, and a production frontend build.

Why Does Open Innovation Matter?

Open innovation makes AI technology more accessible to independent developers and small businesses.

By using an open-weight model with local inference, ListingCraft AI can generate product listings without requiring a paid cloud AI API. This provides greater control over the inference environment and makes it easier to experiment with different models and prompts.

Combining open-source technologies such as React, FastAPI, and Ollama demonstrates how developers can build practical AI-powered applications without depending entirely on proprietary AI services.

TrailWhisper: Screen-Free Audio Companion for Nature Trails with Local AI

Vishnu Yadla — Sun, 11 Oct 2026 11:31:43 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

TrailWhisper is a lightweight, audio-first trail companion designed to get outdoor enthusiasts looking up at the canopy instead of staring down at a glass screen.

Standard nature identification apps force users into the screen trap: pull out a smartphone, frame a photo, fiddle with camera focuses, and scroll through long text descriptions.

TrailWhisper flips this interaction model on its head:

Audio-First Sound ID: Hikers tap one large button to capture ambient bird and wildlife calls, keeping visual focus entirely on the trail.
Spoken Naturalist Observations: The app processes the audio and immediately speaks the species identity and a short, vivid behavioral fact back through headphones or device speakers using browser speech synthesis.
Hands-Free Timeline Journal: Every identified species is stored in a clean, local SQLite database with timestamps and confidence ratings, giving hikers a complete log to review when back at camp.
Who It Is For: Hikers, trail runners, birdwatchers, outdoor educators, and anyone wanting to "Touch Grass" without digital distraction.

Demo

Local Web App Interface: Runs completely in the browser via http://localhost:8000.
User Flow:
1. One tap triggers a 5-second ambient sound capture via device microphone.
2. The backend identifies the wildlife audio signature.
3. A local open-weight AI model synthesizes a 2-sentence conversational field note.
4. The browser reads the note aloud instantly and writes the entry to the on-screen Trail Journal timeline.

2026-10-11 16-36-23.mp4 - Google Drive

drive.google.com

Code

You can find the complete source code and setup instructions on GitHub:

vishnuyadla22-cmd / Trailwhisper

🌲 TrailWhisper — Offline AI Trail Companion

Listen closer. Discover more.
An audio-first, 100% offline nature companion that identifies bird calls and teaches you about wildlife on the trail without screen staring or cloud dependency.

Built for Hacktoberfest. Designed for real nature walks where cellular signal drops to zero.

🌟 Features & Highlights

Audio-First Experience: Tap Record Audio, capture 5 seconds of nature sound, and let TrailWhisper do the rest.
Hands-Free Nature Audio Feedback: Speaks bird call insights out loud using the browser's native SpeechSynthesis API so you can keep your eyes on the trail.
100% Offline Architecture: Zero external CDNs, zero cloud APIs (Zero OpenAI/Anthropic), zero tracking. All assets, stylesheets, icons, and AI components run locally on your device.
Dual-Engine Bird Identification
- Local BirdNET Adapter: Employs local acoustic neural networks when model weights and dependencies are available.
- Deterministic Demo Classifier: If…

View on GitHub

How I Built It

TrailWhisper is architected around local-first, low-overhead open-source technologies:

Local Open-Source AI Inference: Powered by Ollama running the open-weight llama3.2:1b model on-device. It turns raw classification outputs into bite-sized, natural voice field notes in real time without querying remote cloud servers.
Resilient Offline Architecture: If Ollama or deep learning models are not active, the system seamlessly falls back to pre-compiled offline naturalist rules, ensuring the application remains 100% functional deep in the wilderness.
Backend: Built with Python, FastAPI, and Uvicorn for lightning-fast async audio uploads and payload handling.
Storage: Embedded SQLite database storing audio file references, bird species, confidence metrics, and observation timestamps completely offline.
Frontend & Web Audio API:
- Standard HTML5 / CSS3 / JavaScript — zero heavy node runtimes or bulky dependencies to preserve laptop/tablet battery on the trail.
- MediaRecorder API captures raw sound streams directly from the microphone.
- SpeechSynthesis Web API handles hands-free text-to-speech feedback.

Why Does Open Innovation Matter?

Open innovation is what makes TrailWhisper viable in the wilderness:

True Offline Independence: Closed commercial APIs (like OpenAI or cloud speech platforms) fail the second a hiker enters a national park or backcountry canyon without cellular data. Open-source local inference (llama3.2:1b via Ollama) guarantees the software works anywhere on Earth.
Privacy on Public Lands: Location data, ambient recordings, and trail logs remain strictly on the user's local hardware—no cloud tracking, no mandatory telemetry, and no forced user logins.
Hardware Accessibility: Open-weight models like Llama 3.2 1B run easily on standard consumer laptops and low-power edge machines without needing expensive cloud GPU infrastructure.

My Agent Session

(If you used DevRelay to track your AI development session, insert your session tag or link here, or remove this section if not applicable)

Prize Categories

Week 1: Touch Grass (Main Track)

StockBuddy

Vishnu Yadla — Sat, 03 Oct 2026 23:15:19 +0000

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

What I Built

I built StockBuddy, a financial education platform and market simulation tool designed with a modern fintech aesthetic.

Who I Built It For & The Real Problem It Solves

I built this for my friend, Ritvik, who has been wanting to get into stock market analysis and investing. Every time he opened commercial brokerage or charting platforms, he felt overwhelmed by multi-line indicators (RSI, Moving Averages, MACD), cryptic financial jargon, and the paralyzing fear of losing real savings before understanding how technical analysis works.

He didn't want another dry spreadsheet, and he didn't trust generic chatbot wrappers that hallucinate financial advice. He needed a safe, interactive playground where he could test his own theories, observe how market indicators interact, and challenge an AI model without risking a single rupee.

How StockBuddy Solves This

Zero Real-Money Risk: Every user starts with ₹1,00,000 of virtual currency to experiment with simulated buy/sell orders and track portfolio allocation.
Human vs. AI Prediction Duel: Before seeing any machine learning predictions, Aryan locks in his own direction forecast (UP, SIDEWAYS, DOWN) and confidence percentage. Only then does the app reveal the ML model's inference and compare their reasoning side-by-side.
Context-Aware AI Tutor (Not a Chatbot Wrapper): The open-source AI engine receives actual structured application payloads (RSI, MA20/MA50 ratios, MACD histograms, price momentum, volatility) to explain why signals trigger in plain, beginner-friendly language.
What-If Scenario Simulator: Interactive sliders let him adjust variables like RSI or volume to visually observe how market shifts would alter model outputs in real time.
Honest Financial Disclaimer: Model outputs are framed strictly as experimental probabilistic forecasts, reinforcing that no model can predict the future.

Demo

StockBuddy - Google Drive

drive.google.com

Key Views Implemented:

Interactive Dashboard: Live portfolio P&L, indices, watchlist, and test accuracy metrics derived from unseen historical splits.
Markets & Live Stock Detail: Multi-timeframe charts (1D to 1Y) with live data from Yahoo Finance API, paired with modular technical indicator cards.
Human vs. AI Arena: Gamified prediction duel with locked-in user predictions and comparison cards.
AI Lab: Context-aware assistant that parses structured stock JSON with instant quick-action prompts ("Explain RSI", "Why Bullish?", "Beginner Mode").
Virtual Portfolio Engine: Live simulated trade execution, position tracking, asset distribution, and transaction auditing.

Code

vishnuyadla22-cmd / StockBuddy

Hacktoberfest Project-1

StockBuddy 🚀

Tagline: "Challenge the market. Challenge the AI. Learn without risking real money."

StockBuddy is an advanced interactive stock-market learning and prediction simulation platform built for Hacktoberfest 2026. Designed with a startup-quality fintech aesthetic, StockBuddy empowers beginners to explore stock analysis, study technical indicators, challenge an open-weight AI prediction model, run hypothetical "what-if" scenarios, and maintain a virtual portfolio with ₹1,00,000 of simulated capital.

🌟 Hacktoberfest 2026 Highlight: Why Open-Source / Open-Weight AI?

Open-weight and open-source AI models (e.g. Qwen2.5, Llama-3, Mistral via local Ollama/vLLM endpoints) are central to StockBuddy's mission for three key reasons:

Complete Data Privacy & Local Control: Financial learning involves personal preferences, risk tolerance, and trading scenarios. Running open-weight AI locally ensures that sensitive user queries and portfolio context never leave the user's machine.
Cost-Free Scalability & Zero Rate Limits: Proprietary API calls can quickly incur steep pay-per-token costs or hit…

View on GitHub

Architecture & Stack:

Frontend: React, TypeScript, Tailwind CSS, Recharts, Lucide Icons, Framer Motion
Backend API: Python, FastAPI, Uvicorn
Machine Learning: Scikit-Learn (Logistic Regression direction classifier with chronological time-series validation to prevent temporal data leakage)
AI & Market Services: Modular Yahoo Finance historical data provider and an open-weight LLM inference layer with deterministic structured heuristic fallbacks

How I Built It

Open-source and open-weight AI are the central nervous system of StockBuddy, not decorative add-ons:

Structured Application Payloads: Instead of piping arbitrary conversational text, our Python backend (backend/app/services/ai_service.py) structures live market states into structured JSON schemas:


json
   {
     "symbol": "TCS",
     "currentPrice": 3500.0,
     "rsi": 54.2,
     "movingAverage20": 3450.0,
     "movingAverage50": 3380.0,
     "volumeChange": 18.4,
     "volatility": 0.012,
     "mlDirection": "UP",
     "mlConfidence": 0.67
   }

My Hactoberfest 2026

Vishnu Yadla — Thu, 01 Oct 2026 11:13:35 +0000

One of the things I'm most excited about is getting hands-on experience with real-world projects and understanding how developers collaborate on open-source software. I want to improve not only my coding skills but also my ability to read existing code, solve problems, and work effectively with Git and GitHub.