DEV Community: Naresh Kumawat

Submit to the week 4 DEV Challenge

Naresh Kumawat — Tue, 27 Oct 2026 18:36:37 +0000

Lazy — A Ghost That Organizes Your Digital Chaos 👻

What I Built

Lazy is the ghost that quietly haunts your cluttered desktop—not to scare you, but to resurrect order from digital chaos. Inspired by the Ghost in the Machine theme, Lazy brings forgotten files, abandoned projects, and years of accumulated digital clutter back under control using open-source AI. It acts like a silent digital guardian, scanning messy folders such as Downloads and Desktop, intelligently categorizing files, and proposing an organized structure without moving anything until you approve it.

Unlike traditional AI file organizers that require uploading private documents to cloud services, Lazy follows a local-first, privacy-respecting approach. Your files never leave your disk, and when cloud AI is enabled, only filenames and extensions are evaluated. Every file operation is review-first, with collision-safe moves, automatic renaming or skipping instead of overwriting, and one-click undo backed by SQLite transaction logs. Obvious file types are handled through deterministic rules with zero AI tokens and minimal latency, while open-weight models such as Qwen, Llama, and Gemma handle ambiguous filenames. With local inference through Ollama, optional hosted inference providers, and a fully offline rules-only mode, Lazy makes intelligent file organization accessible, private, and free from vendor lock-in.

Demo

Live Demo: https://lazydesk-web.onrender.com

Source Code

GitHub: https://github.com/Nareshkumawat-star/lazy-desk

How I Built It

Lazy uses a secure two-tier architecture wrapped in a native desktop application.

Electron Desktop Shell
(Context Isolation, Sandbox, Native File Picker)
                |
                v
Next.js 15 Frontend
(React, TypeScript, Tailwind CSS, Lucide Icons)
                |
                | Typed HTTP + Loopback
                | X-Lazy-Token Header
                v
FastAPI Local Service
(Python 3.12, 127.0.0.1:8765)
                |
                +-- Categorization Engine
                |   (Rules + Open-Weight Models)
                |
                +-- Collision-Safe Operation Planner
                |
                +-- SHA-256 Duplicate Detection
                |
                +-- SQLite Storage
                    (Sessions, Operations, Rules,
                     Embeddings)

Technology Stack

Desktop: Electron
Frontend: Next.js 15, React, TypeScript, Tailwind CSS, Lucide Icons
Backend: Python 3.12, FastAPI
Database: SQLite
Local AI: Ollama with Qwen 2.5, Llama 3.2, Phi-3 Mini, and Gemma 2
Embeddings: nomic-embed-text
Hosted inference: Pollinations, Groq, OpenRouter, and Hugging Face adapters
Security: Context isolation, sandboxing, strict path validation, and collision-safe file operations
Deployment: Render Blueprint for the web demo and supporting services

User Workflow

Scan: Select a cluttered folder, such as Downloads or Desktop, and let Lazy scan its files.
Categorize: The rules engine and optional AI model classify files into meaningful categories.
Review: Preview the proposed organization and inspect every suggested move before approving.
Organize: Approve the plan and let Lazy safely move files, renaming or skipping conflicts instead of overwriting existing files.
Undo: Restore files to their original locations with one-click Undo if needed.

The entire workflow prioritizes user control, privacy, and safe file management, with offline, rules-only operation available when AI is not needed.

Open-Source AI and Local Inference

Lazy supports local inference through Ollama, including:

Qwen 2.5
Llama 3.2
Phi-3 Mini
Gemma 2

Semantic search uses the nomic-embed-text embedding model. For users who prefer hosted inference, optional adapters support Pollinations, Groq, OpenRouter, and Hugging Face.

Lazy uses structured JSON extraction and Pydantic validation to treat model responses as untrusted input. Suggested categories are checked against defined values, and model output cannot directly determine arbitrary filesystem paths.

Deterministic rules handle obvious file types, such as images, videos, and PDFs, without AI inference. Open-weight models are reserved for ambiguous filenames that require more contextual interpretation.

Defensive Filesystem Safety

When working with personal files, safety is just as important as intelligence.

Lazy includes several protective mechanisms:

