DEV Community: Azmol Wasim Hussain

SlothScript: Automating My Code Reviews Locally with Gemma so I Can Be Lazier

Azmol Wasim Hussain — Sun, 25 Oct 2026 09:31:28 +0000

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

What I Built

Meet SlothScript—a lightweight, local CLI script that automatically reviews my git diffs and writes my commit messages or pull request summaries for me.

As developers, writing detailed commit summaries or context documentation is tedious. SlothScript intercepts my lazy workflow: instead of me typing out what I changed, an open-weight local model analyzes my staged changes and writes the summary while I sit back and sip my coffee. It’s built entirely for developers who want to do less manual typing and let open-source AI handle the bureaucratic chores of coding.

How I Built It

I didn't want to deploy a heavy web app or deal with cloud hosting, so I kept it completely local and script-based using Python and Ollama.

The Model: Powered by Gemma running locally via Ollama.
The Workflow: A simple pre-commit hook or standalone Python script (sloth.py) that grabs git diff --cached, feeds it into the local model with a prompt template asking for a concise summary, and outputs a ready-to-use commit message.
The Architecture: No external APIs, no complicated cloud dependencies—just a local script interacting with an open-weight model right on my machine.

Why Does Open Innovation Matter?

Open innovation and open-weight models are the only reason a workflow like this works cleanly for a lazy developer:

Privacy & Security: My git diffs might contain sensitive internal code or config snippets. Sending proprietary code to a closed, third-party API is a security nightmare. Running an open-weight model locally keeps everything strictly on my machine.
Zero Cost & Offline Capability: I can run this on a plane, offline, without burning through API credits or subscription fees.
Customizability: I was able to tweak the system prompt locally to match my exact preferred commit style without being restricted by safety guardrails or formatting limits imposed by closed APIs.

The Lazy Payoff

Before this script, I used to stare at blank commit message boxes or write generic things like "fix stuff" out of sheer laziness.

This week, SlothScript handled dozens of local commits without me having to manually summarize a single diff. It saves me about 2–3 minutes of context-switching per commit—which adds up to hours of saved mental energy over the course of a week. Maximum laziness achieved!

Prize Categories

Gemma

PlateProfit AI: Turning Food Waste Into Profit with Open-Source AI

Azmol Wasim Hussain — Mon, 19 Oct 2026 04:07:38 +0000

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

What I Built

PlateProfit AI is an AI-powered restaurant management concept designed to help restaurants make smarter decisions, reduce food waste, and protect their profits.

Restaurants often struggle with food waste, fluctuating ingredient costs, inventory management, and hidden profit leaks. Ingredients expire, purchasing decisions become difficult, and small inefficiencies can add up to significant financial losses.

PlateProfit AI aims to bring these challenges into one place. The goal is to help restaurant owners understand their costs, identify potential waste, analyze profitability, and make more informed operational decisions.

🍽️ Who is it for?

Independent restaurant and café owners
Small food businesses and cloud kitchens
Restaurant managers responsible for inventory and costs
Food entrepreneurs looking to improve operational efficiency

💡 Who would pay for it?

Restaurant owners and food businesses could pay for a tool that helps them control ingredient costs, reduce avoidable waste, and make better purchasing decisions. The long-term vision is to offer a practical, affordable solution that helps restaurants improve profitability while using their resources more efficiently.

My goal with PlateProfit AI is simple: help food businesses waste less, understand their numbers better, and turn smarter decisions into better profits.

Demo

🚀 Try PlateProfit AI:

https://plate-profit-ai-8fek.vercel.app/

Explore the live application and see the project in action.

Code

💻 GitHub Repository:

https://github.com/azmolwasimhussain-ops/PlateProfit-AI

Check out the source code, explore the implementation, and follow the project's development.

How I Built It

I built PlateProfit AI as a web application focused on solving real-world challenges in restaurant operations, food waste, and profitability.

🛠️ Technology Stack

Next.js 16 — For building the web application and server-side API routes.
TypeScript — For type-safe development and more maintainable code.
Ollama — For integrating with locally hosted AI models through an open-source AI workflow.

