DEV Community: Bhavya Modi

give one title LazyFlow AI 🦥: Let Your AI Handle the Boring Stuff — Locally

Bhavya Modi — Sun, 25 Oct 2026 18:27:26 +0000

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

What I Built

LazyFlow AI 🦥 — Your Local-First AI Productivity Agent

LazyFlow AI is an AI-powered productivity assistant designed to eliminate repetitive digital work and help people spend less time organizing and more time doing what matters.

It helps users analyze documents, generate summaries, extract actionable tasks, organize messy folders, search through documents using natural language, and prepare daily productivity briefings.

The idea is simple: You make the mess. Your AI handles the boring part.

Instead of manually sorting files, reading lengthy documents, and tracking every little task, users can let LazyFlow AI handle these repetitive workflows.

Demo

lazyflowai.vercel.app

Code

bhavya277 / LazyFlowAI

LazyFlow AI 🦥

Your Local-First AI Productivity Agent | Hacktoberfest: Slow and Steady

“You make the mess. Your AI handles the boring part.”

LazyFlow AI is a privacy-first, local AI productivity desktop assistant that eliminates repetitive digital work. It automatically organizes messy folders, understands complex documents, extracts actionable tasks with verifiable deadlines, and compiles daily productivity morning briefings — using open-weight AI running directly on your computer.

Built specifically for the Hacktoberfest “Slow and Steady” challenge, open-weight AI and local-first architecture are core to its implementation. LazyFlow AI never sends your private documents to third-party hosted APIs.

📌 Problem Statement

Every day, developers and knowledge workers accumulate digital chaos:

The “Downloads & Desktop” Graveyard: Invoices, lecture slides, NDA contracts, screenshots, and duplicate files pile up into an unsearchable clutter.
Dense Document Fatigue: 30-page PDFs and sprint notes contain critical action items and deadlines that get forgotten.
Cloud Privacy…

View on GitHub

How I Built It

LazyFlow AI is built around local-first, open-source AI rather than relying on hosted AI APIs.

Tech stack:

Frontend: React, TypeScript, Vite, and Tailwind CSS
Backend: Python and FastAPI
AI inference: Ollama with a compatible Qwen open-weight model
Document processing: PyMuPDF and Python text-processing libraries
Semantic search: A local embedding model with FAISS or Chroma
Database: SQLite

The application is designed to process documents locally, generate summaries and tasks using an open-weight model, classify files, and retrieve relevant information from a local document index.

Its modular architecture makes it possible to switch compatible local models without rebuilding the entire application.

The goal is to make everyday productivity tasks simpler while keeping users in control of their data.

Why Does Open Innovation Matter?

Open innovation is what makes LazyFlow AI possible as a local-first productivity tool.

With a compatible open-weight model running through Ollama, users can process their documents without sending their contents to a third-party AI provider. Once the required models and dependencies are installed, supported features can work without an internet connection.

Using open-source components also makes the system more flexible. Users can experiment with different models, customize workflows, inspect the implementation, and adapt the application to their own needs.

A hosted AI API can be convenient, but it may introduce recurring usage costs, external data processing, and dependence on a particular provider.

LazyFlow AI takes a different approach: your computer, your data, your model, your rules.

Local inference still requires suitable hardware and consumes computing resources, but it can eliminate per-request charges from hosted model APIs.

My Agent Session

[Optional: Add your DevRelay agent session link or embed your session using the agent_session tag.]

The Lazy Payoff

LazyFlow AI aims to reduce the time spent on repetitive digital chores.

Instead of manually:

Reading entire documents to find the important points
Turning notes into actionable tasks
Sorting files into folders
Searching through multiple documents for specific information
Preparing a daily to-do list from scattered notes

Users can delegate these steps to a local AI assistant and review the results.

The goal is to make productivity less about managing digital clutter and more about getting meaningful work done.

[Add measured time-saving results after testing the application with real workflows.]

Prize Categories

[Add the applicable partner prize categories according to the official challenge rules.]

CreatorCoach AI: Your Personal Growth Coach for Gaming Creators

Bhavya Modi — Sat, 17 Oct 2026 17:56:39 +0000

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

What I Built

CreatorCoach AI is an AI-powered growth coach designed for gaming content creators who want to grow on platforms like YouTube Shorts and Instagram Reels.

It helps creators analyze video performance, understand engagement metrics, discover content opportunities, and generate gaming-specific hooks, scripts, captions, and content plans. It is designed for creators covering games such as Call of Duty: Mobile (CODM), BGMI, Valorant, and Minecraft.

The goal is to help small creators make smarter, data-informed content decisions instead of relying entirely on guesswork.

Demo

Explore the live application: https://creatorcoachai.vercel.app/

Code

Check out the source code and explore the project: https://github.com/bhavya277/CreatorCoachAI.git

How I Built It

