DEV Community: Dineshwar Doddapaneni

The Hermit’s Alibi: Channeling My Inner Sloth with Local AI

Dineshwar Doddapaneni — Sat, 24 Oct 2026 16:00:29 +0000

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

What I Built

I built The Hermit’s Alibi, a local web-based assistant designed to channel your inner sloth and completely automate the exhausting cognitive labor of social avoidance.

When you get invited to an outdoor event, a wedding, or a gathering across town that you are entirely too lazy to attend, you no longer have to waste energy checking forecasts, looking at maps, or agonizing over how to say no. You simply enter your current location, where you've been summoned, the event name, and the date. The app instantly pulls real-time weather and environmental data for that location, combines it with an open-weight model running locally, and weaves those undeniable facts into a bulletproof, casual text message draft designed to help you stay comfortably at home. It even includes a chat interface so you can follow up with prompts like "Make it sound a bit more passive-aggressive" or "Add that my car battery is acting up."

Demo

https://github.com/dinesh9-ai/Hacktoberfest2026_withAI/tree/main/DevChallenge4/Demo

Code

https://github.com/dinesh9-ai/Hacktoberfest2026_withAI/tree/main/DevChallenge4/Code

How I Built It

The application relies entirely on an open-source and keyless stack:

UI Framework: Built using Streamlit, providing a clean sidebar configuration panel alongside an interactive chat interface.
Local Inference Engine: Powered by Ollama running Llama 3.1 8B locally on the machine.
Public Data Integration: Uses Open-Meteo, a free, keyless public weather API that provides global geocoding and forecast data without requiring any authentication tokens or tracking.

Why Does Open Innovation Matter?

Open innovation and open-weight models made this specific project possible for two major reasons:

Bypassing Commercial Guardrails: Commercial cloud-hosted APIs are heavily programmed with corporate safety filters that flag requests involving "excuses" or "deceptive text messaging" as a violation of safety policies. Running Llama 3.1 locally allows complete freedom over system prompts and tone, letting you build a comedy-driven writing assistant without being lectured by an overbearing AI.
Absolute Privacy: Social planning, geographic locations, and who you are trying to avoid are deeply personal data points. By keeping the entire workflow local and relying only on anonymous public weather data, zero private details ever leave your machine, and you pay absolutely zero API fees for continuous iterations.

The Lazy Payoff

This app instantly saves you from the tedious mental chess of social engineering. Instead of spending 10 minutes checking weather apps, calculating travel times, and agonizing over how to back out of a plan politely, you click a single button, copy the text, and go straight back to resting. Zero effort, maximum alibi.

Prize Categories

Open-Source AI / Local Inference Track

LocalTutor AI: An Adaptive Offline Language Coach

Dineshwar Doddapaneni — Sat, 17 Oct 2026 08:32:50 +0000

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

What I Built

I built LocalTutor AI, a fully offline, adaptive language learning application powered by local LLMs. It acts as a relentless but infinitely patient private tutor that lives entirely on your hard drive.

Traditional language apps force you down rigid, pre-baked skill trees (I’m looking at you, green owl). Human tutors are incredible, but they cost a fortune and demand strict scheduling. LocalTutor AI solves this by taking your target language, available daily time, and current skill level, and dynamically generating a customized curriculum day by day. It tests you, grades your answers, identifies your weak points, and seamlessly weaves those lagging topics into tomorrow's lesson.

Who would pay for this? Expats, corporate professionals, and serious self-studiers who want the personalization of a $50/hour private tutor for the price of a standard software subscription.

Demo

https://github.com/dinesh9-ai/Hacktoberfest2026_withAI/tree/main/DevChallenge3/Demo

Code

https://github.com/dinesh9-ai/Hacktoberfest2026_withAI/tree/main/DevChallenge3/Code

How I Built It

The core engine runs on Llama 3.1 (8B) served locally via Ollama, with a frontend built in Streamlit.

To make this actually work as a tutor rather than a stochastic parrot, I had to get highly specific with prompt engineering and state management. The app uses a local JSON database to persist user profiles, track daily streaks, and log historical performance.

