DEV Community: Nilam Kumari Mahato

🦥 SlothDesk — Less Organizing, More Doing

Nilam Kumari Mahato — Mon, 26 Oct 2026 06:46:31 +0000

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

What I Built

We all have those days when our to-do list feels longer than the day itself. There are assignments to finish, project bugs to fix, notes to read, messages to reply to, and deadlines to remember.

Sometimes, organizing all that work takes almost as much time as actually doing it.

That gave me an idea: What if we let AI handle the organizing so we could focus on the work itself?

That's the idea behind SlothDesk, my take on the Slow and Steady theme.

🌿 What is SlothDesk?

SlothDesk is an AI-powered productivity assistant designed to reduce the small but repetitive tasks that consume our time and attention.

Instead of manually sorting every task or reading an entire document to find the important parts, users can give their information to SlothDesk and let AI help organize it.

The project focuses on two core features.

Smart Task Prioritization 📝

We don't always write our tasks in a perfectly organized checklist. Sometimes we just type everything that is on our mind.

For example:
I need to submit my assignment by tomorrow, fix a login bug before Friday's demo, read the API documentation sometime this week, and prepare for Monday's presentation because it carries a lot of marks.

Instead of manually converting this paragraph into a to-do list, SlothDesk uses Gemma to analyze the tasks and organize them based on:

Urgency: How soon does the task need to be completed?
Importance: How much does it matter?
Deadlines: When does the user need to finish it?
Impact: What could happen if the task is delayed?

The goal is to provide a prioritized task list with clear reasons behind the suggested order, helping users understand what needs their attention first.

Quick Note Summarization 📚

Long documents, college announcements, meeting notes, and lengthy messages often contain just a few points that we really need to remember.

SlothDesk's second feature focuses on extracting those points.

Users can provide long text and receive a concise summary containing:

The main idea.
Important facts and key points.
Dates, deadlines, and requirements.
Action items that need attention.

The goal isn't simply to make text shorter. It's to make important information easier to understand and act on.

Demo

Live demo: SlothDesk

Code

GitHub repository:SlothDesk
The project uses a React frontend and a Node.js/Express backend, with Gemma powering the AI features through the Gemini API.

How I Built It

I wanted SlothDesk to be more than a regular to-do list with an AI label attached to it. The AI needed to understand unstructured text and turn it into something useful.

Here's the planned technology stack:

React + Vite: For the frontend and interactive interface.
Tailwind CSS: For the soft sage-green theme and responsive design.
Node.js + Express: For the backend API.
Gemma via Gemini API: For interpreting tasks, assigning priorities, and summarizing text.
Google Gen AI SDK: To connect the backend to the model.

For task prioritization, the backend sends the user's description to Gemma and requests structured results containing task titles, priorities, deadlines, and reasons. The application validates the response before displaying it.

For summarization, Gemma extracts the central idea, key points, dates, and action items while keeping the summary faithful to the original content.

I also wanted the interface to reflect the project's personality. SlothDesk uses a calm pastel-green palette, warm brown accents, handwritten-style typography, and a cute sloth mascot. Productivity tools don't always need to look serious to be useful!

Why Does Open Innovation Matter?

I chose Gemma because I wanted to explore how open-weight models can be used to build practical AI applications.

A model that can be adapted, evaluated, and run in different environments gives developers flexibility when designing their applications. Open-weight models also make it possible to explore local inference and more customized workflows, depending on the model, hardware, and deployment setup.

For SlothDesk, the important part is that the AI can interpret natural language rather than relying entirely on manually written rules. People describe their work differently, and the model helps turn those descriptions into structured information.

Using Gemma has also given me an opportunity to learn more about model integration, prompt design, structured output validation, and building an application around an AI model rather than treating it as a standalone chatbot.

The Lazy Payoff

Imagine receiving a long college announcement with several deadlines, or having six different tasks running through your mind at once.

Normally, you'd need to read everything carefully, identify the important parts, and manually sort your work.

SlothDesk aims to reduce those extra steps:

One paragraph becomes a prioritized task list.
One long text becomes a short, useful summary.
Important dates and action items become easier to spot.

I haven't quantified the time saved yet, so I won't claim a specific percentage. The intended payoff is fewer minutes spent organizing information and more attention available for the work itself.

Prize Categories

1. Best Use of Gemma
Gemma powers SlothDesk's two core features: smart task prioritization and quick note summarization. It helps transform unstructured text into organized, actionable information.

2. Best Use of Render
Render will be used to deploy SlothDesk's backend API, making the AI-powered features accessible to users through the web application.

My goal is to combine Gemma's language-understanding capabilities with a deployed application that makes everyday productivity a little easier.

Thanks for checking out SlothDesk! 🌿

I'd love to hear your thoughts: What's one repetitive task you'd happily let a little sloth handle for you?

Building ScopeMate: My Journey Fine-Tuning an Open-Weight AI Model

Nilam Kumari Mahato — Sun, 18 Oct 2026 09:29:28 +0000

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

What I Built