CreatorCoach AI is built as a full-stack web application using Next.js, TypeScript, and Tailwind CSS, with a modern dark gaming-inspired interface.

The planned technology stack includes Supabase for authentication and persistent data storage, and an open-weight AI model served through an Ollama-compatible inference setup for generating personalized content recommendations.

The analytics layer calculates engagement metrics from video performance data, while the AI layer interprets those metrics and helps creators brainstorm content ideas, hooks, scripts, captions, and weekly publishing plans.

The project focuses on combining deterministic analytics with AI-generated insights to make recommendations more relevant to each creator.

Why Does Open Innovation Matter?

Open innovation makes AI-powered tools more accessible to independent developers and small creators who may not have the resources to build everything from scratch or pay for expensive proprietary AI services.

Using open-source tools and open-weight models gives developers more flexibility to experiment, customize the AI workflow, understand how the system operates, and adapt it to specific communities such as gaming creators.

CreatorCoach AI is built around the idea that creator-growth tools should be accessible, adaptable, and open to improvement by the community. Developers can extend the analytics, experiment with different models, and contribute new features as the project evolves.

My Agent Session

The development process involved using an AI coding agent to help build and improve the application, from its interface to its full-stack architecture.

Agent session: Add your DevRelay session link here if available.

Prize Categories

Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

From AI Prompts to Real-World Adventures: Building OUTSIDE//OS

Bhavya Modi — Sat, 10 Oct 2026 18:57:07 +0000

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

What I Built

OUTSIDE//OS is an open-source, AI-powered outdoor adventure engine that turns your free time into small, personalized real-world quests.

Instead of endlessly chatting with an AI, you tell OUTSIDE//OS how much time you have, your energy level, the kind of activities you enjoy, and the environment available to you.

It then creates an actionable outdoor mission designed around your situation.

You might get a nature-observation challenge, a mindful walking mission, a gardening activity, or a simple quest to notice things you usually walk past without thinking.

But the part I'm most excited about isn't the quest generator.

It's The Disappearing Interface.

Once you accept a quest, OUTSIDE//OS transitions into a minimal expedition experience. It gives you the instructions you need, then encourages you to lock your phone and actually complete the activity.

No infinite feed. No unnecessary notifications. No AI conversation that keeps getting longer.

The product is designed around a simple principle:

The best interaction with OUTSIDE//OS is the one that gets you back outside.

Demo

Live Demo: https://outside-os.vercel.app/

Code

💻 GitHub Repository: https://github.com/bhavya277/outside-os.git

I'd love for developers to explore the implementation, suggest improvements, contribute quest packs, and experiment with different open-weight models.

Contributions that make the experience more accessible, privacy-preserving, or useful offline are especially welcome.

How I Built It

I approached OUTSIDE//OS as a product-design challenge as much as an AI engineering challenge.

The challenge wasn't simply to connect an LLM to a frontend. It was to make AI-generated activities practical, safe, structured, and useful beyond the screen.

The architecture uses a web interface, a backend for quest generation and validation, a local AI inference layer, and local persistence for the user's personal journal.

Technology stack:

Frontend: React, TypeScript, Vite, and Tailwind CSS.

Backend: Python and FastAPI.

AI inference: Ollama with an open-weight model.

Validation: Structured quest outputs validated before they reach the user.

Persistence: SQLite for local application data.

The local model is the intelligence behind personalized adventure generation. A dedicated model adapter makes it possible to experiment with compatible models instead of tying the product to a single proprietary AI provider.

I also designed a deterministic fallback for situations where local inference isn't available, so the core experience can remain useful without pretending that AI generation is working.

The important distinction is that offline access to saved data, offline access to cached quests, and offline AI generation are different capabilities. The full local-AI experience depends on having a compatible model installed and running.

The aim is to keep the core experience independent of paid cloud AI APIs, while making model choice and the underlying implementation transparent.

Why Does Open Innovation Matter?

This is probably the most important part of the project for me.

Open innovation isn't just about using free libraries or putting source code on GitHub. It is about giving people meaningful control over the technology they use.

AI should respect personal data

An outdoor journal can contain personal reflections, routines, and information about someone's surroundings.

A local-first approach makes it possible to keep that information on the user's device instead of requiring every interaction to pass through an external AI provider.

Privacy should be an architectural decision, not just a sentence in a privacy policy.

Developers should be free to experiment

With an open-weight model, developers can experiment with compatible models, compare their outputs, adjust prompts, and improve quest generation without rebuilding the entire product around a proprietary API.

Different models have different strengths, resource requirements, and licensing terms. That flexibility makes experimentation possible.

Useful AI shouldn't require a paid API

Local inference removes per-request cloud AI API charges for the local generation path. It doesn't make computation completely free: users still need compatible hardware and must account for electricity, model downloads, and storage.

Still, eliminating mandatory per-request API fees can make experimentation and self-hosting more accessible.

