DEV Community: Monisha14206

LazyDesk: Let AI Handle Your Messy Files

Monisha14206 — Sun, 25 Oct 2026 06:09:00 +0000

LazyDesk — Let AI Handle Your Messy Files

Less time organizing files. More time doing what matters.

This is my submission for Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady.

devchallenge #hf26challenge #opensource #ai #python #react

The Problem: The Downloads Folder Chaos

We've all been there.

You download a PDF for college, save screenshots from a project, collect images, and create documents. At first, everything seems fine. A few weeks later, finding one specific file feels like a treasure hunt.

What if AI could help organize those files for us?

That's the idea behind LazyDesk — a local-first, AI-assisted file organizer designed to reduce repetitive file management while keeping the user in control.

The Idea

        Messy Downloads Folder
                  |
                  v
             LazyDesk + AI
                  |
          +-------+--------+
          |       |        |
          v       v        v
      Categories Names  Suggestions
          |       |        |
          +-------+--------+
                  |
                  v
            User Reviews
                  |
                  v
            Approve Changes
                  |
                  v
            Organized Files

The goal is simple: let AI handle the repetitive suggestions while the user makes the final decisions.

What LazyDesk Is Designed to Do

Feature	What it helps with
File scanning	Inspect files in a selected folder
Smart categorization	Suggest suitable folders for different file types
Rename suggestions	Recommend clearer, more meaningful filenames
Preview before action	Review proposed changes before approving them
Activity history	Track changes and support recovery where implemented
Local-first AI	Explore AI assistance using a model running on the user's computer

These are planned capabilities. I'll mark each feature as complete only after implementing and testing it.

Demo

See LazyDesk in action

[Add your demo video link here]

Replace this placeholder with a screenshot or GIF of your actual application. A short recording of scanning a folder, reviewing suggestions, and approving a change would make the demo especially useful.

Project links

GitHub repository: [Add your repository link]
Demo video: [Add your video link]
Agent session: [Add your actual session link, if available]

How It Works

Here is the proposed workflow from selecting a folder to organizing files.

flowchart TD
    A([Start LazyDesk]) --> B[Select a Folder]
    B --> C[Scan Selected Files]
    C --> D[Collect File Metadata]
    D --> E[Generate Organization Suggestions]
    E --> F[Show Proposed Names and Locations]
    F --> G{User Approves?}
    G -- No --> H[Edit or Reject Suggestions]
    H --> F
    G -- Yes --> I[Apply Approved Changes]
    I --> J[Record Activity]
    J --> K([Finish])

The important part is the approval step. AI should suggest what to do, not silently move or rename files without the user's permission.

Under the Hood: Architecture

The planned architecture separates the user interface, file operations, AI integration, and activity history.

flowchart LR
    U[User] --> UI[React + Vite UI]
    UI <--> API[Python + Flask Backend]
    API --> FS[Local File System]
    API <--> AI[Ollama + Local Model]
    API <--> DB[(SQLite Activity History)]
    FS --> API
    API --> UI

The components

React + Vite: The interface for selecting folders and reviewing suggestions.
Python + Flask: The backend responsible for coordinating requests and validating approved operations.
Ollama + a local model: The planned AI component for generating useful organization suggestions.
SQLite: The planned store for activity history.
Local file system: The files the user chooses to organize.

The diagram represents the intended design, not a claim that every integration is already working.

Where Open-Source AI Fits In

LazyDesk explores a practical use for locally hosted, open-weight AI models.

Instead of relying on a remote AI service for every suggestion, the application can use a model running through Ollama on the user's computer.

That approach can help keep file-related information local, provided the implementation does not send it elsewhere. It also gives developers an opportunity to experiment with models and adapt the application to their needs.

One important distinction: a model being open-weight does not automatically make the entire application open-source or guarantee privacy. The application code, model licence, network behaviour, and data handling all matter.

Safety by Design

File operations can cause real problems if handled carelessly. A wrong rename or move can make an important document difficult to find.

