DEV Community: abhimanyu sharma

SlothDesk AI: Let Open-Source AI Handle the Busywork | Hacktoberfest 2026

abhimanyu sharma — Tue, 20 Oct 2026 22:34:40 +0000

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

What I Built

I built SlothDesk AI, a lightweight, local-first productivity assistant designed to help people spend less time organizing work and more time doing what matters.

We all have days when our to-do lists feel endless, our notes are messy, and even deciding where to start takes too much energy. SlothDesk AI helps make those days a little easier.

It includes four productivity tools:

Lazy Task Organizer: Turns messy task lists into manageable priorities.
Note Summarizer: Converts long notes into concise summaries and key points.
Low-Energy Mode: Creates a gentle plan for days when time or motivation is limited.
Make It Simpler: Breaks overwhelming tasks into small, actionable steps.

The idea is simple: let AI handle some of the planning overhead so we can focus on taking the next small step.

My goal was to create a beginner-friendly productivity tool that is simple to run, easy to customize, and designed around local AI rather than a paid proprietary API.

Demo

GitHub Repository: SlothDesk AI — Let AI Handle the Busywork

The project includes a responsive web interface built with HTML, CSS, and JavaScript.

You can explore the interface in demo mode. To use actual AI-powered responses, install Ollama and run a compatible open-weight model locally.

Code

Check out the complete source code:

View SlothDesk AI on GitHub

The project uses a simple structure:

index.html — Complete interface, styling, and JavaScript.
README.md — Setup instructions, features, and project documentation.
LICENSE — MIT License.

The frontend uses vanilla JavaScript, and the AI integration communicates with Ollama's local HTTP API.

How I Built It

I built SlothDesk AI using HTML, CSS, and vanilla JavaScript to keep the project lightweight and approachable for contributors.

For local AI, the project integrates with Ollama and supports an open-weight model such as Llama 3.2.

The workflow is straightforward:

The user enters tasks, notes, or a problem they want to simplify.
SlothDesk prepares a prompt based on the selected productivity tool.
The prompt is sent to the locally running Ollama model.
The model generates a summary, prioritized task list, or manageable action plan.
If local AI is unavailable, the interface provides a basic JavaScript-powered demo fallback.

To try the local AI integration, install Ollama and run:

ollama pull llama3.2

Then start Ollama and open the website. Depending on how the page is served, browser cross-origin settings may need to be configured for the local Ollama endpoint.

The important part is that the AI integration is designed around local inference rather than requiring a paid hosted AI API.

Why Does Open Innovation Matter?

For me, open innovation means giving people more control over the tools they use and the data they share.

SlothDesk AI explores three important benefits of open-source AI:

1. Privacy and control

When configured for local inference, prompts are processed by a model running on the user's computer instead of being sent to a third-party hosted AI API. This can be especially useful when organizing personal notes or work-related tasks.

2. Freedom to experiment

Users can change the prompts, experiment with compatible models, and customize the assistant's behavior. The project is not tied to a single proprietary AI provider.

3. Lower barriers to experimentation

There is no paid AI API key required for the local Ollama workflow. Users can experiment without usage-based API charges, although running a model still requires hardware, electricity, and storage.

A closed API might offer a convenient setup, but local inference gives users greater control over where their prompts are processed and how their AI workflow is configured.

That is why open innovation fits this project: the AI is not just an extra feature. The ability to run and customize the model locally is central to the idea.

My Agent Session

I used AI-assisted development to help plan and build the project.

I haven't attached a DevRelay agent session yet. If I save a session using DevRelay, I'll add the session link here so others can explore the development process.

The Lazy Payoff

SlothDesk AI is designed to reduce the small decisions that make everyday work feel harder than it needs to be.

Instead of manually sorting a long task list, users can generate a prioritized plan. Instead of rereading lengthy notes, they can create a concise summary. Instead of staring at an intimidating task, they can start with one manageable action.

I haven't measured real-world time savings yet, so I won't claim a specific number of minutes saved. The next step is to test it with real users and measure how much time the tools save in practice.

The principle behind the project is straightforward:

You don't always need to work harder. Sometimes you need to make the work smaller.

Prize Categories

My submission focuses on the open-source AI and local inference aspects of the challenge.

I'll confirm any specific partner prize categories against the official challenge page before selecting them.

Built for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

Slow down. Make the next step easier. Let open-source AI handle some of the busywork.

ReceiptPilot Local: Your Privacy-First AI Receipt & Invoice Organizer

abhimanyu sharma — Tue, 13 Oct 2026 10:12:26 +0000

ReceiptPilot Local: Your Privacy-First AI Receipt & Invoice Organizer

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

What I Built

ReceiptPilot Local is a privacy-first, AI-powered receipt and invoice organizer designed for freelancers, small business owners, students, and side hustlers.

Managing receipts and invoices manually can be time-consuming. Important details such as invoice numbers, dates, vendor names, taxes, and totals are often scattered across PDFs, images, and documents.

