DEV Community: ChikkalaSukrutiNaidu

SlothTask AI: Slow Down, Let Open-Weight AI Organize Your Tasks 🦥

ChikkalaSukrutiNaidu — Wed, 21 Oct 2026 04:16:30 +0000

Have you ever had so many tasks in your head that you didn't know where to start?

Assignments, reminders, deadlines, emails, and personal tasks can quickly become overwhelming. Sometimes, the hardest part of being productive isn't completing a task—it's figuring out what to do first.

That inspired me to build SlothTask AI, a simple AI-powered productivity assistant that turns messy notes into a clear, prioritized task plan.

This project is my contribution to the open-source AI spirit of Hacktoberfest 2026.

💡 The Problem

We often write down tasks in a hurry:

Finish the DBMS assignment tomorrow

Study SQL joins

Reply to the placement coordinator

Prepare for an upcoming interview

Start a project, but don't know where to begin

These notes capture what we need to do, but they don't always help us decide where to start.

I wanted to build a lightweight tool that could take these unstructured notes and turn them into something more actionable.

🦥 Introducing SlothTask AI

SlothTask AI is a productivity assistant built with Python and Streamlit. Users enter their tasks or reminders, and the AI organizes them into a practical plan.

The generated plan includes:

Quick summary: A short overview of the notes.

Prioritized tasks: Tasks arranged by urgency and importance.

Suggested time estimates: Approximate durations where reasonable.

Do this first: A suggested starting point.

Needs clarification: Details that are unclear or need confirmation.

Users can also download their generated plan as a text file.

The goal isn't to make people work faster all the time. It's to help them spend less energy organizing their thoughts and more energy taking the next step.

🛠️ Tech Stack

I built the application using:

Python for the application logic.

Streamlit for the user interface.

Groq API for hosted model inference.

openai/gpt-oss-20b as the open-weight language model.

python-dotenv for loading local environment variables.

I chose a simple stack so I could focus on the core experience: taking unstructured notes and turning them into a useful task plan.

🤖 Why Open-Weight AI Matters

One of the interesting parts of this project was working with an open-weight model.

Open-weight models give developers access to model weights under their respective licenses, making it possible to explore, build, and adapt AI-powered applications with greater flexibility.

This matters because AI innovation shouldn't be limited to large companies with massive infrastructure. Students, independent developers, and open-source contributors should also be able to experiment with AI and build tools that solve everyday problems.

For this project, I used openai/gpt-oss-20b through the Groq API. The model is open-weight, while the inference service is hosted by Groq. This means SlothTask AI is not a fully offline application, and its AI processing depends on the external API.

That distinction is important when discussing openness and transparency in AI.

🔐 A Small but Important Lesson: API Key Security

During development, I learned that protecting API keys is just as important as getting the application to work.

I used a local .env file for my Groq API key and added .env to .gitignore so it wouldn't be included in normal Git tracking.

I also created an .env.example file containing only a placeholder, so other developers can understand which environment variable they need without receiving my secret.

When publishing software that calls an external API, credentials should never be hardcoded into the source code or committed to a public repository.

🧪 What I Learned

Building SlothTask AI helped me practice several parts of application development:

Connecting a Python application to an AI inference API.

Designing a simple interface with Streamlit.

Writing prompts that produce structured and actionable responses.

Handling missing input and API failures.

Managing dependencies with requirements.txt.

Using Git and GitHub to publish a project.

Protecting API credentials and learning from GitHub push protection.

The GitHub push-protection issue was a useful reminder that a placeholder file can still trigger security checks. I corrected the file and amended the original commit before pushing the project successfully.

Real development involves more than writing code. It also means debugging, protecting secrets, and learning how to recover from mistakes.

🌱 What's Next?

SlothTask AI is a starting point, not a finished productivity platform.

Future improvements could include:

Editing and checking off tasks.

Saving plans between sessions.

Adding customizable priority levels.

Supporting different output formats.

Adding automated tests for input validation and error handling.

I want to continue improving the project while keeping it simple and accessible to other developers.

🚀 Explore the Project

GitHub repository: https://github.com/ChikkalaSukrutiNaidu/SlothTask-AI

If you'd like to explore the code, try it locally, suggest improvements, or contribute, you're welcome to check out the repository.

💚 Final Thoughts

Open innovation matters because ideas become more useful when people can inspect them, learn from them, adapt them, and build on top of them.

SlothTask AI is a small project, but building it helped me understand how an open-weight model can become part of a practical application—and how much there is to learn by building and sharing.