The real magic happens in the daily generation loop. I enforce strict JSON schema outputs from Llama 3.1 to ensure the UI can cleanly parse native scripts (like Kanji and Hiragana), Romanization, and English translations into neat UI cards. The model takes the user's answers from the daily quiz, evaluates them against the day's lesson plan, and generates a structured "Report Card." Crucially, it extracts the exact concepts the user failed at and saves them to the local database as lagging_topics. The next day, the prompt dynamically injects those lagging topics into the system instructions, forcing the model to reteach the failed concepts before introducing new material.

Why Does Open Innovation Matter?

Building a dynamic, generative AI loop that runs multiple inference calls every day per user would be financial suicide if I were relying on a closed, pay-per-token cloud API.

Open-source AI made this side hustle viable for three critical reasons:

Zero Marginal Cost: Because Llama 3.1 runs locally on the user's machine via Ollama, my cloud API bill is exactly $0.00. I can charge a flat fee for the software without bleeding money every time a user decides to study for an extra hour.

Total Data Privacy: Language learners make embarrassing mistakes. Because everything runs offline, my users' data, typing habits, and learning struggles never touch a corporate server.

Unhinged Customization: I needed the model to strictly output native character sets and rigidly adhere to JSON schemas without cloud safety filters randomly deciding that a specific foreign idiom violated a content policy. Running open-weight models locally gives me absolute control over the inference parameters.

My First User

A close friend of mine recently landed a gig at a Japanese company. He loves the job, but he was constantly getting lost in translation during cross-team meetings. He decided he needed to learn Japanese and get his JLPT (Japanese-Language Proficiency Test) certification to survive the corporate battlefield.

He looked into local language institutes and quickly realized two things: the tuition fees for every progressive JLPT level were astronomical, and their rigid class schedules clashed horribly with his erratic software engineering hours.

I handed him the LocalTutor AI demo and told him to give it a spin. He used it consecutively for five days.

His feedback was exactly what you want to hear as a developer: he asked where he could enter his credit card. He told me the app completely eliminated the stress of the "institute schedule." He could study at his own pace, at 2 AM or during a lunch break. More importantly, he loved that the app adapted to his specific grasping speed. When he repeatedly failed to recognize specific Kanji characters, the app didn't drag him forward into a new chapter; it patiently looped those characters back into his next lesson until they stuck. He is now officially my first highly-motivated beta tester.

Prize Categories

Open-Source AI
Local Inference
Best Side Hustle Concept

Hacktoberfest26 week 1 DEV Challenge: OpenStride is a completely offline, privacy-first wearable running coach.

Dineshwar Doddapaneni — Sat, 10 Oct 2026 20:15:18 +0000

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

What I Built

OpenStride is a completely offline, privacy-first wearable running coach.

Modern running has become obsessed with screens. We stare at smartwatches for our heart rate, check pacing on our phones, and get distracted by Strava notifications mid-stride. OpenStride removes the screen from the run entirely.

You clip a simple ESP32 + MPU6050 sensor to your shoe or waistband. It silently logs your running kinematics (cadence, impact force, and leg fatigue) to a MicroSD card while you are out on the trail. You run completely disconnected—no phone, no internet, no distractions.

When you get home, your local PC running Google's open-weight Gemma 2 model (via Ollama) ingests the raw data. It analyzes your form, calculates fatigue drops, asks how you felt, and generates a customized marathon training plan for tomorrow. The screen is only used for two minutes after you've touched grass.

Demo

https://github.com/dinesh9-ai/Hacktoberfest2026_withAI/blob/main/DevChallenge2/Demo/Demo_video.mp4

Code

https://github.com/dinesh9-ai/Hacktoberfest2026_withAI/tree/main/DevChallenge2/Code

How I Built It

OpenStride is built entirely around an open-source hardware and local AI architecture:
Hardware: An ESP32 microcontroller paired with an MPU6050 **accelerometer handles the edge data logging. It is lightweight, cheap, and **requires no internet connection.
Data Pipeline: Python and Pandas process the raw CSV data into readable biomechanical metrics (like impact magnitude and fatigue ratios).
The AI Core: I used Gemma 2, Google's powerful open-weight model, running entirely locally on my PC via Ollama. Gemma acts as the reasoning engine, taking the cold, hard math from the pandas dataframe and translating it into empathetic, actionable coaching advice.