The intended safety workflow is:

flowchart TD
    A[AI Suggests a Change] --> B[Validate the Proposed Path]
    B --> C[Preview the Change]
    C --> D{User Confirms?}
    D -- No --> E[Leave the File Unchanged]
    D -- Yes --> F[Apply the Change]
    F --> G[Record the Result]
    G --> H[Offer Recovery if Supported]

The key principles are:

No automatic file changes without explicit approval.
Operate only on folders selected by the user.
Validate proposed filenames and destination paths.
Handle duplicate names and errors carefully.
Keep an activity record where implemented.
Test recovery features before claiming that changes can be undone.

Tech Stack

Layer	Technology
Frontend	React + Vite
Backend	Python + Flask
AI runtime	Ollama
AI model	Qwen2.5 or another compatible local model
Activity history	SQLite

The exact model and technology choices should match the version that actually runs in the final project.

Challenges and Learnings

Building an AI-assisted utility involves more than connecting a model to an interface.

Some important areas to work through are:

Making AI suggestions useful instead of unpredictable.
Preventing invalid filenames and unsafe file paths.
Handling duplicate names and file-operation errors.
Keeping the interface understandable for beginners.
Separating AI-generated suggestions from actual file-system operations.

These are also opportunities to learn how frontend, backend, local AI, and safety checks work together in a practical application.

What's Next?

Potential improvements include:

More accurate categorization for mixed file types.
Custom categories and user preferences.
Better filename suggestions based on file content, with explicit permission where needed.
A detailed preview of every proposed change.
More robust recovery and error handling.
Packaging the application for easier Windows installation.

Why I Chose This Idea

I wanted to explore how open-source AI could help with a small, familiar problem rather than build something complicated just for the sake of using AI.

Organizing files is ordinary work, but it is also repetitive work. If an AI-assisted tool can make that process easier while preserving user control, it can be genuinely useful.

LazyDesk is my exploration of that idea: make everyday computer tasks a little less tedious, one small improvement at a time.

Agent Session

AI coding assistant: Claude Code

Agent session link: [Paste your actual agent session URL here]

I used AI assistance to help plan and develop LazyDesk. The session documents the prompts, implementation decisions, and development process behind the project.

Prize Categories

This project is submitted for consideration in the following categories:

Main Challenge: Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady
Open-Source AI: Using a locally hosted, open-weight AI model to explore AI-assisted file organization.
Automation: Reducing repetitive file-management tasks through AI-generated suggestions and user-approved actions.

Try It / Contribute

Once the repository and working demo are ready, you can add:

GitHub: [Repository URL]
Demo: [Demo URL]
Issues and contributions: [Repository issues URL]

I'd love to hear suggestions for making local-first AI tools safer and more useful.

Thanks for reading!

LazyDesk: An Open-Source AI That Organizes Your Files Locally

Monisha14206 — Sun, 25 Oct 2026 05:45:13 +0000

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

🦥 LazyDesk: Let AI Organize Your Files While You Relax

What I Built

Have you ever opened your Downloads folder and found a mixture of PDFs, screenshots, assignments, documents, and project files everywhere?

I have, and organizing everything manually can be surprisingly time-consuming.

That's why I built LazyDesk, a local-first AI-powered desktop file organizer designed to make file management easier.

LazyDesk scans a folder selected by the user, uses AI to categorize files, suggests meaningful filenames and destination folders, and creates an organization plan for review.

Instead of manually sorting every file, users can review the suggestions, approve the changes, and let LazyDesk handle the repetitive work.

The goal is simple: spend less time organizing files and more time doing things that matter.

Demo

🎥 Video demo: [Add your demo video link here]

🖥️ Live demo: LazyDesk is designed to run locally on your computer. A deployed version is not required for its core functionality.

Code

💻 GitHub repository: [Add your LazyDesk repository link here]

The repository includes the frontend, backend, local AI integration, and setup instructions.

How I Built It