Sometimes, progress doesn't start with doing everything.

Sometimes, it starts with making the next step clearer.

Slow down. Organize your thoughts. Take one step at a time. 🦥

Hacktoberfest #OpenSource #AI #Python #Streamlit

FreelanceFlow AI

ChikkalaSukrutiNaidu — Wed, 14 Oct 2026 13:28:25 +0000

FreelanceFlow AI: Building an AI-Powered Financial Assistant for Freelancers

Freelancers do more than their core work. They also need to organize invoices, categorize expenses, follow up on payments, and understand their monthly finances.

For my Hacktoberfest 2026 project, I built FreelanceFlow AI, an AI-powered financial workspace designed to make these everyday tasks easier.

🚀 What is FreelanceFlow AI?

FreelanceFlow AI is a Python and Streamlit application that brings four financial tools together in one place.

📄 1. Invoice Organizer

Freelancers can paste unstructured invoice notes or billing details and turn them into a structured invoice summary. The tool organizes client information, service items, payment terms, and totals while identifying missing details.

🏷️ 2. Expense Categorizer

The expense categorizer helps organize rough expense logs and receipt details into useful financial categories. Tax-related information needs to be checked against the user's jurisdiction and circumstances.

⏰ 3. Payment Reminder Generator

Following up on unpaid invoices can be uncomfortable. This feature helps generate polite, professional reminders based on invoice timing, including upcoming payments, payments due today, and overdue invoices.

📊 4. Monthly Summary and Financial Insights

This feature summarizes revenue, expenses, net profit, estimated tax reserves, and cash flow to help users understand their financial position.

🛠️ Technology Stack

Python — application logic and calculations
Streamlit — interactive web interface
Groq API — AI inference
Open-weight language model — understanding financial notes and generating responses
Unit tests — testing important application behavior

🔍 What I Focused On

Building an AI application is not just about generating text. It is also about making outputs useful and handling missing information carefully.

During development, I focused on:

Structuring invoice details without inventing missing information
Verifying invoice calculations
Making payment reminders depend on invoice timing
Calculating financial metrics from user-provided figures
Avoiding definitive tax claims when the jurisdiction is unknown
Adding tests for important application behavior

These improvements helped me think more carefully about validation, reliability, and responsible AI use in financial workflows.

💻 Explore the Project

GitHub repository:

https://github.com/ChikkalaSukrutiNaidu/FreelanceFlow-AI

The repository contains the source code and setup instructions for running the application locally.

🌱 What I Learned

Building FreelanceFlow AI gave me practical experience combining Python, Streamlit, and an AI API into a single application. I also learned why deterministic calculations, input validation, missing-data handling, and unit tests are important when working with financial information.

This project is intended to help with financial organization, not to replace professional accounting or tax advice.

I'm excited to keep improving it and learn from feedback. If you have suggestions for features that would help freelancers manage their finances, I'd love to hear them in the comments!

Hacktoberfest #Python #AI #WebDev

🌿 NatureQuest AI: An Open-Weight AI Coach That Gets You Outside

ChikkalaSukrutiNaidu — Fri, 09 Oct 2026 13:34:28 +0000

What if AI didn't try to keep you on your screen—but encouraged you to put your phone away and explore the real world?

That's the idea behind NatureQuest AI, my project for the Hacktoberfest 2026 Open-Source AI Challenge: Touch Grass.

🌱 What I Built

NatureQuest AI is an AI-powered outdoor mission coach that turns a few simple preferences into a short, personalized outdoor quest.

Users choose:

⏱️ How much time they have
🌳 Their environment, such as a park, garden, or campus
💭 Their mood
⚡ Their energy level
🎯 Their preferred difficulty

The AI generates one outdoor mission designed around these choices. Once the user completes it, they return to describe what they actually noticed. NatureQuest AI then creates a short reflection grounded in their observations.

The goal is simple: spend less time interacting with AI and more time experiencing the world around you.

🎬 Demo

Watch NatureQuest AI in action:

The demo shows the complete experience: creating a quest, putting the phone away, completing the activity, and reflecting on real-world observations.

💻 Code

GitHub repository:
https://github.com/ChikkalaSukrutiNaidu/NatureQuest-AI

The source code is publicly available so others can explore, learn from, and build on the project.

🛠️ How I Built It

I built NatureQuest AI using:

Python — application logic and AI integration
Streamlit — interactive user interface
Groq API — access to a hosted open-weight language model
OpenAI GPT-OSS 20B — the open-weight model used to generate outdoor quests and reflections
python-dotenv — local environment-variable configuration

