DEV Community: Saurabh Kumar

SellCraft AI: Turn Product Photos into Ready-to-Use Listings with Open-Source AI

Saurabh Kumar — Thu, 15 Oct 2026 13:20:20 +0000

SellCraft AI is an AI-powered product listing generator designed for online sellers, small business owners, and independent entrepreneurs who want to create professional product listings without spending hours writing descriptions.

Selling products online involves more than uploading a photo. Sellers need compelling titles, clear descriptions, feature lists, and relevant keywords to make their products easier to discover. For small sellers managing dozens of products, creating this content manually can become repetitive and time-consuming.

SellCraft AI aims to simplify that process.

Users can upload a product photo, provide a few basic details, and generate editable listing content, including:

Product titles: Clear, descriptive titles for online marketplaces.
Product descriptions: Readable descriptions tailored to the product and its intended audience.
Key features: Organized bullet points highlighting important product attributes.
SEO keywords: Relevant search terms to help sellers improve product discoverability.
Writing styles: Different tones, such as professional, friendly, or concise.
Ready-to-use output: Copy or export the generated content for use in a product listing.

The goal is to help small sellers spend less time on repetitive writing and more time improving their products and serving customers.

Who Would Pay for It?

SellCraft AI is designed for independent online sellers, small e-commerce businesses, and social commerce entrepreneurs who regularly create product listings.

A potential business model could include a free tier for occasional use and affordable paid plans for sellers who need to generate listings in bulk.

Rather than building another general-purpose chatbot, I wanted to explore a focused AI tool that solves one specific business problem.

How I Built It

SellCraft AI is designed around open-weight AI rather than depending entirely on a proprietary, hosted AI API.

The planned architecture combines a modern web interface with a backend that handles product inputs, model inference, and structured output.

Technology Stack

Frontend: React, Vite, and Tailwind CSS
Backend: Python and FastAPI
AI inference: Ollama with a compatible open-weight vision-language model
Data validation: Pydantic
Local storage: SQLite, where persistence is needed

The vision-language model is intended to interpret product images alongside user-provided details and generate structured listing content. The backend validates the output before returning it to the interface.

The model choice will depend on its image-understanding capabilities, license, hardware requirements, and performance on the available development machine.

One important design decision is to keep the AI layer replaceable. This makes it possible to experiment with different compatible models without redesigning the entire application.

Why Does Open Innovation Matter?

For a small business tool, the economics of AI matter as much as the quality of its output.

A product that generates useful descriptions but costs too much to operate can be difficult to sustain, especially when serving customers with limited budgets.

Open-weight AI offers several advantages for SellCraft AI.

1. More Control Over Costs

Running a compatible model locally can reduce dependence on per-request API pricing. This could make frequent listing generation more economical, although hardware, electricity, and hosting still have costs.

2. Greater Control Over Data

With local inference, product images and business information can remain on the user's machine rather than being sent to a third-party AI inference service.

This depends on the deployment configuration. A hosted version would need its own privacy and data-handling considerations.

3. Freedom to Experiment

Different models may perform better on different products, languages, and writing styles. An open-weight approach makes it easier to compare models and customize the workflow for particular seller communities.

4. Less Dependence on a Single Provider

The application can be designed with a replaceable model layer, reducing the risk of being locked into one provider's API, pricing, or availability.

5. A More Accessible Starting Point

Open-weight models and open-source frameworks give individual developers and small teams the opportunity to experiment with AI-powered products without first building their own models.

For SellCraft AI, open innovation is not simply a technology preference. It is part of exploring whether an affordable, customizable AI product can be practical for small sellers.

My First User

The next validation step is to put SellCraft AI in front of an online seller or local business owner.

I want to learn whether the generated listings save meaningful time, whether sellers need better control over tone and product details, and whether the tool provides enough value to justify paying for it.

I will use that feedback to prioritize improvements and evaluate the potential pricing model.

What's Next?

Potential future improvements include:

Bulk generation for product catalogs
Support for additional languages
Custom templates for different marketplaces
Better product-specific terminology
Listing history and reusable brand preferences
Evaluation of output quality across different open-weight models

The immediate priority is a reliable end-to-end workflow that produces useful, editable listings.

Conclusion

SellCraft AI explores a simple idea: open-source AI should help people do useful work, not just demonstrate what a model can generate.

By focusing on the repetitive work of writing product listings, the project aims to make AI more practical for independent sellers and small businesses.

The bigger question is whether an open-weight model can deliver enough quality, privacy, and cost control to support a genuinely useful small business product. SellCraft AI is my attempt to explore that possibility.

