DEV Community

Nadun Jayaweera
Nadun Jayaweera

Posted on

LazyDesk AI: Let Local AI Clean Up Your Digital Mess

#devchallenge #hf26challenge

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.

What I Built

I built LazyDesk AI, a local AI-powered file cleanup assistant that helps organize messy filenames without making the user do all the boring decision-making.

The idea is simple:

Your files are messy. Your weekend doesn't have to be.

A lot of us have folders like:

Downloads
Desktop
Documents
Enter fullscreen mode Exit fullscreen mode

filled with files such as:

invoice-final2.pdf
project-final-final-v3.docx
IMG_9988.jpg
meeting_notes_latest.txt
expense-receipt-copy.pdf
Enter fullscreen mode Exit fullscreen mode

Cleaning this manually means deciding:

  • what each file probably is
  • what a better filename would be
  • which folder it belongs in
  • whether the filename is already good enough
  • whether two similarly named files are actually related

That is exactly the kind of small task people keep putting off.

LazyDesk AI reduces that effort.

The user simply pastes a list of filenames and clicks:

Organize with AI
Enter fullscreen mode Exit fullscreen mode

The app then uses a local Gemma model to generate a cleanup plan containing:

  • original filename
  • suggested filename
  • suggested folder
  • reason for the suggestion
  • confidence level

For example:

invoice-ioc-oct.pdf
Enter fullscreen mode Exit fullscreen mode

might become:

Ioc-October-Invoice.pdf
Enter fullscreen mode Exit fullscreen mode

with a suggested folder:

Finance/Invoices
Enter fullscreen mode Exit fullscreen mode

and an explanation such as:

The filename appears to describe an invoice for Ioc.
Enter fullscreen mode Exit fullscreen mode

Who gets to be a little lazier?

LazyDesk is useful for anyone who regularly deals with messy digital folders, including:

  • developers
  • project managers
  • freelancers
  • office staff
  • students
  • small business owners
  • anyone whose Downloads folder has become a graveyard

Instead of manually organizing everything one file at a time, the user lets AI make the first set of decisions.

Demo

Here is my video demo:

https://youtu.be/Edtroqk8eAY

The demo shows the full workflow:

Paste messy filenames
        ↓
Enable Lazy Mode
        ↓
Organize with AI
        ↓
Review filename suggestions
        ↓
Review folder suggestions
        ↓
Edit suggestions if needed
        ↓
Approve cleanup plan
        ↓
Save cleanup history locally
Enter fullscreen mode Exit fullscreen mode

One important design choice is that LazyDesk does not automatically rename, move, or delete real files in the current version.

It creates a cleanup plan first.

That keeps the experience safe while still removing most of the decision-making.

Code

The full source code is available here:

https://github.com/nadunjayaweera/lazydesk-ai.git

The project contains:

  • React frontend
  • Node.js / Express backend
  • Ollama integration
  • Gemma 3 1B local inference
  • Local JSON persistence

How I Built It

LazyDesk AI uses a simple architecture:

React Frontend
      ↓
Node.js / Express
      ↓
Ollama
      ↓
Gemma 3 1B
      ↓
Structured Cleanup Plan
      ↓
User Review / Edit
      ↓
Approve
      ↓
Local JSON Storage
Enter fullscreen mode Exit fullscreen mode

Frontend

The frontend is built with:

  • React
  • Vite
  • CSS

The main screen contains:

  • Workspace name
  • Lazy Mode toggle
  • Filename input
  • AI-generated cleanup plan
  • Editable filename suggestions
  • Editable folder suggestions
  • Confidence indicators
  • Approval button
  • Cleanup history

The goal was to make the interface feel like a small productivity utility rather than a chatbot.

Lazy Mode

Lazy Mode is the main feature that matches the theme of the challenge.

When it is enabled, the user does not need to manually configure categories or folder rules first.

The concept is:

You provide the mess. AI makes the decisions.

The user pastes something like:

invoice-ioc-oct.pdf
IMG_1234.jpg
Apex-agreement-final.docx
meeting_notes.txt
expense-receipt.pdf
project-final-final-v2.docx
Enter fullscreen mode Exit fullscreen mode

and LazyDesk decides how the files could be organized.

Local AI

LazyDesk currently uses:

Gemma 3 1B

running locally through:

Ollama

The backend sends Gemma the list of filenames with instructions such as:

- Do not delete any file.
- Do not invent file contents.
- Preserve file extensions.
- Suggest clearer filenames.
- Suggest practical folder paths.
- Preserve client or project names.
- Avoid overly long filenames.
- Return valid JSON only.
Enter fullscreen mode Exit fullscreen mode

Gemma returns structured JSON.

Example:

{
  "summary": "Organized 4 files into practical folders.",
  "files": [
    {
      "original_name": "invoice-ioc-oct.pdf",
      "suggested_name": "Ioc-October-Invoice.pdf",
      "folder": "Finance/Invoices",
      "reason": "The filename appears to describe an invoice for Ioc.",
      "confidence": "high"
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

The response is normalized by the backend before being displayed in React.

Confidence Levels

Each AI suggestion also includes a confidence value:

high
medium
low
Enter fullscreen mode Exit fullscreen mode

This helps the user understand when the model is reasonably confident about a filename versus when the suggestion may need more review.

For example:

invoice-ioc-oct.pdf
Enter fullscreen mode Exit fullscreen mode

may have:

high confidence
Enter fullscreen mode Exit fullscreen mode

while:

IMG_9988.jpg
Enter fullscreen mode Exit fullscreen mode

may have:

low confidence
Enter fullscreen mode Exit fullscreen mode

because the filename itself does not explain what the image contains.

That is important because LazyDesk currently works from filenames only.

It does not pretend to know what is inside a file.

Editable AI Suggestions

I also wanted to avoid treating every AI suggestion as automatically correct.

The user can edit:

  • suggested filename
  • suggested folder

before approving the plan.

For example:

AI suggestion:
Projects/Reports
Enter fullscreen mode Exit fullscreen mode

can be changed to:

Clients/Apex/Reports
Enter fullscreen mode Exit fullscreen mode

before approval.

When the cleanup plan is approved, the edited version is saved locally.

This gives the AI the boring first-pass work while keeping the user in control.

Safe by Design

The current version intentionally does not perform destructive actions.

LazyDesk does not automatically:

  • delete files
  • rename real files
  • move real files
  • inspect file contents

The current workflow is:

Recommend
   ↓
Review
   ↓
Edit
   ↓
Approve
Enter fullscreen mode Exit fullscreen mode

A future version could continue with:

Execute
   ↓
Undo
Enter fullscreen mode Exit fullscreen mode

but I wanted the Hacktoberfest version to focus on safe AI-assisted planning first.

Local JSON Storage

Cleanup plans are stored locally in JSON.

The backend saves them in:

server/data/cleanup-plans.json
Enter fullscreen mode Exit fullscreen mode

Each saved plan contains:

Workspace
Mode
Summary
Status
Files
Created date
Approved date
Enter fullscreen mode Exit fullscreen mode

Because of this, the user can refresh the frontend and still reopen previous cleanup plans.

No database is required for the current MVP.

Why Does Open Innovation Matter?

Open innovation matters a lot for LazyDesk because file organization often involves private or work-related information.

Even filenames can reveal information such as:

salary-report-october.xlsx
client-contract-final.docx
internal-meeting-notes.txt
customer-invoice.pdf
Enter fullscreen mode Exit fullscreen mode

For this kind of utility, I wanted the core AI inference to run locally.

Privacy

Gemma runs locally through Ollama.

That means the filename list does not need to be sent to a third-party cloud AI service for the core cleanup workflow.

This is particularly useful for:

  • client documents
  • financial files
  • internal work files
  • personal documents
  • company project folders

No Per-Request AI Cost

File organization is something a person might use repeatedly.

Today it might be:

Downloads
Enter fullscreen mode Exit fullscreen mode

Tomorrow:

Desktop
Enter fullscreen mode Exit fullscreen mode

Next week:

Old Projects
Enter fullscreen mode Exit fullscreen mode

With a paid cloud AI API, each cleanup request can create additional usage cost.

With a local open-weight model, once the model is installed, there is no per-request AI provider charge for the core inference.

That makes LazyDesk practical as a small utility someone can run whenever the digital clutter gets out of control.

Offline-Friendly

Once Ollama and Gemma are installed, the AI inference can run locally without requiring a cloud AI service.

That means LazyDesk can still generate cleanup plans even without an internet connection.

Model Flexibility

LazyDesk is also not permanently tied to one commercial AI provider.

Because it uses Ollama, another compatible open-weight model could be tested later.

For example, different models could be compared for:

  • filename understanding
  • folder categorization
  • inference speed
  • memory usage
  • larger context windows
  • better structured output

That flexibility is one of the main reasons open-weight AI works well for a small utility like this.

The Lazy Payoff

The theme for this challenge is Slow and Steady, and LazyDesk is intentionally designed around doing less manual work.

Without LazyDesk, organizing a messy folder usually looks like this:

Open folder
↓
Look at first file
↓
Decide what it is
↓
Think of a better name
↓
Choose a folder
↓
Repeat for every file
↓
Get bored
↓
Close the folder
Enter fullscreen mode Exit fullscreen mode

With LazyDesk:

Paste filenames
↓
Click Organize with AI
↓
Review
↓
Approve
Enter fullscreen mode Exit fullscreen mode

The AI handles the repetitive first-pass decisions.

The user only spends time correcting suggestions that actually need attention.

That is the lazy payoff:

less deciding, less renaming, less folder planning.

For a small batch of files, the time saved may only be a few minutes.

But for a large Downloads folder or project archive, removing the repeated decision-making can save much more effort.

More importantly, it lowers the mental barrier to starting the cleanup at all.

Sometimes the biggest productivity improvement is simply making an annoying task easy enough that you finally do it.

What I Learned

Building LazyDesk helped me explore AI as a tool for reducing repetitive decision-making rather than just generating text.

I practiced:

  • running Gemma locally with Ollama
  • connecting React to local AI
  • building structured prompts
  • validating JSON output
  • building confidence indicators
  • creating editable AI recommendations
  • building an approval workflow
  • persisting data using JSON
  • designing safer AI automation
  • keeping the user in control

One of the biggest lessons from this project was that useful automation does not need to be fully autonomous.

For something involving files, it can be better to let AI prepare the work while the human makes the final decision.

That is the balance I tried to build into LazyDesk.

Final Thoughts

LazyDesk AI is intentionally simple.

It does not try to become a complete file management system.

It focuses on one annoying problem:

deciding how messy files should be organized.

The user provides the filenames.

Gemma provides the first-pass cleanup plan.

The user reviews it.

Then LazyDesk remembers the decision.

For the Slow and Steady challenge, that felt like the right approach:

Let AI do the boring part so you can be a little lazier.

Top comments (0)