DEV Community: StylishDeployer

LazyDesk: Let Open-Source AI Organize Your Files While You Relax

StylishDeployer — Sun, 25 Oct 2026 17:24:39 +0000

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

What I Built

Meet LazyDesk, a local AI-powered file organizer built around a simple idea: organizing files shouldn't take more effort than necessary.

We all have a Downloads folder full of documents, screenshots, code files, and random files we promise ourselves we'll organize later. LazyDesk aims to make that boring task easier.

It uses an open-weight AI model to suggest sensible file categories, clearer filenames, and suitable destinations. Instead of blindly moving files, it lets users review and approve the suggestions first.

The goal is to spend less time managing files and more time doing the things that actually matter.

Code

Rakshit-Chauhan-byte / LazyDesk

How I Built It

I built LazyDesk using Next.js, TypeScript, and Tailwind CSS for the interface, with a local Node.js backend for file operations.

The AI component uses Gemma 3 4B through Ollama, allowing inference to run on the user's own machine instead of relying on a paid, hosted AI API.

The intended workflow is straightforward:

Select a folder to organize.

Let the local model suggest categories and filenames.

Review the suggestions.

Approve the changes and let LazyDesk handle the repetitive work.

I kept the architecture intentionally simple and focused on making the local AI component useful rather than adding unnecessary complexity.

Why Does Open Innovation Matter?

For LazyDesk, open innovation is about control.

Running an open-weight model locally gives users more control over where their file information goes. It also allows developers to experiment with different models, customize prompts, and improve the workflow without being locked into a single hosted AI provider.

Once the model is downloaded, local inference can work without an internet connection, provided the rest of the application and its dependencies are available locally.

It also removes per-request charges from a hosted AI API, although running a local model still uses hardware resources.

The open model isn't just an extra feature here. It is what makes private, locally controlled file organization possible.

The Lazy Payoff

The idea is simple: organize once, review quickly, and get back to what you were doing.

Instead of manually opening files, deciding where they belong, and renaming them one by one, users can review AI-generated suggestions in one place.

I'll use the demo to show the workflow and evaluate how much effort it actually saves.

DukaanSathi AI: Open-Weight AI for Small Indian Businesses

StylishDeployer — Mon, 19 Oct 2026 04:45:53 +0000

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

What I Built

I built DukaanSathi AI, an AI marketing assistant designed for small Indian businesses, local shopkeepers, and online sellers.

Small businesses often need to write product descriptions, WhatsApp promotions, and customer replies but may not have a dedicated marketing team. Writing these messages repeatedly takes time, especially when they need content in different languages.

DukaanSathi AI aims to make this easier. Users can enter basic product details, choose the type of content they need, select a language such as English, Hindi, or Hinglish, and generate content they can review, edit, and copy.

The idea is to make AI-powered marketing assistance simple and accessible for businesses that want to spend less time writing and more time serving customers.

Demo

dukaansaathi-ai-gamma.vercel.app

The demo shows how a few product details can be turned into ready-to-edit marketing content.

Code

GitHub repository: https://github.com/Rakshit-Chauhan-byte/DukaanSaathi-AI

Built with Next.js, TypeScript, and Tailwind CSS.

How I Built It

I built DukaanSathi AI as a web application using Next.js, TypeScript, and Tailwind CSS.

The application collects product information and the user's preferences through a simple form. A server-side API route validates the input and sends a prompt to a hosted inference provider running an open-weight language model. The generated content is then displayed so the user can review, edit, and copy it.

I focused on keeping the MVP small and useful rather than adding unnecessary features. The model is responsible for the actual content generation, which makes AI a core part of the product rather than just an extra feature.

Why Does Open Innovation Matter?

For me, open innovation means having more flexibility in how AI-powered products are built and improved.

DukaanSathi AI uses an open-weight model so that I can experiment with different models, refine prompts for Indian business use cases, and explore better support for multilingual marketing content.

It also gives the project more flexibility as it grows. I can evaluate alternative models and inference providers instead of designing the entire application around a single proprietary model.

For this MVP, hosted inference made integration simpler and allowed me to focus on the user experience without managing model-serving infrastructure myself.

There is an important trade-off: this version uses hosted inference, so it requires an internet connection and sends generation requests to the selected provider. It is not a fully local or offline AI application.

My goal is to explore how open-weight AI can make practical, affordable tools more accessible to small businesses.

What's Next?

I want to test DukaanSathi AI with more small business owners, understand which generated content is genuinely useful to them, and improve the results based on their feedback.