Thanks for reading!

GreenPulse: Offline Field Cartography and On-Device Botanical AI with Gemma 2

Saurabh Kumar — Thu, 08 Oct 2026 07:59:13 +0000

What I Built

Modern outdoor apps suffer from a fundamental paradox: they promise to connect people with nature, but demand constant screen engagement through badges, ads, and telemetry feeds. Furthermore, conventional AI applications depend entirely on cloud APIs, failing the moment a hiker or trail runner enters a dense tree canopy with zero cellular reception.

GreenPulse is a lightweight, mobile-responsive field cartography and botanical identification system engineered around one core principle: make screen engagement the shortest part of the outdoor experience.

Before leaving for a trail, GreenPulse uses Google's open-weight Gemma 2 model to synthesize structured field corridors and botanical target checklists based on local terrain. On the trail, the runner or walker receives a concise 14-second spoken audio briefing via the Web Speech API, allowing them to pocket their device and keep their eyes on the path. When an explorer spots a target specimen (such as a Sugar Maple leaf or White Oak bark), an on-device computer vision pipeline verifies the specimen locally in 36 milliseconds, logging the observation to a client-side catalog with zero external data transmission.

GreenPulse is built for field researchers, trail runners, naturalists, and anyone who wants to explore the outdoors without digital distractions or subscription paywalls.

Demo

Live Deployed Application: https://greenpulse-six-pi.vercel.app/
Target Platform: Desktop and mobile browsers (iOS Safari, Android Chrome, Desktop Edge/Firefox).

Key functional workflows available in the live demo:

Field Routes: View structured corridors, execute Gemma 2 route synthesis, review target waypoints, and listen to the spoken route briefing.
Spatial GIS: Real-time Leaflet cartography powered by OpenStreetMap standard vector tiles, coordinate tracking, and corridor simulation.
On-Device Vision Classifier: Camera viewport with real video stream support and benchmark test specimens, evaluating classification probabilities and latency in milliseconds.
Cataloged Records: Review verified field observations with coordinate timestamps and export data as an RFC 4180 compliant CSV log.

Code

The source repository is open-source under the MIT License:

Saurabhtbj1201 / GreenPulse-Field-Cartography-Botanical-Identification

Offline outdoor route generation and on-device botanical classification running on open-weight models.

GreenPulse: Offline Field Cartography & Botanical Analysis

Offline outdoor route generation and on-device botanical classification running on open-weight models.
Built for the Hacktoberfest 2026 Open-Source AI Challenge: Week 1 ("Touch Grass").

Live Demo • System Architecture • Core Capabilities • Offline AI Rationale • Getting Started • Deployment • Developer Information

Technical Overview

GreenPulse is a high-utility spatial cartography and botanical analysis tool designed for field workers, naturalists, and outdoor trail runners.

Traditional mobile field utilities require constant cellular connectivity and continuous screen engagement. GreenPulse operates on a different model:

Spatial route computation and botanical targets are generated prior to departure using open-weight models (Gemma 2).
Spoken route briefings allow hands-free traversal without staring at mobile displays.
Botanical verification executes locally inside the browser runtime using WebAssembly and ONNX, requiring zero cellular connectivity and transmitting zero images to remote servers.

Core Capabilities

Offline GIS Cartography: Interactive spatial navigation using OpenStreetMap…

View on GitHub

Repository Structure:

index.html: Semantic, accessible structure with high-contrast UI designed for outdoor sunlight legibility.
src/main.js: Gemma 2 route synthesis handler, Leaflet GIS integration, on-device vision pipeline, and audio synthesis.
src/style.css: Clean, utilitarian design system built with Vanilla CSS; strictly avoids purple gradients, novelty animations, and pill radii.
public/favicon.svg: Vector icon optimized for browser tabs.

How I Built It

GreenPulse is built from the ground up without heavy frameworks or bloated abstractions.

1. Spatial Route Engine (Google Gemma 2)

The corridor synthesis logic is designed around Gemma-2-9b-it (4-bit quantized for local edge inference). Gemma 2 processes spatial and ecological prompts (terrain type, season, microclimate, target distance) to generate deterministic route waypoints and specimen targets formatted as strict JSON payloads. This eliminates proprietary route-planning APIs and allows field teams to run customized models on local laptops or edge micro-servers.

2. On-Device Visual Classification (MobileNetV2 ONNX / WebAssembly)