I built LazyDesk using a combination of web technologies, Python, and open-weight AI.

Technology stack:

React + Vite — frontend interface
Python + Flask — backend and file organization logic
Ollama — local model runtime
Qwen2.5 3B — open-weight language model for file categorization and naming suggestions
SQLite — local application history and organization records

The AI analyzes file metadata, suggests meaningful categories and filenames, and explains its recommendations. Python handles filesystem validation, duplicate detection, and file operations.

An important design decision is that AI suggestions are not applied automatically. Users review and approve changes before files are moved or renamed.

Why Does Open Innovation Matter?

For LazyDesk, open innovation is about giving users more control over their own files and their AI tools.

🔒 Privacy first

File organization can involve personal documents, college assignments, and project files. Running the model locally allows the application to avoid sending this information to a hosted AI provider.

📴 Offline capability

After the initial setup and model download, the core workflow can operate without an internet connection.

🛠️ Freedom to experiment

Users can change the model, adjust categorization rules, and improve the application without being locked into a proprietary AI API.

💸 Lower recurring costs

Local inference avoids per-request hosted AI API fees, although it still uses the computer's processing power, memory, and electricity.

🤝 Human control

AI is useful for making suggestions, but it can make mistakes. LazyDesk keeps users in control by requiring approval before file operations and using deterministic Python checks for filesystem safety.

Open-source AI makes it possible to build a useful personal productivity tool without making a cloud service the center of the experience.

The Lazy Payoff

Imagine returning to a folder full of unsorted files and getting a clear organization plan instead of spending time deciding where every file belongs.

That's the experience I want LazyDesk to provide.

Rather than organizing everything manually, users can review AI-generated suggestions, approve a batch of changes, and keep their files organized with less effort.

The next step is to measure the time saved using a realistic folder of sample files and compare manual organization with LazyDesk.

Building LazyDesk has been an opportunity to explore how open-weight AI can solve an everyday problem in a practical, privacy-conscious way.

Sometimes, productivity doesn't mean doing more. It means letting repetitive work take care of itself. 🦥

The world outside my window

Monisha14206 — Sun, 11 Oct 2026 02:34:24 +0000

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

What I Built

🌿 The World Outside My Window

Go live the moment. Capture what matters. Keep the memory.

The World Outside My Window is a local-first, AI-powered photo journal designed to help people preserve the little moments they experience in the real world.

Whether it's a peaceful walk in the park, a visit to the beach, a trip with friends, or an ordinary day that becomes a special memory, users can upload photos, describe what happened, share how they felt, and use AI to turn their experiences into beautiful, personalised journal entries.

Instead of letting meaningful moments disappear into a crowded camera roll, this project gives them a place to live as stories that can be revisited later.

The idea is simple: spend less time staring at a screen and more time experiencing the world around you. The app is designed to help people preserve their memories after experiencing life, rather than encouraging endless scrolling.

Demo

Demo video: https://drive.google.com/file/d/1CdobNpa3iD0JP7XgMw07UrL68ijiv42z/view?usp=sharing

The video will demonstrate the journal interface, creating a memory, generating a journal entry with AI, and saving and revisiting memories.

This project currently runs locally on my computer.

Code

GitHub repository: https://github.com/Monisha14206/The-world-outside-my-window

How I Built It

I built this project using:

React + Vite for the frontend.
Python + Flask for the backend and API.
SQLite for storing journal entries.
Local file storage for uploaded photographs.
Ollama + Qwen 2.5 3B for local inference with an open-weight language model.

The core AI feature is designed to transform a user's own notes, experiences, and feelings into a journal title and narrative that they can review and edit before saving.

The React frontend communicates with the Flask backend, which handles journal operations and requests to the locally running Ollama model. Journal entries are stored in SQLite, while uploaded photographs are kept in local storage.

I chose a local-first architecture so the application can run on a personal computer without requiring a paid AI API or a cloud database.

Why Does Open Innovation Matter?