Have you ever received a client message that sounds exciting but doesn't actually explain what they want?

Something like:

"Hey! I really like your content. We'd love to collaborate sometime. Let me know if you're interested!"

It's a nice message, but what happens next? What kind of content do they expect? Is it a paid collaboration? When do they need it? And what exactly am I agreeing to?

That's the problem I wanted to explore with ScopeMate.

ScopeMate is an AI assistant I'm building to help content creators, freelancers, and other creative professionals make sense of vague client briefs. It takes an informal message and turns it into a structured project scope, highlighting what's already known and what still needs to be discussed.

The output includes the project type, requirements, deliverables, budget, timeline, revision limit, missing information, assumptions, and questions worth asking the client.

The idea is simple: help creators get clarity before committing to a project.

Demo

I'm currently demonstrating ScopeMate through a Google Colab notebook, so there's no separate frontend yet.

Notebook

Code

github

I'll include the training notebook, dataset, inference code, and instructions for running the project.

How I Built It

I wanted to do more than just send a prompt to an existing AI API. I wanted to experiment with fine-tuning an open-weight model for a specific task.

For ScopeMate, I used Google's google/gemma-4-E2B model and worked through a LoRA-based fine-tuning workflow in Google Colab.

Here's how I approached it.

Starting with the dataset

I created 40 examples based on content creation briefs and potential client collaborations:

30 training examples
5 validation examples
5 test examples

Each example contains a client message and the structured JSON response I want ScopeMate to produce.

I also checked the dataset's JSON structure and required field types before starting training. Building the dataset helped me think more carefully about the difference between information a client actually provided and information the model should ask about instead of inventing.

Fine-tuning Gemma I used Hugging Face tools, PyTorch, TRL, and PEFT to experiment with parameter-efficient fine-tuning using LoRA and 4-bit quantization.

The process involved loading the model, preparing the data, configuring the adapter, setting up the training loop, and evaluating the model on validation data.

Training completed for three epochs and 12 steps. The final training loss was around 1.78, while the final validation loss was around 2.00.

These numbers are useful for tracking the experiment, but they don't tell the whole story. I still need a larger dataset and more systematic testing to understand how reliably the model handles different types of client messages.

Testing and saving the model After training, I tested ScopeMate with client briefs and checked its generated responses. I also saved the trained adapter and backed it up to Google Drive so I can load it again without repeating the training process.

My current focus is making the inference workflow reproducible and improving the quality of the output on examples the model hasn't seen before.

Tools I used:

Google Gemma 4 E2B
Python and PyTorch
Hugging Face Transformers
TRL and PEFT
LoRA and 4-bit quantization
Google Colab
JSONL datasets

Why Does Open Innovation Matter?

One thing I liked about this project was being able to experiment with the model itself instead of treating AI as a black box behind an API.

Using an open-weight model gave me the opportunity to prepare my own dataset, experiment with fine-tuning, inspect the training process, and keep the adapter for future improvements.

It also made this a useful learning experience. I had to think about data quality, training configuration, model outputs, and evaluation—not just how to write a prompt.

I think this kind of flexibility is valuable when you're trying to build AI tools for specific problems that general-purpose assistants might not handle consistently.

Prize Categories

I'm entering the Google Gemma category with ScopeMate.

ScopeMate uses Google's open-weight Gemma 4 E2B model, which I fine-tuned using a custom dataset and a LoRA-based workflow.

GrassQuest — Less Scrolling More Exploring!

Nilam Kumari Mahato — Mon, 12 Oct 2026 05:41:17 +0000

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

What I Built

GrassQuest is a nature-exploration companion designed to help people take a break from their screens and reconnect with the world around them. 🌱

We spend so much time scrolling, studying, coding, and staring at screens that we sometimes forget to notice the little things around us—a tiny flower growing beside a path, birds singing in the morning, clouds changing shapes, or the peaceful feeling of walking outdoors.

I wanted to build something that makes going outside feel fun rather than like another task on a to-do list.

With GrassQuest, users can choose their mood, interests, preferred duration, and environment to get a personalized nature-based quest. Whether it's observing flowers, listening to birds, exploring nearby greenery, or simply taking a mindful break, each quest encourages users to step away from their screens and experience the real world.

🌼 The goal: Less endless scrolling, more real-world exploring!

GrassQuest also features a cute sticker-reward concept to make completing quests feel more playful and rewarding.

Demo

🎥 YouTube Demo: Watch GrassQuestin action

The demo walks through the GrassQuest experience, from selecting preferences to generating a nature quest and exploring its reward system.

Code

GitHub Repository: Explore the GrassQUest source code .

GrassQuest is an open-source project built to experiment with making AI useful beyond the screen.

Feel free to explore the code, share feedback, and contribute ideas!

How I Built It

I built GrassQuest using a web-based frontend and a backend that connects the user experience to AI-powered quest generation.

Tech stack:

React + Vite — Frontend and interactive user interface

Tailwind CSS — Styling and responsive design

Node.js + Express — Backend API

