LazyDesk: I Built a Local AI That Organizes My Files So I Don't Have To

Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady Submission 🦥

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

My Downloads folder has a habit of becoming a digital junk drawer.

PDFs from college, screenshots, documents, random images, project files, and files with names like final_v2_latest_REAL.pdf all end up in the same place.

I could organize them manually. I could also keep postponing it.

For Hacktoberfest Week 3, I decided to build something that takes the repetitive work off my hands: LazyDesk, a local AI-powered file organizer.

The idea is simple: let AI handle the tedious parts while keeping me in control of the final changes.

LazyDesk is a small desktop-friendly application that helps users organize files with the assistance of an open-weight AI model.

Instead of asking users to manually inspect every file, rename it, decide where it belongs, and move it into the right folder, LazyDesk prepares an organization plan.

The goal isn't to let an AI run wild across someone's computer. It's to eliminate repetitive decisions while leaving the user in control.

The principle: automate the boring work, not the user's judgment.

In the demo, I'll show a folder containing disorganized files, the AI-generated organization plan, and the resulting folder after approving the changes.

The repository includes the application source code, setup instructions, dependencies, example files, and documentation explaining how the local AI integration works.

I built LazyDesk using Python, Streamlit, Ollama, and an open-weight Gemma model.

The application is divided into four main parts:

The application collects basic metadata such as filenames, extensions, and file sizes. Where necessary, it can extract relevant text from supported documents to make more informed suggestions.

The model receives a limited description of each file and proposes a category, a clearer filename, and a short explanation. Structured output helps the application validate the suggestions before using them.

The proposed changes appear in a review interface. Users can edit, reject, or approve suggestions instead of trusting every AI output blindly.

The application applies approved changes through ordinary Python file operations. It checks paths, handles naming conflicts, avoids silently overwriting files, and records the changes made.

The language model proposes actions; the application validates them; the user approves the final plan.

This separation is important because a language model can make mistakes, and a file organizer should never treat every generated suggestion as automatically correct.

One interesting challenge is that file organization requires more than generating a plausible filename.

A model might suggest a filename that already exists, misunderstand a document, or return a category that doesn't match the application's allowed options.

I address this by validating model output, constraining category choices, checking destination paths, and requiring approval before moving files.

For this project, using an open-weight model isn't just a technical preference. It changes where the work happens and who controls the data.

Files can contain academic work, personal documents, financial records, and other information that users shouldn't casually upload to an external service.

Running inference locally allows the application to analyze supported files without sending their contents to a third-party AI API, provided the complete workflow is configured to remain local.

An open-weight model gives developers more flexibility to choose an appropriate model, adjust prompts, change inference settings, and experiment with different models as their requirements evolve.

Once a compatible model is downloaded, local inference can avoid per-request charges from a hosted language-model API. The trade-offs include local hardware requirements, model storage, electricity, and inference speed.

Open AI tooling makes it possible to inspect the surrounding implementation, experiment with different models, and understand how the application behaves instead of treating the model as an inaccessible service.

For LazyDesk, the important advantage is that AI-assisted file organization can be built around user-controlled data and transparent file operations.

[OPTIONAL: EMBED OR LINK YOUR DEVRELAY AGENT SESSION HERE.]

I used [INSERT YOUR ACTUAL DEVELOPMENT WORKFLOW OR TOOLS] to build and test the application. The session shows how the project evolved, the implementation decisions I made, and the problems I worked through.

The point of LazyDesk is to replace a repetitive manual process with a reviewable, AI-assisted workflow.

For my demonstration, I tested it with [NUMBER] files across [NUMBER] categories.

These measurements come from my actual test run, not estimated performance figures.

The most useful outcome is not simply that AI can rename files. It's that a user can review an entire proposed cleanup in one place instead of making every decision individually.

[LIST ONLY THE PARTNER CATEGORIES THAT YOUR IMPLEMENTATION ACTUALLY QUALIFIES FOR, OR REMOVE THIS SECTION.]

I'd like to explore additional capabilities such as duplicate-file detection, customizable organization rules, scheduled cleanup suggestions, and support for more document formats.

The guiding idea will remain the same: let local AI handle the tedious parts, keep potentially sensitive data under the user's control, and make consequential actions reviewable.

Building LazyDesk for the Hacktoberfest Slow and Steady challenge has been a reminder that a useful AI project doesn't have to be enormous. Sometimes, the best automation is the one that quietly gives people their time back.

If you've built a tool that saves you from a repetitive task, I'd love to hear about it.