Symbolic links are not traversed during scans or moves.
Directory traversal attempts, such as ../, are blocked through path validation.
Source files and destination paths are validated before operations.
Existing files are never overwritten; conflicts are renamed or skipped.
Undo operations validate source and destination paths before restoring files.
SQLite records operation history to support safe recovery.
SHA-256 hashing helps identify duplicate files.

These safeguards help ensure that AI recommendations remain suggestions rather than unrestricted commands over the user's filesystem.

Why Does Open Innovation Matter?

When dealing with a user's personal desktop, privacy is paramount. Traditional proprietary tools may require subscriptions, rely on closed cloud services, or send sensitive information to external systems.

Open innovation makes Lazy possible in ways that closed, cloud-dependent systems may not.

True Local Privacy: Open-weight models such as Qwen, Llama, and Gemma allow file categorization to run on the user's own machine. In local mode, file information can remain on the device without being sent to an AI provider.

Works Without Internet: Lazy offers a rules-only mode for basic file organization without requiring an internet connection or an external AI service.

No Paywalls or Vendor Lock-In: Users can choose local models, supported hosted inference providers, or rules-only processing based on their hardware, preferences, and budget.

Verifiable and Extensible: The open-source code allows developers and security researchers to inspect the implementation, contribute improvements, and experiment with different models and categorization strategies.

For Lazy, open innovation is not just a technical choice. It gives users more control over their files, their AI models, and the tools they depend on.

Prize Categories

Best Use of Render

Lazy includes a Render Blueprint (render.yml) designed to configure the FastAPI service and exported Next.js frontend, with service-token wiring, explicit CORS restrictions, and health checks.

Best Use of Gemma

Lazy supports Gemma 2 (gemma2:2b) for lightweight file categorization, making it a suitable option for users experimenting with local inference on compatible hardware.

Team Leader

Username: nareshkumawatstar

Final Thoughts

Lazy is built around a simple idea: your computer should handle the boring work while you stay in control. By combining open-source AI, local-first architecture, deterministic automation, and safe file operations, Lazy turns digital clutter into an organized workspace without making privacy the price of convenience.

Sometimes, the best ghost is the one that quietly cleans up after you.

Submit to the week 3 DEV Challenge(hactoberfest)

Naresh Kumawat — Tue, 20 Oct 2026 19:54:03 +0000

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

What I Built

LazyDesk is a local-first, privacy-respecting desktop application that scans messy folders (like your overflowing Downloads or cluttered Desktop), computes an intelligent category-based structure, and moves only the files you explicitly approve.

Most AI file tools expect you to hand over access to your private folders and upload documents to third-party cloud APIs. LazyDesk takes the "Slow and Steady" approach:

Your files never leave your disk: File contents are never uploaded to remote servers. When cloud AI is enabled, only file names and extensions are evaluated.
Review-First & Zero Overwrites: AI proposes moves; it never executes them in the dark. Every conflict is auto-renamed or skipped, never overwritten.
Instant 1-Click Undo: Every operation is logged in an ACID SQLite transaction. If you change your mind, hit Undo and your files return to their exact original locations safely.
Deterministic Fallback: For obvious files (.jpg, .mp4, .pdf), deterministic rule-matching works with 0 tokens and 0 latency. Open-weight AI is reserved for ambiguous filenames like tax_return_final_v2 or project_draft_october.
Zero Cost & Free Tiers: Fully functional with local open-weight models via Ollama (qwen2.5, llama3.2, gemma2), free hosted inference (Pollinations, Groq, OpenRouter, Google AI Studio), or in 100% offline rules-only mode.
Whoever has an unmanageable Downloads directory can finally sit back, be a little lazier, and let LazyDesk do the boring chores.

Demo

Live Hosted Demo: https://lazydesk-web.onrender.com

Code

github link : https://github.com/Nareshkumawat-star/lazy-desk

How I Built It