🧠 Building Around Open-Source AI

Rather than treating AI as just another chatbot, my goal was to make it useful for a specific business problem: helping food businesses make better operational and financial decisions.

The application includes API routes for Ollama analysis and service-status checks. This provides a foundation for connecting AI capabilities to restaurant-focused workflows.

🚀 My Development Approach

I focused on building a working web application, connecting the frontend with backend API routes, and preparing the project for deployment.

The project is deployed on Vercel, and the source code is available on GitHub so others can explore the implementation.

For me, this project is an opportunity to explore how open-source AI can make practical business tools more accessible to smaller food businesses — without making expensive AI infrastructure a prerequisite for innovation.

Why Does Open Innovation Matter?

I believe powerful AI tools shouldn't be accessible only to companies with large budgets. Small restaurants, cafés, and independent food businesses also deserve access to technology that can help them make smarter decisions.

That's why open innovation matters to PlateProfit AI.

By exploring Ollama and open-source AI models, I could experiment with locally hosted AI workflows instead of relying entirely on a proprietary AI API. This opens up possibilities for greater control over model selection, privacy-conscious processing, and reduced dependence on a single provider.

Open-source tools also make experimentation more accessible. Developers can inspect implementations, customize workflows, test different models, and learn from the wider community rather than building everything from scratch.

For a project focused on restaurant profitability and food waste, these advantages matter. The long-term vision is to make useful AI-powered business tools more accessible to smaller food businesses, where every operational improvement can count.

Open innovation makes it possible to build, experiment, share, and improve together. PlateProfit AI is my attempt to explore how that collaborative approach can turn AI into something practical for real-world businesses.

Prize Categories

I'm focusing on building a practical AI-powered solution for restaurant profitability and food waste reduction. I'll enter partner prize categories only where PlateProfit AI meets the specific requirements through actual implementation.

TerraMind: Your Offline AI Nature Companion 🌿

Azmol Wasim Hussain — Fri, 09 Oct 2026 20:50:52 +0000

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

What I Built

TerraMind is an offline-first AI nature companion built for the Hacktoberfest 2026 — Touch Grass Challenge. 🌿

We spend so much time staring at screens that we often forget to explore the world around us. I built TerraMind to turn AI from something that keeps us online into something that encourages us to step outside.

What does TerraMind do?

🌱 AI-Powered Nature Missions: Generate personalized outdoor activities based on your available time, energy level, interests, and location hints. Whether you have 10 minutes for a mindful walk or a few hours for birdwatching, TerraMind helps you find something meaningful to do.

📓 Private Nature Journal: Record observations, thoughts, and discoveries from your outdoor adventures. Keep track of what you see, hear, and experience in nature.

🧭 Distraction-Free Mode: Follow your mission checklist, focus on the present moment, and put your phone away instead of endlessly scrolling.

🔒 Offline-First & Privacy-Focused: TerraMind uses locally running open-weight AI models through Ollama for mission generation. Journal entries, mission progress, and settings are stored locally in the browser using IndexedDB, helping keep personal data on your device.

🌲 Built for Real-World Exploration: From noticing birds and identifying interesting natural patterns to practicing mindfulness and observing trees, every mission is designed to encourage curiosity about the world outside your screen.

Who is it for?

TerraMind is for students, nature lovers, people who spend too much time online, and anyone who wants to build a healthier relationship with technology.

The idea is simple: use AI less as a destination and more as a starting point for real-world experiences.

Instead of asking AI to keep you entertained for hours, let it give you a reason to close your laptop, step outside, and discover something new.

🌍 Touch grass. Notice more. Live a little offline.

Demo

🌐 Live Website: https://terra-mind-lqvd.vercel.app/

Code

💻 GitHub Repository: https://github.com/azmolwasimhussain-ops/TerraMind

How I Built It

TerraMind is built around Ollama and open-weight AI models, with one core goal: use AI to help people spend less time on their screens and more time exploring the real world.

