DEV Community: Navya Pachigolla

SlothMode AI: Let Local AI Handle the Busywork

Navya Pachigolla — Thu, 22 Oct 2026 16:45:29 +0000

This is my submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

SlothMode AI is a local AI-powered file organizer designed to make file management less tedious.

We all have folders filled with randomly named documents, images, PDFs, and other files. Sorting them manually takes time and effort. SlothMode AI helps automate that busywork by scanning a folder, suggesting suitable categories, and organizing files with less manual effort.

🦥 The goal: Spend less time organizing files and more time doing things that matter.

Key features:

🤖 AI-powered file categorization using a locally running model.

📂 Automatic file organization into relevant folders.

👀 Dry-run mode to preview proposed changes before applying them.

↩️ Undo functionality to reverse supported file moves.

📜 History tracking to review previous organization actions.

🛡️ Collision handling to avoid overwriting existing files.

🔌 Heuristic fallback when the local AI model is unavailable.

Demo

Project: SlothMode AI

https://youtu.be/OiBlPZgK5l0

Code

GitHub Repository: https://github.com/NavyaPachigolla/SlothMode-AI

The project includes the Python source code, setup instructions, tests, and documentation.

How I Built It

I built SlothMode AI using Python, Ollama, Qwen2.5 3B, and Streamlit.

The application uses a locally running language model to suggest file categories. Python handles folder scanning, organization plans, file operations, history, and undo functionality. Streamlit provides a web interface for interacting with the project.

I also added safety features to make automation more trustworthy:

Preview changes before applying them.

Allow selective approval of proposed actions.

Track file operations and support undo.

Avoid overwriting files when name collisions occur.

Fall back to heuristic categorization if the local model is unavailable.

The project includes automated tests for important behaviors, including dry-run safety, collision handling, and undo operations.

Why Does Open Innovation Matter?

Open innovation made it possible to experiment with AI without depending entirely on a paid, closed API.

Using an open-weight model through local inference gives users more control over where their files are processed. It can also reduce dependence on external services, avoid per-request API costs, and make experimentation more accessible.

For a tool that works with personal files, local processing is especially useful because users can keep their documents on their own machines.

This project showed me how open-source AI can turn a repetitive task into a more convenient, user-controlled workflow.

My Agent Session

I used Antigravity to help develop and test the project.

If I publish a DevRelay session for this build, I will add the session link here.

The Lazy Payoff 🦥

SlothMode AI aims to reduce the repetitive effort involved in manually sorting files.

Instead of moving every file one by one, users can preview a proposed organization plan, approve the changes they want, and review or undo supported operations when necessary.

The project includes a demo folder with sample files for testing the workflow.

Prize Categories

Add the applicable partner prize categories here after checking the challenge rules. Remove this section if you are not entering a partner category.

Built with Python and local AI, for everyone who would rather spend less time sorting files. 🦥

FreelanceFlow AI: Your Local AI-Powered Expense Assistant 💸🤖

Navya Pachigolla — Tue, 13 Oct 2026 17:23:09 +0000

FreelanceFlow AI: Your Local AI-Powered Expense Assistant 💸🤖

What I Built

Managing expenses, organizing receipts, and preparing monthly reports can take valuable time away from freelance work. That's why I built FreelanceFlow AI, a local AI expense assistant designed to help freelancers organize their expenses with less manual effort.

FreelanceFlow AI combines open-weight AI with expense tracking and receipt processing to make financial record-keeping simpler.

✨ Key Features

🧾 Receipt Scanning: Extract text from receipt images using OCR.
🤖 AI-Powered Extraction: Turn natural-language expense descriptions into structured expense details using a locally running AI model.
💰 Expense Management: Add, view, edit, delete, search, and filter expenses.
📊 Smart Reports: View spending summaries, monthly trends, and category breakdowns.
📁 CSV Export: Export expense records for further analysis.
🔒 Local Processing: Uses Ollama and a local AI model, helping keep expense data on your device rather than sending it to a cloud AI API.

The goal is simple: less paperwork, more time for paid work.

Demo

🎥 Watch the project demo: https://youtu.be/Cm4OhnaB_2A

Code

💻 GitHub Repository: https://github.com/NavyaPachigolla/FreelanceFlow