Rather than uploading high-resolution field photos to remote cloud endpoints, GreenPulse runs vision inference directly within the browser runtime using WebAssembly. The classifier computes top-1 class distributions and softmax probabilities (e.g., Acer saccharum, probability 0.964) with sub-40ms latency.

3. Open Spatial Cartography (Leaflet + OpenStreetMap)

Spatial navigation uses standard EPSG:3857 OpenStreetMap vector tiles. Waypoint polylines and coordinate markers are plotted with standard Leaflet layers, ensuring offline tile caches can be utilized when venturing away from cellular range.

4. Hands-Free Auditory Guidance

To fulfill the "Touch Grass" requirement of minimizing screen interaction, route narratives are dispatched through the browser SpeechSynthesis engine. Field explorers can initiate the audio briefing with one tap, put their phone in their pocket, and receive their trail directions hands-free.

Why Does Open Innovation Matter?

Open-source AI was not merely an architectural choice for GreenPulse; it is an absolute functional prerequisite.

Zero-Signal Resilience: Cell towers do not cover deep wilderness trails, ravines, or national forests. Closed AI APIs (such as OpenAI or Anthropic) fail completely with zero bars of signal. By running open-weight models locally on device, GreenPulse remains 100% operational in remote environments.
Complete Data Sovereignty & Privacy: Field GPS tracks, running routes, and environmental photographs represent sensitive personal location data. In GreenPulse, coordinates and images never leave the client device, preventing commercial tracking or profiling.
Zero Operating Costs & Open Democratization: Closed APIs impose recurring token costs and subscription tiers that make persistent outdoor utilities inaccessible to casual hikers and student field biologists. Open weights provide unlimited, zero-cost inference indefinitely.

My Agent Session

This application was conceptualized, structured, and developed using paired agentic workflows. The complete implementation transcript, architecture diagrams, and testing logs are preserved:

Agent Framework: Antigravity IDE / DevRelay Gateway
Session Reference: a8e3cf6b-c01c-42c3-a0f1-7e9d1e064c50

Prize Categories

Google Gemma Category: Built with Google's open-weight Gemma 2 model family at its computational core for spatial corridor synthesis and ecological prompt reasoning.
Overall Hacktoberfest Week 1 ("Touch Grass"): Designed specifically to minimize screen time, eliminate cloud tethering, and enable genuine outdoor exploration through hands-free audio briefings and on-device botanical verification.

BugWhisperer — Voice-First Diagnostic Assistant for Developers

Saurabh Kumar — Sat, 03 Oct 2026 09:45:08 +0000

What I Built

I built BugWhisperer for my friend, a remarkably talented software engineer who lives with ADHD.

For neurodivergent builders, a broken build isn't merely an inconvenience—it's an ambush. When an unexpected 80-line red stack trace floods the terminal, it triggers immediate cognitive overload, rapid heartbeat, and decision paralysis. Staring into dense call frames feels visually overwhelming, and the common workaround—switching tabs to dump logs into ChatGPT or scan Stack Overflow—breaks hyper-focus flow states and pulls developers into hour-long context-switching rabbit holes.

BugWhisperer transforms chaotic terminal errors into a calm, empathetic audio conversation.

Whether piped directly from your terminal (pytest 2>&1 | python cli/bugwhisper.py) or pasted into the distraction-free web dashboard, BugWhisperer uses Google's Gemma 2 to strip away the noise, explain the root cause in plain English, and isolate THE ONE next action to take.

Then, powered by ElevenLabs Turbo v2.5, it speaks the guidance aloud in a warm, reassuring human tone—acting like an empathetic senior pair programmer sitting right beside you, saying:

"Take a breath. You're doing great. It's just a missing null-check on line 42."

Demo

🌐 Live Web Companion: https://bugwhisperer.onrender.com (Hosted on Render)
💻 Terminal CLI Pipe: npm test 2>&1 | python cli/bugwhisper.py
📑 Project Case Study: gu-saurabh.tech/project/8babe8cb-294b-48c5-8e29-3d280992cefa

What my friend said when testing it:

"When my build broke, hearing a calm voice validate that this happens to everyone before giving me just ONE thing to fix made my anxiety drop instantly. I didn't have to read through 40 lines of Webpack noise." — my friend

Code

Saurabhtbj1201 / BugWhisperer-Voice-First-Diagnostic-Assistant-for-Developers

An Empathetic Voice Debugger for My ADHD Friend Built with Gemma 2 & ElevenLabs

🦆 BugWhisperer

Voice-First Diagnostic Companion for Developers with Cognitive Overload & ADHD