🧠 Open-Source AI at the Core

I integrated Ollama to run AI models locally instead of relying entirely on paid, cloud-hosted AI APIs. TerraMind supports models such as Llama 3, Gemma 2, and Qwen, allowing users to choose a model based on their hardware and preferences.

The AI uses a user's available time, energy level, interests, and preferred outdoor location to generate personalized nature missions, practical instructions, safety tips, and interactive checklists.

🌿 Built for Offline-First Experiences

The application is designed to keep personal nature observations on the user's device.

Local AI inference: Ollama can generate missions using locally running models.
Offline fallback: A built-in botanical mission engine provides an alternative when local AI generation is unavailable.
Private storage: IndexedDB stores missions, checklist progress, journal entries, and application settings locally in the browser.
Progressive Web App: PWA support helps make the experience accessible on supported devices, including when offline assets are available.
Resilient error handling: Model connection failures and malformed AI responses are handled with clearer diagnostics and fallback options.

⚙️ The Technical Approach

I built the application with a component-based frontend, API routes for AI integration, local database persistence, and a nature-inspired responsive design system. I also focused on keyboard accessibility, mobile usability, mission history, and a distraction-free mode.

Rather than making AI the destination, TerraMind uses AI as a starting point: generate a mission, put the phone away, explore your surroundings, and record what you discover.

The idea behind the project is simple: AI should not always keep us connected to a screen. Sometimes, it should help us disconnect.

Why Does Open Innovation Matter?

Open innovation matters to TerraMind because AI should be accessible, private, and adaptable—not locked behind expensive APIs or proprietary platforms.

By building around Ollama and open-weight models, I could explore local AI inference and make AI-generated nature missions possible without requiring every generation to go through a cloud-based AI provider.

Here is what open innovation made possible:

🔓 Freedom to experiment: I can try different models, compare their outputs, and choose one that works best for my use case and hardware.
🔒 Privacy by design: With local inference and browser-based IndexedDB storage, personal preferences, missions, and journal entries can remain on the user's device when the application is configured and used locally.
🌱 Accessibility: Users can experiment with AI without needing a paid, per-request API subscription, although running models locally still requires suitable hardware and storage.
📴 Offline potential: Local models and a built-in mission fallback make it possible to keep the core experience useful when cloud services or internet connectivity are unavailable.
🛠️ Community-driven innovation: Open tools let developers inspect, adapt, improve, and build on existing technology instead of starting from scratch or depending on a single vendor.

A closed API could still generate personalized missions, but it would typically introduce an external service dependency and potentially usage costs. Open tools gave me more control over how TerraMind runs and how personal data is handled.

For me, open innovation is about more than using free tools. It is about giving people control over their technology. TerraMind uses that freedom to turn AI into a bridge between the digital world and the natural one—helping people put their phones away, explore their surroundings, and reconnect with nature.

TerraMind’s Open-Source AI Stack

TerraMind is built around open-weight AI and local-first technologies that make personalized outdoor exploration more accessible and privacy-conscious.

🧠 Ollama — Local AI Runtime

Ollama runs compatible open-weight models locally, allowing TerraMind to generate nature missions without requiring a paid cloud AI API for each request.

🌱 Open-Weight Models

TerraMind supports locally installed models such as Llama 3, Gemma 2, and Qwen. Users can experiment with different models and choose one that fits their hardware and needs.

⚙️ Application Architecture

Next.js and TypeScript: Application structure, user interface, and API integration.
React and Tailwind CSS: Responsive, reusable UI components and styling.
Ollama API: Local model discovery, connection checks, and mission generation.
IndexedDB: Local persistence for missions, journal entries, checklist progress, and settings.
Progressive Web App technologies: Offline access to supported cached assets and saved content.

🔒 Local-First by Design

The combination of local model inference and browser-based storage gives users more control over their data. Personal journal entries and saved missions can remain on their device, while the local AI generates personalized activities when Ollama is available.

When the model cannot be reached, TerraMind can use its built-in botanical mission fallback instead of pretending that an AI request succeeded.