This project has been an opportunity to explore how open-weight AI can be used to solve a specific, everyday problem rather than building another general-purpose chatbot.

Thanks for checking out DukaanSathi AI!

TrailSense: Less Scrolling, More Exploring with Local AI

StylishDeployer — Sun, 11 Oct 2026 13:06:07 +0000

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

What I Built

TrailSense — Less Scrolling, More Exploring

TrailSense is a local-AI-powered outdoor quest generator designed to help people spend less time on their screens and more time exploring the world around them.

Users choose how much time they have and what kind of activity they enjoy. TrailSense generates a short outdoor mission with simple activities that encourage nature observation, mindful walking, and curiosity.

The idea is simple: use AI to prepare an outdoor experience, then put the phone away.

Code

GitHub repository: https://github.com/Rakshit-Chauhan-byte/TrailSense

How I Built It

TrailSense is built with Next.js, TypeScript, and Tailwind CSS. It uses Gemma 3 4B through Ollama for local AI inference.

The model generates short outdoor quests based on the user's selected duration and interests. The app includes a simple checklist, a completion flow, and a local journal for recording discoveries.

When the local model is unavailable, the app can display bundled fallback quests so users can still explore.

Why Does Open Innovation Matter?

I wanted AI to help people spend less time using technology, rather than encouraging them to spend more time chatting with it.

Running an open-weight model locally can keep prompts on the user's device and avoid per-request fees from a hosted AI API. It also gives developers more control over the model and the way it behaves.

Local inference does have trade-offs: the model must be downloaded, compatible hardware is required, and generation speed depends on the device.

TrailSense explores how local AI can make technology more private and useful while encouraging people to reconnect with the world outside their screens.

Prize Categories

No partner prize category claimed at this time.

Thanks for checking out TrailSense!

StudyBuddy: An Adaptive AI Study Planner That Adapts to You

StylishDeployer — Sun, 04 Oct 2026 19:03:07 +0000

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

What I Built

I built StudyBuddy, an adaptive AI study planner for a student who found that fixed study schedules were difficult to follow when assignments, deadlines, and unexpected work came up.

Instead of creating a plan once and expecting the student to follow it perfectly, StudyBuddy can adapt the remaining schedule when something changes.

I enter a study goal, available daily study time, deadline, and strong and weak topics. StudyBuddy then generates a personalized plan.

The important part comes when a task is missed.

Instead of simply moving the missed task to the next day and potentially overloading the schedule, the student can explain why they missed it — for example, because of a surprise assignment, exhaustion, sickness, or lack of time.

StudyBuddy then adapts the remaining plan around the situation while preserving completed work and respecting the student's remaining available time.

The idea is simple:

The student shouldn't have to adapt to the study plan. The study plan should adapt to the student.

I built this for a friend who was struggling to keep up with rigid study schedules because of changing college work and deadlines.

Demo

The demo shows the complete flow:

Create a personalized plan → Complete a task → Miss a task → Give a reason → Adapt the plan → See the updated schedule

Code

GitHub Repository

How I Built It

StudyBuddy is built with:

Next.js
TypeScript
Tailwind CSS
Firebase Firestore
Ollama
Gemma 3 4B

The core AI runs locally using Gemma 3 4B through Ollama.

I deliberately kept the architecture simple. The application calculates the valid study slots on the server and gives those constraints to Gemma rather than asking the model to independently calculate dates and scheduling limits.

For the initial plan, Gemma receives the student's profile, available study slots, strengths, weaknesses, and goal, and generates a structured study plan.

For adaptation, the model receives the missed task, the reason it was missed, the student's remaining available time, completed work, and future pending tasks.

The server then validates the model's response before applying the changes.

This means the AI is responsible for making the plan useful and adaptive, while the application remains responsible for enforcing the scheduling constraints.

Completed tasks are preserved, missed tasks remain in the history, and only future pending work is reorganized.

Why Does Open Innovation Matter?

For StudyBuddy, using an open-weight model made local AI inference practical.

Gemma 3 4B can run locally through Ollama, which means the core planning and adaptation logic does not depend on sending every AI request to a closed hosted API.

That gave me more control over the model, the prompts, the structured output, and how the application validates AI-generated plans.

It also makes experimentation easier. I can change the model or run a different open-weight model without redesigning the entire application around a proprietary API.

For a personal study tool, this approach is especially useful because it makes local experimentation possible while keeping the AI layer under the developer's control.

Prize Categories

Best Use of Gemma — Gemma 3 4B is the core AI model used for personalized study-plan generation and adaptive replanning.