LazyDesk is engineered as a secure two-tier local system wrapped in a native desktop shell:
Electron Desktop Shell (Context Isolation, Sandbox, Native Picker)
│
├──► Next.js 15 UI (React, Tailwind CSS, Lucide Icons, TypeScript)
│ │ (Typed HTTP + Loopback + X-LazyDesk-Token Header)
│ ▼
└──► FastAPI Local Service (Python 3.12, 127.0.0.1:8765)
├── Categorization Engine (Rules + Open-Weight Model Registry)
├── Collision-Safe Operation Planner (shutil.move with validation)
├── SHA-256 Deduplication Scanner
└── SQLite Storage (Sessions, Operations, Embeddings, Rules)

Open-Source AI Stack & Local Inference Local Inference via Ollama: Supports private on-device models such as qwen2.5:7b, llama3.2:3b, phi3:mini, and gemma2:2b. Semantic search embeddings use nomic-embed-text. Zero-Setup Free Cloud Inference: Defaults to Pollinations (gpt-oss-20b) without any API key or signup required, with optional adapters for Groq (Llama/Qwen), OpenRouter free open-weight tiers, and Hugging Face. Structured JSON Extraction with Pydantic: Model responses are treated as untrusted text. Outputs are parsed and validated strictly against defined categories to prevent prompt hallucinations or path injection.
Defensive Filesystem Safety Symlinks are never traversed during scans or moves. Directory traversals (../) are actively blocked by strict boundary validators. Pre-move and pre-undo validation passes verify that source files still exist and target destinations are completely collision-safe before touching disk. ## Why Does Open Innovation Matter? When dealing with a user's personal desktop, privacy is paramount. A traditional proprietary tool demands subscriptions, ties you to proprietary cloud endpoints, and uploads your documents to black-box commercial APIs.

Open innovation made LazyDesk possible in ways closed APIs cannot:

True Local Privacy: Open-weight models (Qwen, Llama, Gemma) allow complex natural-language file interpretation to happen entirely inside the user's laptop RAM without sending a single byte outside.
No Paywalls or Vendor Lock-in: By decoupling the organization logic from proprietary APIs, anyone can run LazyDesk forever with zero operational costs.
Verifiable Auditability: Because the models, FastAPI backend, and Electron preload bridges are open-source, users and security researchers can verify that their personal files remain strictly on their hard drive.

Prize Categories

Best Use of Render: LazyDesk includes a production-ready, schema-validated render.yml Render Blueprint that provisions both the Python FastAPI service and the exported Next.js static front-end with automatic service token wiring, explicit CORS origin restrictions, and health check probes.
Best Use of Gemma: Supports local and hosted Gemma 2 (gemma2:2b) inference for efficient on-device categorization and lightweight CPU/GPU setups.

Team leader (username):nareshkumawatstar

Seller AI — Open-Weight AI Listing Studio for Solo Sellers & Side Hustles

Naresh Kumawat — Sat, 17 Oct 2026 17:43:18 +0000

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

What I Built

Solo sellers, makers, and side-hustlers — selling on Etsy, eBay, Shopify, or local markets — spend countless tedious hours writing product titles, descriptions, keyword tags, and SEO metadata.
For someone testing a side hustle or making an extra $200–$500 a month, paying a $20–$40/month subscription for a proprietary AI listing SaaS is a massive friction point that directly eats their margins.
Seller AI is an open-source, local-first AI workspace built specifically for small online sellers. It turns raw, bullet-point product notes and photos into marketplace-ready, high-converting product listings in seconds:

4-in-1 Marketplace Formats: Generates listings tailored to the strict rules and character limits of Generic e-commerce, Shopify, Etsy, and eBay.
Alternative Titles & SEO Metadata: Generates multiple catchy title hooks, meta descriptions, and algorithmic search tags.
Multilingual & Regional Commerce: Supports English, pure Hindi (Devanagari script), and bilingual listings for sellers targeting regional and global buyers.
Local Vision Analysis: Capability-aware image analysis for product photos running on open-weight vision models (like qwen2.5vl:3b) without sending unreleased product photos to third-party clouds.
Zero Lock-In & Complete Privacy: Client data and product ideas never leave the machine. Listings are stored locally in the browser (localStorage), with 1-click copy for individual fields, copy-all, and export to TXT, CSV, and JSON.

Demo

