Hacktoberfest Open-Source AI Challenge 2026 — Week 3: Slow and Steady

Ever opened your Downloads folder and found final_v2_REAL.pdf, screenshot_2026.png, backup.zip, and a bunch of files you promised yourself you'd organize someday? ????

That tiny organizational task somehow becomes a whole afternoon.

So I built SlothSort — an AI-powered file organizer designed to make that process safer, simpler, and less tedious.

???? Live Demo: https://slothsort-web.onrender.com/

???? Source Code: https://github.com/Tanmay-Dalvi/slothsort

???? What is SlothSort?

SlothSort scans a selected folder, analyzes file metadata, and proposes an organization plan with suggested destination folders and filenames.

But there's one important difference from a fully autonomous file agent:

The AI proposes. Deterministic code validates. You approve.

Files aren't moved just because a model suggested something. You can inspect the plan, edit individual destinations, select which operations to approve, and execute only after confirmation.

And if you change your mind, SlothSort supports undo for eligible operations.

???? Screenshots

The main dashboard, provider selection, and folder scanning interface.

Review proposed file moves and destinations before approving them.

An execution result showing the completed batch and available undo action.

Operation history and the ability to reverse eligible changes.

These are placeholders. Replace each ADD_SCREENSHOT_URL_X_HERE with the corresponding uploaded image URL before publishing.

✨ Key Features

• AI-assisted organization: Generate proposed categories, destination paths, and filenames.
• Local AI with Ollama: Run inference locally using an available model such as gemma3:1b.
• Optional hosted provider: Google Gemini can be selected explicitly when cloud processing is acceptable.
• Deterministic validation: Validate proposed operations before execution.
• Human approval: Review, edit, and select proposed operations before applying them.
• Collision protection: Detect conflicts instead of silently overwriting existing files.
• Undo and history: Track operations and reverse eligible batches.
• Safety-focused design: No file deletion operation is part of the intended organization workflow.
• Demo mode: Test the workflow with a dedicated sample folder instead of risking personal files.

???? Why local-first AI?

File metadata can reveal more than we realize. Filenames may contain names, project details, financial information, or other personal context.

That's why provider choice matters.

SlothSort supports three modes:

• Deterministic Mock: Rule-based suggestions for testing and demonstrations.
• Local Ollama: Model inference runs on your machine.
• Hosted Gemini: Sends the metadata required by the implementation to Google's API.

The local option helps keep processing on-device. The hosted option is explicit rather than a silent fallback.

One important distinction: local inference does not automatically mean every part of an application is network-free. The privacy boundary depends on the selected provider and application configuration.

????️ How I Designed It

I wanted to avoid giving an AI model unrestricted control over filesystem operations.

The system separates suggestions from execution:

1. Scan an authorized directory and collect file metadata.
2. Ask the selected provider to propose an organization plan.
3. Validate the proposed paths and operations deterministically.
4. Let the user review and approve the plan.
5. Execute the approved operations.
6. Record the results so eligible operations can be undone.

Architecture at a glance

Architecture diagram: frontend, API, provider layer, validation, execution, and undo.

???? Technology Stack

• Frontend: React, TypeScript, Vite, Tailwind CSS
• Backend: Python, FastAPI
• Local AI: Ollama with Gemma
• Hosted AI: Optional Google Gemini API integration
• Testing: Pytest and Vitest
• Deployment: Render for the hosted web interface

????️ Challenges I Worked Through

1. Keeping AI suggestions separate from file operations

A model response should never be treated as trusted filesystem instructions. The application needs deterministic validation and an explicit approval boundary.

2. Making undo safer

Undo is not simply moving everything back blindly. If a file has changed or a destination is no longer safe, restoration needs to respect those conditions rather than overwrite unrelated data.

3. Explaining privacy honestly

Local inference, hosted inference, backend connectivity, and browser connectivity are different things. I wanted the UI to make provider selection and metadata handling visible instead of hiding them behind a generic “AI is working” message.

4. Making the project reproducible

A project is more useful to the open-source community when contributors can understand the architecture, run tests, and try a safe demo without pointing it at their real files.

???? Try It Yourself

Live interface: https://slothsort-web.onrender.com/

Repository: https://github.com/Tanmay-Dalvi/slothsort

The hosted interface is deployed on Render. Because SlothSort's real file operations depend on a backend with access to the target filesystem, use the documented local setup and demo workflow for actual filesystem operations. Do not assume the public website can access files on your computer.

For a safe first test:

1. Clone the repository.
2. Follow the setup instructions in the README.
3. Configure a supported provider.
4. Use the dedicated demo folder.
5. Scan, generate a plan, review it, and approve selected operations.
6. Test undo after execution.

???? What I Want to Improve Next

There is still room to improve SlothSort:

• Better categorization for ambiguous files.
• More comprehensive collision and recovery tests.
• A polished first-run experience.
• Automated CI for pull requests.
• Better visual documentation and onboarding.
• Clearer provider-specific privacy reporting.

I'd love feedback on the workflow, safety model, and what would make this more useful for everyday file organization.

???? Contributing

SlothSort is open source, and contributions around testing, usability, documentation, and safe file operations are welcome.

Check the repository for setup and contribution guidelines:

https://github.com/Tanmay-Dalvi/slothsort

???? Final Thoughts

I wanted to build something that uses AI without turning every action into an unpredictable autonomous decision.

SlothSort is built around a simple principle:

Let AI suggest the plan. Let deterministic code enforce the rules. Let the human make the final decision.

Slow and steady — and no files moved without your approval.

If you try it, I'd appreciate your feedback!

Hacktoberfest #OpenSource #AI #Python #React #Ollama #Gemma #DevTools