Open innovation makes AI development more accessible to students, independent developers, and anyone who wants to experiment with new ideas without relying entirely on closed, paid AI services.

For this project, open-weight models and local inference provide more control over model selection, prompts, and the journal-writing experience. They also make it possible to explore a privacy-conscious approach where personal journal entries and photographs can remain on the user's computer in the intended local setup.

Most importantly, this project explores a different way to use AI: not to keep people glued to their screens, but to help them preserve the experiences they have away from them.

I want technology to help us remember life, not replace living it.

When You Need Me 💛 — A Private AI Companion Built for a Friend

Monisha14206 — Mon, 05 Oct 2026 09:28:07 +0000

What I Built

When You Need Me 💛

When You Need Me is a private AI companion built for a real friend.

Sometimes someone we care about wants to talk, share how they feel, or simply have someone listen — but we may be busy, unavailable, or unable to respond immediately.

I built this project to create a small bridge during those moments.

Instead of building another generic chatbot, I wanted the AI to understand how I communicate and combine that with what I know about my friend.

The system can:

Analyze an approved sample of my conversations to create a communication-style profile
Learn my tone, vocabulary, sentence style, emoji usage, humor, language mixing, and support style
Build a friend profile based on information I choose to provide
Generate responses using the communication style + friend profile + current conversation
Explain why a response feels like my communication style
Run the AI locally using an open-weight model
Provide safety handling for conversations involving serious distress
Allow users to delete stored chats, profiles, memory, and other personal data

Most importantly, the AI does not pretend to actually be me. It clearly identifies itself as an AI companion inspired by my communication style.

Demo

🌐 Live UI Demo

https://monisha14206.github.io/when-you-need-me/

The GitHub Pages version demonstrates the frontend experience.

🎥 Full AI Demo

The complete AI experience runs locally with Ollama and an open-weight model.

Demo video: https://drive.google.com/file/d/1tFId9IJMRS3d-3FGy0tEpueLhSw4rFPG/view?usp=sharing

Code

GitHub Repository

https://github.com/Monisha14206/when-you-need-me

The repository contains the complete frontend, backend, safety system, local AI integration, demo data, tests, and setup instructions.

How I Built It

Tech Stack

Frontend

React
Vite
JavaScript
CSS

Backend

Python
FastAPI
SQLite

AI

Ollama
llama3.2:3b
Open-weight local inference

Other

Local-first data storage
Rule-based safety layer
Communication-style analysis
Friend profile and memory system

How It Works

The basic architecture is:

             ┌─────────────────────┐
             │       Friend        │
             └──────────┬──────────┘
                        │
                        ▼
             ┌─────────────────────┐
             │   React Frontend    │
             └──────────┬──────────┘
                        │
                        ▼
             ┌─────────────────────┐
             │    FastAPI Backend  │
             └──────────┬──────────┘
                        │
            ┌───────────┼───────────┐
            ▼           ▼           ▼
      ┌──────────┐ ┌──────────┐ ┌──────────┐
      │  Style   │ │  Friend  │ │  Safety  │
      │ Analysis │ │  Profile │ │   Layer  │
      └────┬─────┘ └────┬─────┘ └────┬─────┘
           │            │            │
           └────────────┼────────────┘
                        ▼
             ┌─────────────────────┐
             │  Ollama / LLM       │
             │  llama3.2:3b        │
             └──────────┬──────────┘
                        │
                        ▼
             ┌─────────────────────┐
             │ Personalized Reply  │
             └─────────────────────┘

1. Communication Style

The user can provide an approved conversation sample.

Instead of sending the entire conversation to a cloud AI service, the application extracts useful communication patterns such as:

Tone
Sentence length
Vocabulary
Emoji usage
Punctuation
Humor
English/Telugu mixing
Listening style
Reassurance and advice style

These are converted into a communication-style profile.

2. Friend Profile

The user can optionally provide information about their friend, such as:

Personality
Interests
What makes them happy
What makes them upset
Preferred support style
Humor preferences
Topics to avoid
Important boundaries