ReceiptPilot Local simplifies this process by using AI to extract important information from uploaded receipts and invoices and organize it into an editable table.

✨ Key Features

📄 Multiple File Formats: Upload PDF, TXT, Markdown, CSV, and image files.
🤖 AI-Powered Extraction: Extract invoice details into structured JSON using a locally running AI model.
🔒 Privacy First: Process documents locally with Ollama instead of relying on a cloud-based AI API.
✏️ Editable Results: Review and correct extracted information before exporting it.
📊 Data Export: Export organized invoice data as CSV or JSON.
🧾 Sample Receipt: Test the application using a sample receipt.

Who Would Pay for It?

Freelancers, consultants, small business owners, independent contractors, and side hustlers who want to simplify expense tracking without sending sensitive financial documents to third-party AI services.

The project could evolve into a subscription-free desktop application, a paid business tool, or a self-hosted solution for teams that prioritize data privacy.

Demo

Project: ReceiptPilot Local — AI-Powered Receipt & Invoice Organizer

The application runs locally on your computer using Streamlit and Ollama.

Sample Receipt: Upload a sample invoice to test the extraction workflow.
Live Demo: A publicly deployed demo is not available yet; the current version is designed to run locally.

Code

GitHub Repository: https://github.com/001abhimanyu/ReceiptPilot-Local.git

The project includes:

app.py — Streamlit application and AI-powered document processing.
requirements.txt — Python dependencies.
README.md — Setup instructions and project documentation.
.gitignore — Files that should not be committed to GitHub.

The application is designed to be simple to run, easy to understand, and open for community contributions.

How I Built It

I built ReceiptPilot Local using Python, Streamlit, and open-source AI tools.

Technology Stack

Python: Core application logic and document processing.
Streamlit: Interactive web interface.
Ollama: Runs the AI model locally.
Llama 3.2: The default locally configured model for structured information extraction.
PyPDF: Extracts text from PDF documents.
Tesseract OCR: Extracts text from supported receipt and invoice images.
Pandas: Organizes extracted information and supports data export.

How It Works

The user uploads a receipt or invoice.
The application extracts text from the document or uses OCR for images.
The extracted text is sent to the locally running AI model through Ollama.
The model identifies relevant fields, such as vendor name, invoice number, date, subtotal, tax, and total.
The application displays the extracted information in an editable table.
The user reviews the results and exports them as CSV or JSON.

The goal was to build something practical that combines local AI inference with a simple interface to solve a real-world problem.

Note: OCR and document extraction accuracy can vary depending on image quality and document format. Users should review extracted financial information before relying on it.

Why Does Open Innovation Matter?

Open innovation made it possible to build an AI-powered application without making a proprietary cloud AI service a mandatory dependency.

By using open-source tools and a locally running model, ReceiptPilot Local explores a different approach to handling sensitive financial documents.

Benefits of Open Innovation

Privacy and Control: Users can process documents locally without needing to upload them to a hosted AI provider.
Accessibility: Developers and learners can experiment with AI without building their applications around a paid proprietary API.
Customization: Users can experiment with different locally supported models and improve extraction prompts.
Transparency: Developers can inspect the application code, understand the workflow, and contribute improvements.
Community Collaboration: Other developers can add features such as expense categorization, duplicate detection, monthly reports, and improved OCR.

Open innovation is not just about making software free. It is about giving people the freedom to learn, adapt, improve, and build on existing technology.

ReceiptPilot Local is my attempt to demonstrate how open-source AI can make everyday financial workflows simpler while giving users greater control over their data.

My Agent Session

I built the initial application by working through the project structure, document-processing workflow, local AI integration, and export functionality.

Agent session: Add your DevRelay session link here if you recorded one. Otherwise, you can remove this optional section.

Prize Categories

Select the applicable partner categories from the official challenge page before submitting. I have not listed any categories here because eligibility should be confirmed against the challenge's official rules.

What's Next?

I would love to improve ReceiptPilot Local with community contributions, including:

Automatic expense categorization.
Monthly and yearly expense summaries.
Duplicate receipt detection.
Multi-currency support.
Better OCR for low-quality receipt images.
Export to accounting-friendly formats.
Batch processing for multiple invoices.

If you're interested in open-source AI, Python, privacy-first applications, or developer tools, contributions and feedback are welcome!

Built for the Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle.

AI Garden Buddy: Plan with AI, Grow in the Real World

abhimanyu sharma — Tue, 06 Oct 2026 19:13:12 +0000

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

What I Built

I built AI Garden Buddy, a simple web application that helps people create a personalized gardening plan.

The idea behind the project is simple: instead of using AI only to spend more time on a screen, I wanted to use AI to help people get outside.

Users can enter their location, season, sunlight conditions, garden space, experience level, and what they want to grow.

The application then creates a personalized garden plan with plant recommendations, gardening advice, and an outdoor mission.

The final step is the most important one:

Close the screen and go outside.