How I Built It

I built FreelanceFlow AI using:

Python and Flask for the backend.
HTML, CSS, and JavaScript for the user interface.
SQLite for storing expense records.
Ollama with Qwen2.5 3B for local AI-powered expense extraction.
Tesseract OCR for extracting text from receipt images.
Pytest for automated testing.

The application combines traditional software logic with local AI. Python and SQLite handle expense storage and numerical calculations, while the AI model helps interpret natural-language descriptions and organize extracted information.

An important design decision was to keep a manual expense-entry option available. AI-generated details should be reviewed before saving because OCR and language models can make mistakes.

Why Does Open Innovation Matter?

Open innovation makes powerful AI technologies more accessible to developers, students, freelancers, and small businesses.

By building with an open-weight model and local tools, I explored how useful AI features can be developed without depending entirely on paid cloud AI services.

This project also helped me understand how AI integration, backend development, database operations, OCR, and testing work together in a practical application.

I believe open-source technology gives developers the freedom to experiment, learn, customize, and build solutions for real-world problems.

My Agent Session

I used Antigravity as a coding assistant to help scaffold the application, create its services and interface, and prepare automated tests and documentation.

I then worked through the generated project and tested the local AI and receipt-processing workflow.

My First User

My target users are freelancers who want a simple way to organize business expenses and receipts.

The next step is to collect feedback from a real freelancer and use it to improve the application. I would especially like to learn which expense-management tasks take the most time and which features provide the most value.

Prize Categories

FreelanceFlow AI is my contribution to the Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle.

It explores how open-weight AI can power a practical tool that could become useful to freelancers and independent professionals.

Built with curiosity, open-source tools, and a focus on solving everyday problems! 🚀

devchallenges #hf26challenge

TouchGrass AI — Let AI Plan It, You Go Outside

Navya Pachigolla — Thu, 08 Oct 2026 16:36:58 +0000

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

What I Built

I built TouchGrass AI, a local AI-powered outdoor activity planner.

The idea is simple:

Let AI plan it. You go outside. 🌱

TouchGrass AI helps people turn their free time into simple outdoor activities instead of spending more time on their screens.

Users can enter their:

Activity type
Available time
Energy level
Environment
Solo or group preference
Personal interests
Optional location or context

The AI then generates a personalized outdoor mission.

For example, a user can enter:

Activity: Walking
Time: 30 minutes
Energy: Medium
Environment: College campus
Interest: Nature

The application can generate a mission such as:

30-Minute Campus Nature Hunt

Walk for 5 minutes without checking your phone.
Find three different types of leaves.
Sit quietly and observe your surroundings.
Listen for different natural sounds.
Find something interesting in nature.
Take a different route back to your starting point.

The goal is to make the screen the shortest part of the experience.

Generate the mission → Put the phone away → Go outside. 🌱

GitHub Repository

https://github.com/NavyaPachigolla/TouchGrass-AI

Demo

https://youtu.be/uEIksufzbt0

If the project is currently running locally, you can write:

The project currently runs locally using Flask and Ollama. A demo video/screenshot can be added here.

The basic flow is:

Enter preferences → Generate outdoor mission → Start mission → Put the phone away → Go outside

Code

The complete source code is available on GitHub:

GitHub Repository:

https://github.com/NavyaPachigolla/TouchGrass-AI

The project contains:

Flask backend
HTML frontend
CSS styling
JavaScript functionality
Ollama local AI integration
Outdoor mission generation
Mission countdown timer

How I Built It

I built TouchGrass AI using a simple web stack:

Python
Flask
HTML
CSS
JavaScript
Ollama
Qwen2.5 3B Instruct

The backend receives the user's preferences and creates a prompt for the local AI model.

The local model then generates a personalized outdoor mission.

The generated mission contains:

Mission title
Description
Duration
Difficulty
Outdoor steps
What to bring
Safety guidance
Screen-off challenge

The frontend displays the generated mission in a simple and nature-focused interface.

I also added a mission timer so that after generating the plan, the user can start the activity and reduce interaction with the screen.

The main idea behind the application is that AI should help the user leave the screen, not keep the user on the screen.

Why Does Open Innovation Matter?