3. Response Generation

The AI combines:

Communication Style
+
Friend Profile
+
Current Conversation
+
Approved Memory
+
Safety Rules
↓
Local Open-Weight LLM
↓
Personalized AI Response

4. Explainability

The application can also explain why a response feels similar to the user's communication style.

For example:

Casual conversational tone
Uses familiar expressions
Short supportive sentences
Matches the user's emoji style

This makes the personalization more transparent instead of simply saying that the AI "knows" the user.

5. Safety

The application includes a safety layer that classifies conversations into different levels of emotional distress.

For potentially serious crisis situations, the application does not simply let the language model generate an unrestricted response.

Instead, the safety layer can intervene and provide a predefined supportive response that encourages reaching out to trusted people and appropriate emergency/professional support.

The AI is also explicitly designed not to encourage emotional dependency.

It should never tell someone that they only need the AI or that the AI is their only source of support.

Why Does Open Innovation Matter?

I chose open-source AI because this project deals with something extremely personal: private conversations and relationships.

Using a closed cloud AI API would mean sending potentially sensitive conversations to an external service.

With a local open-weight model, the project can instead run the inference on the user's own computer.

This provides:

🔒 Privacy

Personal conversations can remain local.

🛠️ Control

The developer can inspect and modify how the system works.

🧠 Customization

The AI experience can be designed specifically for one person's communication style and use case.

💰 Accessibility

The project does not require a paid proprietary AI API to function.

🌍 Open Innovation

Open models and tools make it possible for students and independent developers to experiment with AI applications that would otherwise require expensive infrastructure or proprietary services.

For this project, open innovation is not just about using free software.

It gives me more control over where personal data goes, how the AI behaves, and how the system can be changed.

Privacy & Safety

Privacy is a core part of the project.

The project is designed around:

Local AI inference
No OpenAI/Claude/Gemini API
No real private conversations in the repository
Fictional demo data
Data deletion controls
Transparent AI identity
Safety rules for high-risk conversations
No encouragement of emotional dependency

The AI is not a therapist and does not replace real human support.

It is intended to provide a temporary supportive interaction while encouraging connection with real people when needed.

What I Learned

Building this project taught me that creating an AI application is not only about getting a model to generate a response.

The harder questions were:

What personal data does the AI actually need?
What information should never be sent to the model?
How can personalization happen without training a model?
How do you prevent an AI from pretending to be a real person?
What should happen when a conversation becomes unsafe?
How can users understand why an AI generated a particular response?

These questions influenced the architecture as much as the choice of model.

Challenges

The biggest challenge was balancing personalization and privacy.

I wanted the AI to feel familiar without simply feeding a person's entire chat history into an LLM.

The solution was to separate:

Raw Conversation
       ↓
Communication Analysis
       ↓
Communication Profile
       ↓
AI Prompt

This allows the application to use communication patterns without continuously sending the original private conversation to the model.

Another challenge was safety. A general-purpose LLM should not be responsible for making every safety decision, so I added a separate safety layer before response generation.

Future Improvements

Some improvements I would like to explore:

Better multilingual support
More sophisticated communication-style analysis
Optional voice interaction
Improved long-term memory controls
More granular privacy settings
Additional open-weight models
Better mobile experience
More explainable personalization
Optional encrypted local storage

My Agent Session

Optional

If you used an AI coding agent while building the project, I will include my agent session / development process here.

Prize Categories

Primary category: Open Source AI / AI Application

The project uses an open-weight model through Ollama and keeps the core AI functionality local rather than depending on a proprietary cloud AI API.

Final Note

I built When You Need Me for a simple reason:

Sometimes the person you want to talk to isn't available immediately.

I don't want an AI to replace that person.

I wanted to build something that can make the waiting period feel a little less lonely — while still being honest that it is an AI, keeping personal data under the user's control, and encouraging real human connection when it matters.

When you need me, even when I'm not immediately there. 💛