# LazyAI: Stop Doing It Twice. Let AI Do It for You. 🤖

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.

Meet LazyAI — a local AI-powered personal automation assistant designed to take repetitive file-organization tasks off your hands.

We all waste time doing the same things repeatedly: organizing files, deciding where they belong, checking for duplicate filenames, and cleaning up messy folders. LazyAI aims to make those tasks easier without giving an AI unrestricted access to your computer.

The main idea: AI should handle the planning, but you should remain in control of the execution.

LazyAI is built around a simple principle: automate the repetitive work, not the user's judgment.

demo video link: https://drive.google.com/file/d/1NHdqgQuWkUxGgAMWGLt7hESjuVnqG9Pc/view?usp=sharing

LazyAI currently runs locally on your machine.

The frontend provides a dashboard, File Organizer, Workflow Library, Activity Logs, and Settings.

To try it locally, you'll need Python, Node.js, and Ollama installed, along with a downloaded model.

cd backend python -m pip install -r requirements.txt python run.py Enter fullscreen mode Exit fullscreen mode Start the frontend in another terminal:

cd frontend npm install npm run dev Enter fullscreen mode Exit fullscreen mode Open the frontend at http://localhost:5173.

The backend API documentation is available at http://127.0.0.1:8000/docs.

Before testing file operations, use a disposable test folder rather than important personal files. The application is designed to preview changes and require approval, but testing in a sandbox is still the sensible approach.

A hosted demo or recorded walkthrough can be added here when available.

🚀 GitHub Repository: https://github.com/naveensri4518/LazyAi-Hack4week

The repository contains the frontend, backend, API routes, filesystem handling, execution and rollback logic, tests, and project documentation.

Feel free to explore the code, report issues, and suggest improvements!

I built LazyAI using a modern frontend, a lightweight Python backend, and local AI inference.

LazyAI separates AI-generated planning from actual filesystem operations.

The backend also implements staged plans, expiration, replay protection, collision handling, and safeguards against rolling back files that have changed since execution.

I deliberately avoided letting the AI generate arbitrary shell commands or directly modify the filesystem. The AI proposes a plan; deterministic backend code validates and executes the approved operations.

During final integration, the backend test suite reported 45 passing tests and zero failures. The frontend production build also completed successfully.

I additionally verified the main workflow, including scanning, planning, previewing, approval, execution, audit logging, rollback, and workflow reuse.

For a project that changes files on someone's computer, safety and predictable behavior matter just as much as the AI itself.

For LazyAI, open innovation makes local AI experimentation possible without making every operation dependent on a closed, cloud-hosted AI API.

Using Ollama with an open-weight model lets users run inference on their own machines after installing the required dependencies and downloading the model.

Open-weight models are not automatically equivalent to unrestricted open-source software; their licenses still matter. For example, Llama 3.2 is distributed under Meta's Llama Community License Agreement.

The broader lesson is that AI automation doesn't always need a remote service. With the right architecture, useful AI features can run locally while keeping important decisions under user control.

LazyAI is designed to reduce the repetitive effort involved in organizing files and reviewing proposed changes.

Instead of manually deciding where each file belongs and performing every operation individually, users can review a proposed plan and approve the supported changes as a batch.

I haven't established a reliable real-world time-saving measurement yet, so I won't claim a specific number of minutes saved. The current milestone is a working, tested local workflow with preview, approval, execution, audit logging, and rollback.

The next step is to measure how much time it saves on realistic folders and improve the planning accuracy based on those results.

Slow and steady means building automation that people can trust—not simply making it faster.

Some limitations remain. LazyAI currently reasons primarily from file metadata rather than reading document contents, and rollback refuses to proceed when a destination has been modified in a way that makes restoration unsafe.

Future improvements could include better file classification, more workflow templates, additional model support, and broader testing across operating systems.

For now, I'm happy to have taken LazyAI from a dashboard concept to a tested application with a safety-conscious execution workflow.

Thanks for checking out my project! If you have ideas, feedback, or suggestions, I'd love to hear them in the comments. 🚀