Open source makes the project bigger than its original author

Someone could contribute a gardening quest pack. Someone else could improve accessibility. Another developer could add support for a different model or help make the application more robust offline.

That is the part of open innovation I find exciting: the project can evolve through contributions from people with different experiences and ideas.

The open-source approach isn't an optional decoration around OUTSIDE//OS. It is what makes local inference, model flexibility, and community-built experiences possible.

PingPilot — a local AI network co-pilot for gamers.

Bhavya Modi — Sun, 04 Oct 2026 19:06:11 +0000

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

What I Built

PingPilot is a local-first AI network diagnostic tool I built for a friend who loves gaming but regularly struggles with high ping, random lag, jitter, and packet loss.

Whenever the connection gets unstable, the usual solution is to guess: restart the router, blame the Wi-Fi, or assume the internet plan isn't fast enough. The problem is that a speed test doesn't really explain why a game is lagging.

So I built PingPilot to investigate the connection instead.

It measures real network conditions such as gateway latency, internet latency, game-server latency, jitter, packet loss, DNS resolution, and network routes, then uses an open-weight AI model running locally to interpret those measurements and explain the likely cause in simple language.

Instead of just telling my friend:

"Your ping is 82 ms."

PingPilot tries to answer the more useful question:

"Why is your game lagging, and what should you actually do about it?"

The goal was to build something small enough to be useful immediately, but personal enough that my friend could actually use it the next time a game starts lagging.

Demo

Live Demo: https://pingpilot-two.vercel.app/

The live demo showcases PingPilot's professional network-diagnostics interface and the complete user flow for analyzing gaming connectivity.

Code

GitHub Repository: https://github.com/bhavya277/PingPilot

The complete source code for PingPilot is open source and available on GitHub.

The repository includes the React + TypeScript frontend, FastAPI backend, network diagnostic engine, Ollama-powered local AI integration, SQLite diagnostic history, and demo mode.

How I Built It

PingPilot is built around a local-first AI architecture, where the AI doesn't replace the network diagnostics — it interprets them.

The backend is built with Python and FastAPI, while the frontend uses React, TypeScript, Vite, and Tailwind CSS.

For the AI layer, I used Ollama to run open-weight models locally, with support for models such as Llama 3.2, Mistral, Qwen, and Phi.

The diagnostic flow works like this:

Real Network Measurements
↓
Deterministic Heuristic Engine
↓
Structured Diagnostic Data
↓
Local Ollama Model
↓
AI Diagnosis + Recommendations

PingPilot first collects real measurements from the user's machine, including:

Gateway latency and packet loss

Internet latency and jitter

Game-server RTT and packet loss

DNS resolution latency

Traceroute information

Network throughput

The diagnostic engine then performs deterministic analysis to identify patterns such as local network instability, upstream packet loss, high jitter, or routing problems.

That structured evidence is passed to the local Ollama model with a strict system prompt that tells the model to never invent measurements, reason only from the collected data, separate evidence from interpretation, and provide prioritized troubleshooting recommendations.

The AI returns a structured JSON diagnosis containing the overall connection status, primary issue, confidence level, evidence, possible causes, recommended actions, and things the user should avoid doing.

I also built a deterministic fallback engine, so PingPilot can still perform useful diagnosis even when Ollama isn't running.

Diagnostic sessions are stored locally using SQLite, allowing users to review previous connection tests and identify recurring problems.

The result is a system where the network engine provides the facts and the open-weight AI explains what those facts mean.

Why Does Open Innovation Matter?

For PingPilot, using open AI wasn't just about adding an AI feature. It made the product possible in the way I wanted to build it.

PingPilot analyzes network information from a user's machine. I didn't want that diagnostic data to be sent to a closed third-party AI API just to explain what was happening.

By using Ollama with an open-weight model, the AI analysis can run locally on the same machine as the network diagnostics.

That gives PingPilot three important advantages:

🔒 Privacy

Network diagnostics can contain information about a user's connection environment. With local inference, the diagnostic data doesn't need to be sent to a cloud AI provider for analysis.

🧩 Freedom to Change

PingPilot isn't locked into a single proprietary AI model. The underlying model can be swapped, upgraded, or eventually fine-tuned for gaming-specific network troubleshooting without rebuilding the entire application.

💰 No Per-Request AI Cost

Once the model is available locally, PingPilot doesn't require a paid AI API or a cloud request every time a user wants to diagnose their connection.

Most importantly, the open-weight model is part of the architecture, not just a feature added on top.

The network diagnostic engine collects the evidence, deterministic logic analyzes the measurements, and the local AI turns that evidence into an explanation that a gamer can actually understand.

For this project, open innovation gave me something a closed API wouldn't have given me as easily: local control over the entire AI reasoning pipeline while keeping the user's diagnostic data close to them.