Ollama + Gemma — Local inference with an open-weight AI model

Git and GitHub — Version control and open-source collaboration

The idea is to use AI to turn a few simple preferences—such as mood, interests, time available, and surroundings—into an actionable nature quest.

Instead of asking users to spend more time chatting with an AI, GrassQuest uses AI as a starting point for an offline experience. The generated quest should encourage users to put their devices away and engage with their environment.

And I have also added Stickers as award upon completion of quests

Why Does Open Innovation Matter?

For GrassQuest, open innovation matters because AI should help people engage with the world, not just spend more time online.

Using open-weight AI models and local inference gives developers more control over how AI-powered experiences are built and lets them experiment without depending entirely on a closed, paid API.

It also makes the project a learning opportunity: I can explore how AI models can be integrated into a real application, understand the backend integration, and experiment with prompts and outputs.

Open-source tools make this kind of experimentation more accessible to students and independent developers. They also make it easier for others to inspect the implementation, suggest improvements, and build on the idea.

I built GrassQuest as a small step toward using AI more intentionally—not just to generate more digital content, but to inspire meaningful experiences offline. 🌿

Prize Categories

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

Thanks for checking out GrassQuest! 🌱

Sometimes the best quest isn't on a screen. It's waiting just outside your door. 🍀

DesignSpark — Never Stare at a Blank Figma Canvas Again ✨

Nilam Kumari Mahato — Mon, 05 Oct 2026 02:25:46 +0000

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

What I Built

DesignSpark is an AI-powered UI/UX design challenge generator that I built for a friend who is learning UI/UX design.
One of the biggest problems she faces isn't knowing how to design.
It's knowing what to design.
Sometimes you open Figma, create a new blank frame, and then spend more time thinking:
"Okay... but what should I actually make?"

That's where DesignSpark comes in.
Instead of generating a complete UI, DesignSpark gives you a realistic design problem to solve yourself.
You choose:

🎯 A design category
📊 A difficulty level And DesignSpark generates a structured design challenge containing things like:
A realistic problem
Target users
User scenario
Design objective
Design task
Constraints
Edge cases
Things to think about
Suggested number of screens For example: Category: Healthcare Difficulty: Intermediate

Challenge:
Design a medication management experience
for elderly users who take multiple medications
throughout the day.

Target User:
Adults aged 60+ managing daily medication.

Constraints:
• The experience should be easy to understand.
• Consider accessibility and readability.
• Handle missed medication scenarios.

Edge Cases:
• A user forgets a dose.
• Medication schedule changes.
• Multiple medications have overlapping times.

The important part is that DesignSpark doesn't design the solution for you.
It gives you the problem.
You bring the creativity. We bring the challenge. ✨

Demo

Live Demo:DesignSpark
Demo Video:VideoDemo

Code

GitHub:Github Repo

How I Built It

The core stack is:
Frontend

React
TypeScript
Vite
Tailwind CSS
React Router
Lucide React
Framer Motion Backend
Node.js
Express.js
Zod
CORS
dotenv AI The most important part of DesignSpark is Gemma 4. I use the open-weight Gemma 4 model through Google's API to generate the design challenges. The architecture looks like this: DesignSpark │ ▼ React + TypeScript │ │ category │ difficulty ▼ Express.js Backend │ ▼ Challenge Prompt │ ▼ Gemma 4 │ ▼ Structured Challenge │ ▼ React Challenge UI

I deliberately kept the AI on the backend rather than calling it directly from the frontend so that the API key isn't exposed to the client.
The backend also validates the user's category and difficulty before sending the request to the model.
The AI's role
I wanted to avoid building another tool where AI simply creates a UI and the human watches.
Instead, Gemma acts more like a design challenge mentor.
The prompt tells the model:

Don't generate HTML/CSS.
Don't generate code.
Don't create a wireframe.
Don't specify the exact UI layout.
Don't solve the design problem.
Give the designer enough context to solve it creatively. This means the AI provides the starting point, while the human still does the actual design work.

Why Does Open Innovation Matter?

For DesignSpark, open innovation is important because the goal isn't just to use AI — it's to use AI in a way that keeps the human creative process at the center.
A closed AI system could generate a complete interface for the user.
But that's not what I wanted.
I'm building DesignSpark for someone who is trying to learn design.
If the AI creates the entire solution, she doesn't get to practice the skills she's trying to develop.
Using an open-weight model like Gemma lets me build an AI-assisted workflow where the model provides structured challenges while the designer remains responsible for the creative decisions.
It also gives developers more freedom to experiment with how AI is integrated into applications rather than treating AI as a black-box feature.
For DesignSpark, open innovation makes it possible to explore a different question:
What if AI didn't replace the creative process, but helped people start it?

That's the idea behind DesignSpark.

My Agent Session

I used an AI coding agent during development to help structure the Express backend, integrate the Gemma 4 API, and improve the project architecture.

Prize Categories

Gemma — Gemma 4 is the core AI model powering DesignSpark's design challenge generation.
Render — The DesignSpark is deployed on Render .