The key idea: Open-weight AI provides the flexibility, while local-first storage and offline-friendly design help turn that flexibility into a practical nature companion.

Development Process

I used AI-assisted development to shape TerraMind's concept, build its interface, and develop its local-first AI experience. Throughout the process, I focused on a simple goal: make technology a starting point for outdoor exploration rather than another reason to stay in front of a screen.

Prize Categories

Best Use of Gemma — TerraMind uses Google's open-weight Gemma model through Ollama for local AI-powered nature mission generation.

StudyMate — An AI Study Partner Built for a Friend

Azmol Wasim Hussain — Sun, 04 Oct 2026 07:40:24 +0000

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

What I Built

I built StudyMate, an AI-powered study partner for a friend who struggles with managing lecture notes, PDFs, and a large amount of study material before exams.

Instead of switching between notes, search engines, YouTube, and different AI tools, StudyMate brings everything into one place.

With StudyMate, students can:

📚 Upload and organize study materials
🤖 Ask questions about their notes
🔎 Get answers grounded in their study material
📝 Generate quizzes for practice
📅 Create personalized study plans
🔄 Revise important concepts
📊 Track their learning progress

The goal is simple:

Turn scattered study material into a personal, interactive AI study partner.

I built StudyMate to solve a real problem: having plenty of study material but not knowing how to effectively learn, practice, revise, and prepare from it.

Demo

🚀 Live Demo:

https://study-mate-one-psi.vercel.app/

Explore StudyMate and experience the AI-powered study workflow.

Code

💻 GitHub Repository:

https://github.com/azmolwasimhussain-ops/StudyMate

The complete source code is open-source and available on GitHub.

How I Built It

StudyMate is built with Next.js, React, and TypeScript, with a modular architecture for AI, document processing, RAG, database operations, and study features.

For the AI layer, I used Google Gemma 2 2B, an open-weight model, running locally through Ollama.

The core workflow is:

Study Material
      ↓
Document Processing
      ↓
Chunking & Retrieval
      ↓
Relevant Context
      ↓
Gemma 2 2B
      ↓
Grounded Response

This AI architecture powers the main StudyMate features:

🤖 AI study chat
🔎 RAG-based answers from study materials
📝 Quiz generation
📅 Personalized study planning
🔄 Revision assistance
📊 Learning progress I built the AI layer using a provider-based architecture, so the application is not tightly coupled to a single model or AI provider. This makes it easier to experiment with different open-weight models in the future. I also used AI coding agents during development to help with implementation, debugging, refactoring, and organizing the codebase into a maintainable structure. The main idea was to make the open-weight model the core intelligence behind StudyMate rather than simply adding AI as a separate feature.

Why Does Open Innovation Matter?

Open innovation matters because it gives developers more control, flexibility, and freedom to experiment with the technology behind their products.

For StudyMate, this is especially important because the application is designed around students' personal study materials such as lecture notes, PDFs, and assignments.

Instead of building the entire AI experience around a closed API, I used an open-weight model, Gemma 2 2B, running through Ollama. This allowed me to build the AI layer around a model that I can run and experiment with locally.

Open innovation made it possible for me to:

🔓 Experiment with open-weight AI models
🖥️ Run the model locally through Ollama
🔧 Customize prompts and AI behavior
🔎 Build my own RAG pipeline
🔄 Change or experiment with different models
🧩 Create a modular AI provider architecture
🚀 Have more control over how the AI layer is developed

A closed API can be convenient, but open-weight AI gives developers the ability to understand, customize, and evolve the technology behind their applications.

For StudyMate, open innovation wasn't just about using an AI model — it allowed me to build the AI layer around the product rather than building the product around a single closed AI provider.

That flexibility is what makes open innovation valuable for projects like StudyMate.

Prize Categories

🏆 Best Use of Gemma — StudyMate uses Google Gemma 2 2B, an open-weight model running through Ollama, as the core AI intelligence behind its study assistant, RAG-based question answering, quiz generation, planning, and revision features.