Explore Live Web App • Project Details • DEV Submission Draft • Report Issue

Modern light-orange cognitive interface featuring Gemma 2 root-cause reasoning and ElevenLabs audio companion

📖 Table of Contents

🌟 The Story: Built for My Friend

My friend is a remarkably talented developer who lives with ADHD. When complex code breaks or an unexpected 80-line red stack trace floods the terminal, it triggers sudden cognitive overload, anxiety, and decision paralysis.

The Pain Point:

🛑 Overstimulation: Walls of red terminal text and Webpack frames cause immediate mental fatigue.
🔄 Context Switching Traps: Tab-switching to Stack Overflow or ChatGPT fractures hyper-focus and pulls developers into…

View on GitHub

How I Built It

BugWhisperer is designed from the ground up for minimal cognitive load. The stack combines a lightweight Python FastAPI backend, a sharp light-orange companion dashboard, real-time Web Audio API waveform rendering, and a native CLI pipe utility.

1. Open-Source AI Core (Gemma 2)

Standard LLMs produce 500-word academic lectures with 5 different possibilities, which paralyzes someone with ADHD. We conditioned Google Gemma 2 (9B / 2B) with a specialized Cognitive Pacing Schema:

Empathy First: A short validation note to regulate stress.
Plain-English Cause: Two sentences maximum, stripping technical jargon.
The Single Next Action: Only one line of code or one file to inspect. No choice overload.
Conversational Spoken Script: Formatted specifically for audio synthesis (removing raw syntax characters like {}, =>, or unpronounceable regex tokens).

2. Voice Engine (ElevenLabs Turbo v2.5)

The generated spoken script streams through ElevenLabs Turbo v2.5 using an empathetic voice profile tuned for calm pacing and reassurance. The frontend includes an automatic graceful fallback to the browser Web Speech API, ensuring full offline accessibility.

3. Log Sanitizer & Privacy Shield

Before any log reaches the AI engine, an automated sanitizer strips ANSI terminal escape sequences and masks local filepaths (e.g., C:\Users\username\... → ~/...), protecting sensitive user directories.

4. Observability & Telemetry (Sentry Agent Tracing)

Every debugging interaction is traced using the Sentry SDK. Sentry records custom AI agent spans, measuring token consumption, LLM reasoning latency, and ElevenLabs audio roundtrip latency.

Why Does Open Innovation Matter?

Open-source AI isn't an implementation detail in BugWhisperer; it is the reason the project can exist:

Confidentiality & Code Privacy:
Developers routinely debug proprietary code containing internal API routes, business logic, and private filepaths. Sending full stack traces to closed corporate APIs creates immense compliance and security liabilities. With Gemma 2, developers can run inference 100% locally via Ollama on their machine—no logs ever leave the local network.
Zero Subscription Paywall for Accessibility:
Neurodivergent assistive tools should not require an ongoing $20/month proprietary API tax. Open weights democratize developer accessibility for students and independent builders worldwide.
Prompt & Behavior Sovereignty:
Closed APIs regularly shift their behavior and prompt responses without notice. By anchoring on open weights, BugWhisperer’s tailored cognitive pacing remains consistent, auditable, and reliable over time.

My Agent Session

This project was pair-programmed and architected using an AI coding agent session. The session drove the iterative design from the initial concept:

Rapid prototyping of the ADHD cognitive prompt schema with Gemma 2.
Structuring the dual-interface workflow (CLI pipe utility + modern light-orange companion dashboard).
Implementing Sentry agent telemetry and ElevenLabs audio streaming.
Refining the user interface based on neurodivergent accessibility feedback: replacing visual clutter with sharp, high-contrast action cards, a step-by-step parsing indicator, and a one-click Deep Focus Mode.

Prize Categories

I am submitting BugWhisperer for the following partner categories:

🌟 Best Use of Gemma (Featured - $200): Google Gemma 2 is the core reasoning brain powering the log diagnosis, plain-English translation, and spoken conversational script.
🚀 Best Use of Render (Featured - $200): Fully automated deployment on Render using Infrastructure as Code (render.yaml).
🎙️ Best Use of ElevenLabs (Partner - $100): Turbo v2.5 voice synthesis giving voice to the rubber-duck companion.
📊 Best Use of Sentry Agent Tracing (Partner - $100): Telemetry and span tracing capturing token usage and latency metrics.

How do you handle developer anxiety and cognitive overload during marathon debugging sessions? I'd love to hear your thoughts and feedback in the comments!