The project is designed for beginners, students, home gardeners, balcony gardeners, and anyone who wants to spend more time with nature.

Demo

You can try AI Garden Buddy here:

Website: https://001abhimanyu.github.io/AI-Garden-Buddy/#about

The project is completely frontend-based and can be opened directly in a web browser.

Code

The complete source code is available on GitHub:

GitHub: https://github.com/001abhimanyu/AI-Garden-Buddy

I kept the project simple so that it is easy to understand, modify, and contribute to.

How I Built It

I built the application using:

HTML
CSS
JavaScript

Browser-based storage

Open-source AI concepts

The frontend collects information about the user's garden and turns it into a personalized gardening experience.

The main workflow is:

The project is intentionally built with only HTML, CSS, and JavaScript so it can be easily hosted using GitHub Pages.

For the open-AI direction of the project, I designed the architecture around browser-based open-weight AI using technologies such as Transformers.js and an open-weight model such as Qwen2.5 1.5B.

This approach allows the AI layer to be moved toward local browser inference instead of depending on a traditional closed AI API.

Why Does Open Innovation Matter?

Open innovation gives developers more freedom to experiment with AI.

For a project like AI Garden Buddy, browser-based open AI can make it possible to build experiences where personal information does not have to be sent to a third-party AI service.

It also gives developers more control.

With open-weight models, developers can explore different models, change the application logic, experiment with local inference, and learn how the AI system works instead of treating a closed API as a black box.

Another important reason is accessibility.

A simple project built with HTML, CSS, JavaScript, and open technologies can be shared, modified, and improved by other developers.

For me, the most interesting part is that AI does not have to mean more screen time.

AI can help us decide what to do and then get out of the way.

That is the idea behind:

Plan with AI. Grow in the real world.

My Agent Session

I used AI during the development process to help with project planning, UI ideas, workflow design, code generation, and documentation.

I have not included a DevRelay agent session link in this submission.

Prize Categories

I am submitting AI Garden Buddy for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

Final Thoughts

This project started with a simple question:

What if AI could help us spend less time looking at a screen?

AI Garden Buddy is my attempt to answer that question with a small, practical project.

The app creates the plan.

The user does the real work.

Go outside. Touch grass. Grow something.

CloudPal AI: Building a Free Cloud & DevOps Learning Assistant for Hacktoberfest 2026

abhimanyu sharma — Sun, 04 Oct 2026 20:06:24 +0000

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

What I Built

I built CloudPal AI – Your Cloud & DevOps Learning Friend, a beginner-friendly educational chatbot designed to help students and aspiring cloud engineers learn Cloud Computing, AWS, Microsoft Azure, DevOps, Docker, Kubernetes, and Linux.

I created this project with learners in mind who often struggle to find a simple and interactive way to understand technical concepts and prepare for interviews.

CloudPal AI provides:

Interactive chatbot with predefined educational responses.
Cloud and DevOps learning topics.
Multiple-choice technical quizzes.
Technical interview practice.
Useful Linux, Docker, and Git commands.
A responsive and user-friendly dashboard.

The main goal is to make technical learning simple, accessible, and engaging without requiring users to create accounts, configure API keys, or install additional software.

Demo

Live Website: CloudPal AI – Your Cloud Learning Friend

Code

GitHub Repository: https://github.com/001abhimanyu/CloudPal-AI

The project is built using three simple files:

index.html – Website structure and chatbot interface.
style.css – Responsive styling and dashboard design.
script.js – Chatbot logic, predefined knowledge base, quizzes, and interview questions.

How I Built It

I built CloudPal AI using HTML5, CSS3, and vanilla JavaScript.

The current implementation uses a predefined JavaScript knowledge base and rule-based responses instead of connecting to an external AI API.

I intentionally kept the application simple:

No API tokens or secret keys.
No backend configuration.
No external frameworks or dependencies.
No software installation required.
Works directly in a web browser, including offline.

The project is designed as a starting point for an educational AI assistant. Future versions can explore integration with open-source, open-weight AI models.

Why Does Open Innovation Matter?

Open innovation makes technology more accessible by allowing developers to share ideas, collaborate, learn from one another, and improve existing projects.

For CloudPal AI, open-source development provides an opportunity for students and developers to contribute new learning topics, improve chatbot responses, add quizzes, and introduce new features.

It also makes the project easy to understand, modify, and extend without depending on expensive proprietary services.

My goal is to make CloudPal AI a community-driven learning resource that helps beginners build confidence in Cloud Computing and DevOps.

My Agent Session

Not available for this submission.

Prize Categories

This project is submitted for the Hacktoberfest Weekend Challenge: Build for a Friend.

Future Improvements

Expand the educational knowledge base.
Add more interactive quizzes and interview questions.
Introduce different learning difficulty levels.
Explore integration with open-source AI models.
Encourage community contributions.

Author: Abhimanyu Sharma

Technologies: HTML, CSS, JavaScript

Project: CloudPal AI – Your Cloud & DevOps Learning Friend