deplyed link: https://seller-ai-ldyl.onrender.com

Code

GitHub Repository: https://github.com/Nareshkumawat-star/seller-ai-

How I Built It

Open-Source AI Stack Seller AI is powered entirely by open-weight models running on local inference through Ollama:

Text & Copywriting: qwen2.5:3b (or llama3.2:3b / mistral:7b) for lightweight, high-efficiency generation.
Vision Extraction: qwen2.5vl:3b for extracting physical attributes, materials, and colors from product photos.

Architecture & Reliability Patterns Prompt Isolation & Security: User input is strictly isolated inside blocks with system-level instruction guarding against prompt injection. Structured JSON Mode: The model is prompted with format: "json". Responses pass through a robust extraction pipeline that handles markdown code fences, comments, and chatter, followed by Zod runtime schema validation. Language Verification Safeguard: Early tests revealed that smaller models sometimes claim language: "hi" while still returning English body text. We implemented a Unicode script analyzer (lib/ai/language-check.ts) that verifies Devanagari script density, automatically retries if English is detected, and flags unverified outputs. Hardware-Honest Health Check: /api/health queries Ollama's /api/tags and /api/show to verify if the configured models are actually pulled and vision-capable before the user triggers generation

Why Does Open Innovation Matter?

Zero Marginal Cost for Side Hustlers: When starting an Etsy shop or small handmade store, monthly API or SaaS subscriptions add financial anxiety before making the first sale. Open-weight models running locally cost $0 in recurring subscription fees.
Absolute Privacy for Unreleased Products: Artisans and inventors often draft listings weeks before launching novel designs, handcrafted jewellery, or secret recipes. With local open-source inference, proprietary photos and product concepts never leave their hard drive.
Freedom from Arbitrary Vendor Lock-in: Closed AI APIs frequently change pricing tiers, throttle requests, or deprecate models without warning. With open weights, the seller owns their entire software stack permanently.
Niche Customization: Because marketplace template prompts (lib/config/marketplaces.ts) are open code in the repository, any seller can add specialized rules for their niche platform (e.g., Poshmark, Mercari, Depop) without waiting for a SaaS company to build it.

My Agent Session

Prize Categories

eller AI includes a production-ready render.yaml blueprint configured to deploy the Next.js web application frontend on Render. It enables sellers or teams to deploy their studio front end to the web while pointing to their private, secure remote inference server via the OLLAMA_BASE_URL environment variable.

Team leader (username):nareshkumawatstar

Submit to the week 1 DEV Challenge(hactoberfest)

Naresh Kumawat — Fri, 09 Oct 2026 15:54:18 +0000

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

What I Built

TouchGrass AI is an open-weight, privacy-first outdoor companion. Instead of an infinite feed or endless chatbot conversations, it generates one personalized, safe outdoor micro-mission at a time—then explicitly asks you to put your phone away and step outside.
Key Features:
Personalized Micro-Missions: Tailored to your available time (5 to 30 mins), preferred activities (nature walks, photo hunts, sound mapping, plant observation), fitness level, local weather (via Open-Meteo), and nearby green spaces (via OpenStreetMap).
Distraction-Free Mission Mode: Once started, the interface strips away all non-essential UI, showing only a minimal timer, current objective, and the reminder: "Put your phone away 🌳".
Open-Weight Vision Discoveries: When you return, take a photo of a leaf, bird, insect, tree, or plant. An open-weight vision model provides a hedged identification, visual reasoning behind the guess, and safe natural facts.
Anti-Addictive Gamification: Points and leveling measure real minutes spent outdoors—never screen time or daily login streaks. No ads, no tracking, and zero streak guilt.
100% Offline & Local Capabilities: Runs completely offline using local open-weight models via Ollama and PWA caching.

Demo

https://touchgrass-ai-hwlk.onrender.com/

Code

https://github.com/Nareshkumawat-star/touchgrass-ai

How I Built It