Open innovation is important for this project because the purpose of TouchGrass AI is to help people spend less time looking at screens.

The project uses an open-weight AI model locally through Ollama instead of depending on a closed cloud AI API.

This provides several benefits.

1. Local AI

The AI can run locally on the user's computer.

The user's activity preferences can therefore stay on their own machine instead of automatically being sent to a remote AI service.

2. No dependency on a paid AI API

The core AI functionality does not require a paid proprietary AI API.

This makes the project easier to experiment with and run locally.

3. Freedom to experiment

Using an open-weight model allows developers to experiment with different models and approaches.

The model can potentially be replaced or customized as the project evolves.

4. Less vendor lock-in

The application is not designed around one proprietary AI provider.

This gives developers more flexibility when experimenting with local AI.

5. The AI has a specific purpose

The AI is not being used just to create another chatbot.

Its purpose is to generate a real-world activity that encourages the user to stop using the screen and experience the outdoors.

The AI creates the plan.

The real experience happens outside. 🌱

My Agent Session

I used an AI coding agent while developing TouchGrass AI.

[Add your DevRelay agent session here if you have one.]

If you don't have a DevRelay session, this section can be removed because it is optional.

Prize Categories

AI / Open-Source AI

What I Learned

While building this project, I learned how local AI can be integrated into a practical application instead of relying entirely on cloud-based AI APIs.

I also learned that AI doesn't always have to increase screen time.

It can also be used as a tool to help people step away from technology and interact with the real world.

That is the idea behind TouchGrass AI:

Use AI for a few minutes. Then go touch grass. 🌱

SpeakBuddyHF26: Your AI English Speaking Partner

Navya Pachigolla — Fri, 02 Oct 2026 17:33:37 +0000

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

What I Built

I built SpeakBuddyHF26, an AI English Speaking Partner for a friend who wants to improve their English speaking confidence without the fear of being judged for making mistakes.

SpeakBuddy creates a friendly and patient environment where users can practice realistic English conversations using their microphone.

Users can:

Choose Beginner, Intermediate, or Advanced speaking levels
Practice Daily Conversations
Practice Job Interviews
Practice College Conversations
Practice Travel situations
Practice a 60-second personal introduction
Speak naturally using their microphone
Continue an interactive conversation with the AI
Track their speaking practice and progress

The goal is to make English practice feel like talking to a supportive friend rather than attending a classroom lesson.

Demo

🎥 2-minute demo:

https://youtu.be/hR1RFzRCrZk?si=szuy9MlMgs0s4TiC

The demo shows the complete experience, including selecting a scenario, speaking with SpeakBuddy, receiving AI responses, and viewing the application.

Code

💻 GitHub Repository:

https://github.com/NavyaPachigolla/SpeakBuddy

How I Built It

SpeakBuddy is built around Llama 3 8B running locally through Ollama.

The basic flow is:

User speaks → Speech is transcribed → Llama 3 processes the conversation → AI responds → User continues the conversation

The project includes:

Llama 3 8B
Ollama
Local AI inference
Voice/microphone interaction
Real-world conversation scenarios
Multiple speaking levels
Progress tracking
Full-stack frontend and backend

Why Does Open Innovation Matter?

Open innovation is important for SpeakBuddy because the application is designed to provide a private and comfortable environment for English speaking practice.

I use Llama 3 8B through Ollama, allowing the core AI conversation experience to run locally instead of depending on a closed proprietary AI API.

This gives the project more flexibility and helps keep the user's practice experience private.

For someone practicing English, they may talk about their education, career goals, personal experiences, and everyday life. Local AI provides a useful way to practice without requiring those conversations to be sent to a third-party AI service.

My Agent Session

I used an AI-assisted development workflow to build and improve SpeakBuddyHF26.

What I Learned

Building SpeakBuddy taught me that an AI application does not need to be complicated to be useful. The most important part was designing the experience around a real person's problem.

I focused on making the conversations simple, encouraging, and practical so that the user can keep practicing without feeling judged.

Final Thoughts

SpeakBuddyHF26 was built to make English speaking practice more comfortable, private, and accessible.

Instead of worrying about making mistakes, the user can simply speak, practice, learn, and try again.

Thank you for checking out my Hacktoberfest 2026 project!