The application follows a simple loop:

The user shares their preferences.
The AI generates one outdoor mission.
The user puts their phone away and goes outside.
After completing the mission, the user describes their observations.
The AI creates a reflection based on the user's description.

I also designed the prompts to discourage activities requiring special equipment and to avoid inventing details in the user's reflection.

🌍 Why Does Open Innovation Matter?

Open innovation makes AI experimentation more accessible to students and independent developers like me.

Using an open-weight model through an accessible inference API allowed me to explore how generative AI can support an idea beyond a conventional chatbot. Instead of building an application designed to maximize screen time, I wanted to use AI to encourage people to step away from their devices.

The project also demonstrates how a relatively simple combination of Python, an open-weight model, and an interactive interface can become a practical experiment in human-centered AI.

I hope others can build on this idea with new quest types, accessibility improvements, additional environments, and better ways to help people reconnect with the world around them.

🌿 My Agent Session

I used AI-assisted development to help implement the application, refine prompts, and troubleshoot integration issues. I tested the quest-generation and reflection flows before recording the demo.

One important lesson was that the AI's output matters as much as its interface: quests should be safe and realistic, and reflections should stay grounded in what users actually report.

🏆 Prize Categories

This project was created for the Hacktoberfest 2026 Open-Source AI Challenge — Week 1, “Touch Grass.”

It focuses on using open-weight AI to encourage real-world outdoor experiences rather than prolonged screen interaction.

Final Thought

AI doesn't always need to give us another reason to stay online.

Sometimes, its best job is to give us a reason to step outside. 🌱

devchallenge #hf26challenge

DebugBuddy — Your AI DSA Debugging Coach

ChikkalaSukrutiNaidu — Fri, 02 Oct 2026 14:21:32 +0000

What I Built

I built DebugBuddy, a beginner-friendly AI debugging assistant designed around a common problem faced by a friend who is learning Java DSA: understanding why a solution produces the wrong answer.

While learning DSA, it is common to understand the problem but still get stuck when the code does not work as expected. DebugBuddy is designed to make that debugging process easier to understand.

The user provides:

A DSA problem
Their Java code
What they are stuck on

DebugBuddy then provides:

Problem Understanding
Hint
What's Wrong
Dry Run
Correct Approach
Time Complexity
Space Complexity
Practice Question

The goal is not just to provide an answer, but to help the learner understand why their code failed.

Demo

I recorded a short demonstration of DebugBuddy analyzing a Java DSA problem involving finding the maximum element in an array.

In the example, the code initializes max to 0, which produces the wrong result when all the array elements are negative. DebugBuddy identifies the issue, performs a dry run, and explains the corrected approach.

Demo video:

Code

The complete source code is available on GitHub:

GitHub: https://github.com/ChikkalaSukrutiNaidu/DebugBuddy

How I Built It

I built DebugBuddy using Python and Streamlit for the application interface.

For the AI component, I used the open-weight model:

Qwen/Qwen2.5-Coder-7B-Instruct

through the Hugging Face Inference API.

The application sends the DSA problem, Java code, and the student's difficulty to the model and requests a structured debugging explanation.

I designed the prompt so that DebugBuddy focuses on:

Identifying the primary bug
Using the submitted code as the basis for the explanation
Performing a faithful dry run
Avoiding invented bugs
Separating the primary bug from edge cases
Providing a corrected Java approach
Explaining time and space complexity
Giving a related practice question

The project intentionally keeps the architecture simple. It does not use Ollama, LangChain, LangGraph, FAISS, or a database.

Why Does Open Innovation Matter?

I chose an open-weight model because open models give developers more flexibility when building AI applications.

With an open-weight model such as Qwen2.5-Coder, developers can experiment with the model and evaluate it for their own use cases. Open models can also provide flexibility around model choice and inference setup.

For DebugBuddy, I currently use Hugging Face hosted inference. This means students do not need a powerful local GPU just to experiment with the application.

At the same time, using an open-weight model gives the project a foundation that can be explored and adapted further as the project develops.

My Agent Session

I used AI assistance during development to help with implementation, debugging, documentation, and testing.

The development process included testing DebugBuddy with Java DSA examples and refining the instructions given to the model so that the generated explanations would stay focused on the submitted code.

Conclusion

DebugBuddy is my attempt to make Java DSA debugging more understandable for beginners.

Instead of simply showing the final solution, it focuses on the reasoning behind the mistake — including hints, dry runs, corrected approaches, and complexity analysis.

devchallenge #weekendchallenge #hf26challenge