Open-Source AI & Models
Text / Mission Generation: Qwen2.5-1.5B-Instruct (qwen2.5:1.5b) running locally via Ollama. Licensed under Apache-2.0, it runs in ~15-20 seconds on a standard laptop CPU while reliably generating structured JSON missions.
Vision / Photo Analysis: Qwen2.5-VL-3B-Instruct (qwen2.5vl:3b) via Ollama. An Apache-2.0 vision-language model used for identifying flora and fauna, providing visual feature breakdowns and educational facts without making unsafe medical or edibility claims.
Remote Hosted Fallback: Optional Hugging Face Inference API integration running Qwen/Qwen2.5-7B-Instruct and Qwen/Qwen2.5-VL-7B-Instruct for serverless/cloud deployments.
Zero-Failure Floor: OfflineTemplateProvider containing hand-crafted, reviewed outdoor templates used whenever no AI runtime is reachable.
Built-in Safety & Sanity Pipeline
All AI outputs pass through a strict server-side safety review (src/lib/safety.ts). Any mission suggesting trespassing, climbing dangerous heights, entering open water, approaching wildlife, or walking in traffic/darkness is automatically rejected and replaced with a reviewed safe template.

Why Does Open Innovation Matter?

Privacy & Data Sovereignty: Closed AI cloud endpoints require sending sensitive real-time location data and personal photo streams to third-party servers. Open-weight models running locally via Ollama ensure 100% of location context and camera photos stay on the user's device.
Offline Resilience & Zero Key Dependencies: Nature walks often happen in areas with low cell service. Open innovation makes it possible to generate AI missions and run vision identification deep in a forest trail with zero internet connection, zero API keys, and zero subscription fees.
Licensing Transparency: Proprietary APIs operate as black boxes. Open weights allow us to inspect exact weights, verify licenses (Apache-2.0), and present full licensing attribution directly to the user in the app UI.
Re-orienting AI for Human Well-Being: Closed commercial AI is structurally incentivized to maximize user retention and screen time. Open innovation gives developers the freedom to build AI tools designed specifically to disconnect users from digital screens and reconnect them with the physical world.

Prize Categories

Main Challenge: Touch Grass (Hacktoberfest Open-Source AI Challenge Week 1)
Open-Source AI / Open Weights Track: Built entirely around Apache-2.0 open-weight models (Qwen2.5-1.5B and Qwen2.5-VL-3B).

team leader (username):nareshkumawatstar

Hacktoberfest Weekend Challenge: Build for a Friend (devmemory)

Naresh Kumawat — Sun, 04 Oct 2026 08:08:32 +0000

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

What I Built

DevMemory is a personal coding-memory app. You log the bugs you actually hit — the snippet, the error, and what you learned — and it turns that pile of mistakes into an AI that answers you, grounded in your history.

I built it for my friend Rahul, who is learning to code. His problem was never "I can't find an answer." It was that he kept making the same class of mistake over and over — an off-by-one here, a missing null check there, a Python ternary precedence bug he'd already fixed two weeks earlier. He'd fix it, forget it, and then hit a near-identical variant in a different project. Existing tools (Stack Overflow, ChatGPT) give generic answers because they don't know what he already got wrong.

DevMemory is the thing that remembers for him. Every mistake he saves makes the next answer sharper.

Six capabilities:

AI root-cause analysis — paste a snippet + stack trace, and Gemma extracts the real root cause, severity, and the lesson (not just the symptom).

Semantic search over his own memories — MongoDB Atlas Vector Search matches by logic pattern, not keywords, so "list index out of range" finds his old off-by-one fix. Grounded Q&A — ask "why does my recursion blow the stack?" and get an answer built only from bugs he has personally hit. Recurring-bug detection — every error is tagged and categorized so anti-patterns surface automatically. Progress analytics — mistake frequency, severity trends, and a topic-weakness radar over days, weeks, and months. Personalized practice — generates a fresh coding problem aimed at the exact concepts he struggles with most.

The pipeline, end to end:

01 Save Memory → log snippet + problem description + thrown error
02 AI Analysis → Gemma extracts root cause, difficulty, key takeaways
03 Vector Embed → chunks + embeddings stored in MongoDB Atlas
04 Semantic Retrieval → Atlas Vector Search pulls relevant past memories
05 Grounded Answer → Gemma answers, strictly grounded in his own history

Demo