Why Does Open Innovation Matter?

Open innovation isn't just a feature for this project; it is the only way it works.

-** Absolute Privacy:** Running kinematics and location timings are highly personal biometric data. By using a local open-weight model (Gemma) instead of a closed cloud API, the runner's health status and routines never leave their laptop.

True "Touch Grass" Capability: Marathoners often train in remote locations, national parks, or mountain trails with zero cell service. Because OpenStride relies on local hardware and local PC inference, you could be in a remote cabin for a high-altitude training camp with no Wi-Fi, and your AI coach still works perfectly.
Zero Ongoing Costs: Daily coaching via a proprietary LLM API would rack up costs quickly. Running Gemma locally means runners can query their coach, iterate on their goals, and analyze endless historical runs for absolutely free.

My Agent Session

Prize Categories

Best Use of Gemma: I utilized Gemma 2, Google's open-weight model, running locally via Ollama to serve as the project's core AI reasoning engine, eliminating the need for cloud APIs.
Best Use of Entire: I have included my agent session in the write-up above to share how the underlying data pipelines were built.

SecondBrain AI

Dineshwar Doddapaneni — Sun, 04 Oct 2026 20:28:40 +0000

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

What I Built

My close friend is a relentless learner who documents everything—from technical courses and side-project logs to articles and even personal cooking secrets. Over the years, their digital footprint has become enormous. When they actually need to recall a specific piece of information, like a command syntax or the exact proportions for a family recipe, it gets buried across messy markdown files, local PDFs, and scattered notes.

To solve this, I built SecondBrain-Local: an entirely offline, private, and autonomous AI retrieval assistant. It automatically ingests their personal notes, PDFs, Word documents, and presentations into a local vector store via a background agent. It uses a vision-language model to read tables and images in the documents, and a text model to answer questions. They can now chat with their own knowledge base instantly without sending a single byte of data to external cloud APIs.

Demo

https://github.com/dinesh9-ai/Hacktoberfest2026_withAI/tree/main/Week_1/Demo

Code

https://github.com/dinesh9-ai/Hacktoberfest2026_withAI/tree/main/Week_1/Code

How I Built It

SecondBrain-Local is engineered from the ground up to run air-gapped on standard hardware with zero internet dependency, utilizing powerful open-weight models:

Local LLM Runtime: Powered by Ollama running llama3.1:8b for prompt completion and reasoning, and glm-ocr to parse complex tables and images.
Orchestration & Indexing: Built using LangChain to parse heterogeneous file formats (Markdown, PDF, Text, PPTX, Docx) and chunk documents efficiently.
Vector Database: Utilizes ChromaDB coupled with nomic-embed-text for local embedding storage and fast similarity search over unstructured knowledge.
Workflow Automation: A Python watchdog script acts as an autonomous agent, automatically watching local directories and updating the vector embeddings seamlessly whenever my friend adds new materials.

Why Does Open Innovation Matter?

Open innovation and open-weight models made this project possible in ways a closed API never could:

Absolute Privacy: My friend stores sensitive personal notes, private thoughts, and confidential project ideas. Running open-weight models locally ensures that personal data never leaves their machine and is never sent to third-party servers.
Zero Cost & Infinite Reliability: Because there are no per-token API fees or cloud dependencies, my friend can query their second brain endlessly without worrying about rate limits, internet outages, or subscription costs.
Multi-Modal Agility at the Edge: Combining a specialized vision model (glm-ocr) with a robust reasoning model (llama3.1) completely offline demonstrates the power of composable open-source frameworks to tackle complex, messy real-world files like scanned PDFs.

My Agent Session

I used an AI coding assistant to help architect the background watchdog loop and debug the PyMuPDF image extraction logic so it would correctly format the image bytes for the local GLM-OCR model. Iterating with an agent helped me quickly switch from a standard text-only RAG to a multi-modal pipeline without getting bogged down in PDF byte-stream errors.