This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.
What I Built
Meet LazyDesk AI — a local-first AI file organizer designed for people who would rather spend their time building things than organizing folders.
We all have that one Downloads folder. Random screenshots, receipts, duplicate photos, old documents, code snippets, and files named final_v2_really_final.pdf.
Organizing them manually is boring. So I built a tool to help automate the process.
LazyDesk AI scans a folder you choose, analyzes supported files using a locally running AI model, suggests meaningful filenames and folder categories, detects exact duplicates, and lets you review and apply changes.
What can it do?
- 🤖 Smart categorization: Use local AI to suggest where files belong.
- ✍️ Meaningful filenames: Turn confusing filenames into descriptive alternatives.
- 🔍 Duplicate detection: Find byte-for-byte identical files using SHA-256 hashes.
- 📋 Cleanup queue: Review, edit, approve, or reject suggestions before making changes.
- ⏪ Undo operations: Restore files to their original locations using the operation journal.
- 🛡️ Safe file handling: Prevent path traversal, destination collisions, and silent overwrites.
- 📴 Offline fallback: Continue organizing files with a rule-based engine when Ollama is unavailable.
The goal is simple: less time managing files, more time doing meaningful work.
Demo
The project also includes an interactive demo mode with sample unorganized files, so you can explore the workflow without starting with your personal files.
The ideal workflow is straightforward:
- Select a folder.
- Scan its contents.
- Let the local AI generate organization suggestions.
- Review and approve the proposed changes.
- Apply the changes and undo them if necessary.
Code
GitHub repository: click
The project is released under the MIT License.
Contributions, bug reports, feature ideas, and improvements to the safety mechanisms are welcome.
How I Built It
LazyDesk AI is a full-stack application built around local AI inference rather than a cloud-based AI API.
The tech stack
- Frontend: React 19, TypeScript, Vite, Tailwind CSS
- Backend: Node.js, Express, TypeScript
- Database: SQLite with Better-SQLite3
- AI inference: Ollama and configurable open-weight models
- Validation: Zod
- Testing: Vitest, React Testing Library, and Supertest
Why Ollama?
Ollama provides a straightforward way to run compatible language models locally and communicate with them through an API.
LazyDesk AI uses Ollama's Chat API to analyze supported document content and generate structured organization suggestions. The application validates model responses before using them.
The AI can recommend a category, destination folder, filename, explanation, and confidence score.
Importantly, the model doesn't get to execute its recommendations directly. The application validates paths, checks for collisions, and requires user approval before applying file operations.
If Ollama is unavailable, the rule-based categorization engine keeps the core organization workflow usable.
This means the application isn't completely dependent on a running language model to remain useful.
Why Does Open Innovation Matter?
For this project, open innovation isn't just about using a different AI provider. It changes where the computation happens and who controls the data.
1. Your files stay on your machine
File organization can involve private documents, financial receipts, personal notes, and work-related information.
Sending those files to an external AI API introduces a dependency on another company's infrastructure and data-handling policies.
With LazyDesk AI, the intended default is local processing. Supported document content is analyzed through a local Ollama service instead of a paid cloud inference API.
2. No paid inference API is required
Once the application dependencies and model weights are installed, local inference doesn't require purchasing cloud API tokens.
The trade-off is that local inference still consumes your computer's CPU, memory, and potentially GPU resources. Model downloads and initial setup also require connectivity unless everything is already available locally.
3. Freedom to experiment with models
Different models can behave differently when categorizing documents or generating filenames.
By making the model configurable, LazyDesk AI allows experimentation with compatible local models without tying the application to one proprietary inference service.
Model licensing varies, so open-weight availability should not be confused with every model having the same open-source license.
4. Automation without surrendering control
Open AI makes experimentation more accessible, but automation still needs safeguards.
LazyDesk AI treats file contents as untrusted input, validates model output, checks destination paths, and records file operations for recovery.
The model proposes. The application validates. The user decides.
That separation matters when AI is working with real files instead of generating text in a chat window.
The Lazy Payoff
The real payoff is reducing the repetitive decisions involved in maintaining a digital workspace.
Instead of manually opening documents, guessing where they belong, renaming them, and searching for duplicates, users can review a batch of suggestions in one place.
I also focused on making the cleanup process reversible. Automation is much easier to trust when you can inspect its actions and recover from mistakes.
I haven't established a measured time-saving figure yet, so I won't claim that the application saves a specific number of minutes or hours. That would require testing it against a real folder and comparing the results with manual organization.
For now, the goal is to make file cleanup less tedious, safer, and easier to repeat.
Testing and Safety
File organization software can cause real problems if it moves or overwrites the wrong files. Safety therefore had to be part of the implementation rather than an afterthought.
LazyDesk AI includes safeguards for:
- Restricting scans and destinations to permitted workspace boundaries.
- Avoiding symbolic links that escape the selected workspace.
- Rejecting invalid filenames and unsafe paths.
- Detecting destination conflicts before applying changes.
- Preventing silent file overwrites.
- Avoiding automatic deletion of duplicate files.
- Recording operations in a persistent SQLite journal.
The project README reports 42 passing tests, covering important safety checks, duplicate detection, AI response validation, API behavior, and rollback scenarios.
Final Thoughts
The best automation isn't always the most complicated one. Sometimes, it's the tool that quietly takes an annoying task off your plate.
LazyDesk AI explores how locally run AI can make everyday computer maintenance more convenient without requiring users to hand their files over to a cloud service.
The broader idea is simple: open AI should give people more control over their tools, not just another place to send prompts.
Build less busywork. Keep control of your data. Let your computer do the boring stuff.
That's my version of Slow and Steady. 🦥
If you try the project, I'd love to hear what you'd improve, which local models work best for your files, and what other repetitive tasks you'd like to automate.
Top comments (0)