Deployed link:https://devmemory-sdsp.onrender.com/
Video walkthrough:https://screenapp.io/app/files/6ac208e300322e29fc6a6f0a
Code
GitHub: Nareshkumawat-star/devmemory

How I Built It

evMemory is built around Gemma, an open-weight model from Google. Gemma does the thinking: root-cause analysis of a stack trace, recurring-mistake detection, the personalized explanations, the practice-problem generation, and the grounded Q&A. It talks to my app over a plain OpenAI-compatible /chat/completions interface, which turned out to be the most important design decision in the whole project.

For retrieval, I use an OpenAI-compatible embedding endpoint to chunk and embed each memory, store the vectors in MongoDB Atlas, and retrieve them with Atlas Vector Search. Gemma then answers strictly from what retrieval returned — so it can't hallucinate advice about code my friend never wrote.

Architecture

Next.js (UI + route handlers)
│
├── MongoDB Atlas ──────────── Vector Search
│ ▲ │
│ │ embeddings │ retrieved memories
│ embedding API ▼
└──────────────► Gemma ──────► grounded answer

How it was actually built (and where the AI agent came in)

I built this with Codebuff as my agent, working through it in small, verifiable steps:

Scaffolded the Next.js 16 App Router app, Zod schemas, and MongoDB connection layer.
Built the memory CRUD + Monaco editor, then the analyze endpoint (Gemma analysis → embed → vector upsert).
Added the RAG pipeline and wired /api/ai/ask and /api/ai/practice on top of it.
Built the analytics dashboard with Recharts and the improvement timeline.
Hardened it: 68 unit tests, Playwright E2E, tsc --noEmit, ESLint.
Deployed to Render on the free plan with a render.yaml blueprint + a multi-stage Dockerfile, and pointed Mongo at Atlas.

Deployment lessons I hit along the way (in case they help someone else):

Next.js 16 warns that next start is unsupported when output: "standalone" is set at build time — so I gate it behind an env flag and only enable it for Docker.
On Render, setting NODE_ENV=production makes npm ci skip devDependencies, which breaks the build (Tailwind's PostCSS plugin lives in devDeps). The fix is npm ci --include=dev && npm run build.
@types/node had to move to ^24 to satisfy a Vitest 5 peer requirement, and the lockfile had to be regenerated with the same npm major as the build container.

Why Does Open Innovation Matter?

My Agent Session

This project only works because the model is open. Three concrete reasons:

1. The inference host is swappable, with zero code changes. Because DevMemory speaks the plain OpenAI-compatible shape, the exact same code runs against a local Ollama instance, a self-hosted vLLM server, or any hosted provider. That's not a nice-to-have — it's the difference between the app working and not working. During development my friend runs Gemma locally for free and offline; in production it points at a hosted endpoint. One environment variable changes, and the feature set is identical. A closed API locks you to one company's servers, one company's price, and one company's uptime.

2. Privacy is a feature, not a footnote. The whole premise is my friend logging his real mistakes — the code he's embarrassed about, the bugs from his actual projects. With open weights he can run the entire thing on his own machine and nothing ever leaves it. With a closed API, every personal coding mistake is posted to someone else's server. For a "personal memory" app, that's a fundamental difference.

3. Open weights let the app stay free. A hobby project for one friend can't subsidise per-token API costs. Being able to run the open model locally, or point at a free hosted endpoint, is what makes DevMemory viable as a gift rather than a subscription.

More broadly, open innovation is what makes the RAG pattern accessible at all. The embedding pipeline, the vector store, and the model are three independent choices, each replaceable. That composability — being able to hold the whole stack in your head and swap any piece — is exactly what closed, vertically-integrated AI platforms take away.

My Agent Session

I built DevMemory with Codebuff / Freebuff as my coding agent.

The agent handled the full loop with me: scaffolding the App Router structure, writing the Zod schemas and the MongoDB RAG layer, implementing the Gemma client, building the analytics UI, writing the Vitest + Playwright tests, and debugging the Render deploy (the devDependencies/Tailwind build failure and the @types/node peer conflict both surfaced through the agent's test-and-verify cycle).

team leader (username):nareshkumawatstar