DEV Community: Nandan P Aghera

Slow and Steady: LazySort — Your Local AI File Organizer 🦥

Nandan P Aghera — Mon, 26 Oct 2026 13:11:52 +0000

This is a submission for the "Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady" (https://dev.to/challenges/hacktoberfest-week3-2026-10-19)

What I Built

Meet LazySort, a local AI-powered file organizer that takes care of the digital clutter we keep postponing.

Downloads folders are full of random PDFs, screenshots, documents, images, code files, and files with names that make absolutely no sense. Organizing everything manually is boring, so why not let AI handle it?

LazySort is designed to scan a selected folder, understand what files contain, suggest meaningful filenames, and organize them into categories such as Documents, Work, Images, Code, and Personal.

The goal is simple: spend less time managing files and more time doing things that actually matter.

Key features:

Automatically categorize files using AI.
Suggest meaningful filenames instead of confusing defaults.
Organize cluttered folders into a clean structure.
Preview proposed changes before applying them.
Keep files and sensitive information on the local machine.

The intended demo workflow is straightforward: select a messy folder, let the local AI analyze the files, review the suggested organization, and apply the changes.

Code
The project will be open source, allowing developers to inspect the implementation, customize the categorization rules, and contribute improvements.

How I Built It

LazySort is designed around open-source AI rather than depending entirely on a proprietary cloud API.

Planned technology stack:

Python: Core application logic and file operations.
Ollama: Local model execution and inference.
Qwen or another suitable open-weight model: Understanding file content and generating useful filenames and categories.
Local file system: Reading selected files and organizing them into folders.
Streamlit: A simple interface for reviewing suggested changes.

The workflow is:

The user selects a folder.
The application identifies supported file types.
Relevant text or metadata is extracted locally.
The open-weight model suggests a category and an appropriate filename.
The application presents a preview of the proposed changes.
The user approves the changes before files are moved or renamed.

The application is designed to keep the model's analysis local, with safeguards such as previewing changes and avoiding overwrites.

Why Does Open Innovation Matter?

For a tool that handles personal documents, privacy matters just as much as convenience.

A closed AI API could provide file classification, but it may require sending document contents to an external service and could introduce ongoing usage costs.

An open-weight model running locally offers a different approach.

Privacy by design

Personal documents can contain financial information, work files, private notes, and other sensitive content. Local inference can keep document contents on the user's machine instead of sending them to a third-party AI API.

Freedom to choose the model

The project can use different compatible open-weight models depending on the available hardware, speed, and classification quality. Developers can experiment without being locked into one provider.

Reduced recurring costs

Once the software and model are downloaded, local inference can run without per-request API charges. Hardware, electricity, storage, and setup still have costs.

Offline capability

After setup and downloading the required model, the core workflow can be designed to run without an internet connection.

Customization and transparency

Developers can modify prompts, categorization rules, and application logic to suit their own workflow. They can also inspect the code and adapt the tool rather than relying entirely on a closed service.

For this use case, open innovation isn't just about using a different model. It makes a more private, customizable, and potentially cost-effective approach to everyday automation possible.

The Lazy Payoff
Imagine downloading 50 files after a week of work and having to sort each one manually.

LazySort aims to reduce that repetitive work to a quick review and approval process. Instead of opening every file, deciding where it belongs, and renaming it yourself, you let a local AI assistant prepare the organization for you.

The intended payoff is less repetitive work, a cleaner workspace, and more time for the things you would rather be doing.

Actual time savings and classification accuracy will need to be measured during testing.

Built for the lazy, powered by open innovation.

Why spend your evening organizing files when you could be relaxing like a sloth? 🦥

Hacktoberfest #OpenSourceAI #LocalAI #Ollama #Python #AI #BuildInPublic

InvoicePilot AI

Nandan P Aghera — Mon, 12 Oct 2026 21:45:37 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

InvoicePilot AI: A Private, Open-Source AI Assistant for Freelancers

What I Built

Freelancers often waste time manually organizing invoices, sorting receipts, tracking expenses, and preparing monthly financial summaries.

I’m building InvoicePilot AI, an AI-powered expense management assistant designed for freelancers, independent developers, consultants, and small businesses.

The goal is simple: upload an invoice or receipt, extract the important details, categorize the expense, and generate a clean summary without manually entering everything into a spreadsheet.

Planned features include:

Smart extraction: Extract vendor names, invoice dates, totals, and other relevant fields from receipts and invoices.
Automatic categorization: Classify expenses into categories such as software, travel, equipment, and office supplies.
Expense summaries: Generate monthly spending reports and export structured data to CSV.
Local-first AI: Process sensitive financial documents locally wherever practical.

The long-term goal is to make expense management simpler and more affordable for people who cannot justify paying for complicated accounting software.

How I Built It

InvoicePilot AI is designed around open-source tools rather than a mandatory proprietary AI API.

The planned technology stack includes:

Ollama: Run compatible open-weight language models locally.
Qwen2.5 or another compatible open-weight model: Extract structured information and categorize expenses.
PaddleOCR: Explore OCR for reading text from scanned receipts and invoice images.
Python and FastAPI: Build the backend and document-processing pipeline.
SQLite: Store expense records locally for the initial version.
React: Build a simple dashboard for uploading documents and reviewing extracted expenses.

The workflow is straightforward:

The user uploads a receipt or invoice.
OCR extracts text from the document when necessary.
The local language model identifies relevant fields and suggests an expense category.
The application validates the extracted data and lets the user correct mistakes.
The user reviews expenses and generates a monthly summary.

The initial version will prioritize reliable extraction, human review, and a working end-to-end demo before adding more advanced features.

Why Does Open Innovation Matter?

Financial documents contain information that people may not want to send to an external AI provider. At the same time, recurring API costs can make an inexpensive tool difficult to sustain.

Open innovation gives InvoicePilot AI a different starting point.

Privacy and control: Local inference can keep document contents on the user's machine instead of requiring every invoice to be sent to a third-party AI API.

Cost control: Once a compatible model is running locally, there are no per-request charges from a hosted model API. Hardware, electricity, and maintenance still have costs.

Model flexibility: The application can experiment with different open-weight models and choose the best balance between extraction accuracy, speed, and hardware requirements.

Transparency and customization: An open-source processing pipeline makes it easier to inspect how documents are processed, customize categories, and adapt the application to a particular type of freelancer or business.

A closed API might be easier to integrate initially, but local inference offers an important advantage for this use case: greater control over sensitive documents and recurring inference costs.

The goal is not simply to add AI to an expense tracker. It is to make useful AI accessible to people who need a practical tool without mandatory dependence on a paid AI service.

Built as part of the Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle.

WildLens AI 🌿 - An Offline Nature Explorer Powered by Open-Source AI

Nandan P Aghera — Sat, 10 Oct 2026 07:46:20 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

## What I Built
WildLens AI is an offline-first app that helps people explore nature. Users photograph plants, identify them using AI, learn interesting facts, and complete outdoor missions instead of spending time scrolling on their phones.

## Key features
Nature Scanner: Identify plants from photos using an open-weight image classification model.

Pocket Field Guide: Discover interesting facts about identified plants.

Touch Grass Missions: Complete real-world challenges, such as finding three different leaf shapes or spotting five types of flowers.

Discovery Journal: Save discoveries locally and build a personal nature collection.

Offline Mode: Run the image recognition model locally without sending photos to a cloud AI service.

The app is designed for hikers, students, nature enthusiasts, and anyone who wants to spend less time on screens and more time exploring.

## How I Built It
Built using React, Tailwind CSS, an open-weight plant image classification model, and ONNX Runtime Web for local AI inference.

## Why Does Open Innovation Matter?

Open-source AI enables offline identification, better privacy, and freedom to experiment with different models without depending on paid proprietary AI APIs.
Nature exploration is personal. Users may photograph private gardens, remote trails, or places with unreliable internet connectivity. 3.Open-source AI makes it possible to build an experience where photos stay on the user's device and identification can work without a constant internet connection.

Thank You!! :-)

BuddyBoost

Nandan P Aghera — Mon, 05 Oct 2026 06:57:45 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built BuddyBreak, a personal productivity and break-reminder assistant for a friend who tends to stay focused on work for long periods without taking proper breaks. Instead of relying only on fixed notifications, the app generates personalized suggestions such as taking a short break, stretching, drinking water, or stepping away from the screen. The goal was to turn a simple reminder into a lightweight assistant that feels more relevant to the user's current context.

How I Built It

The project was designed around an open-source AI approach, using Gemma as the language model to generate short, natural reminder messages instead of relying entirely on predefined responses. SerpAPI can be used to provide additional contextual information when relevant, while Sentry is integrated for application monitoring and error tracking. The application combines these components into a lightweight workflow where user activity triggers the reminder-generation process and the AI produces an appropriate response.

Why Does Open Innovation Matter?

Open innovation makes it possible for developers to combine open-weight AI models, open-source frameworks, APIs, and community-built tools to create useful solutions without depending entirely on a single closed platform. For BuddyBreak, this approach makes experimentation easier and gives developers more control over how AI is used. It also demonstrates how accessible AI infrastructure can help turn a small problem experienced by a friend into a working prototype.