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!