DEV Community: hrishu802

I Built TidyByte to Make Document Organization Less Tedious

hrishu802 — Fri, 23 Oct 2026 21:49:41 +0000

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

What I Built

Have you ever downloaded a document, saved it with a confusing filename, and promised yourself you'd organize it later?

That small task can turn into a pile of forgotten files. I built TidyByte to make document organization less tedious, with reviewable suggestions and a one-click ZIP export.

The idea is simple: let software handle repetitive housekeeping while keeping the user in control.

TidyByte is a privacy-conscious document organizer that lets users upload TXT and PDF files, review suggested filenames and categories, edit suggestions, approve the results, and export everything into a neatly structured ZIP archive.

What it can do

Upload TXT and PDF documents in batches.
Suggest filenames, categories, and descriptions.
Review, edit, and approve suggestions before exporting.
Search and filter documents.
Export approved files into a ZIP containing category folders, original files, and a README.
Download the generated archive again when needed.
Work without an external AI API key in the current demo.

Demo

Live application: TidyByte on Vercel

Source code: TidyByte on GitHub

I tested the deployed workflow with text files and PDFs, including a PDF larger than 30 MB. I also verified that the generated ZIP archive contained valid files and the expected folder structure.

Code

TidyByte is built with React, Vite, and TypeScript.

The repository includes the source code, tests, and setup instructions:

Explore TidyByte on GitHub

How I Built It

I wanted to build something useful without creating another application that depends on a paid API or sends every document to a third-party service.

I used Antigravity as my development environment to build the application, refine the interface, troubleshoot upload and export behavior, and validate the project. I then pushed the code to GitHub and deployed the frontend using Vercel.

The current version uses deterministic, rule-based suggestions, including filename heuristics. It does not yet run an open-weight language model. The current demo focuses on delivering a working document-management workflow, while model-powered classification and descriptions remain future work.

I also paid attention to practical details, such as handling duplicate uploads, validating file sizes, preserving access to original files, and making ZIP exports easy to retrieve again.

Why Does Open Innovation Matter?

For a tool that handles personal documents, privacy should be part of the design rather than an afterthought.

Open-weight models could eventually let TidyByte analyze documents without relying on a closed AI API. Depending on the model and deployment setup, inference could run locally or through a hosted provider. Open implementations would also give developers more freedom to change models, inspect behavior, and avoid being locked into a single provider.

Cost matters too. I want to explore an approach that remains usable without per-request inference fees, rather than building a feature that becomes expensive as usage grows.

For now, I have deliberately kept the demo independent of an AI service. My next step is to integrate a suitable open-weight model through a provider or deployment option that fits a strict ₹0 inference budget, while being transparent about any data sent to a hosted service.

Open innovation matters because it gives developers the freedom to experiment, adapt tools to real needs, and make thoughtful choices about cost and privacy.

My Agent Session

I used Antigravity to develop and refine TidyByte, test its functionality, and work through implementation issues.

I haven't attached a DevRelay session link. You can explore the implementation and project setup through the public GitHub repository.

What's Next?

My next goals are to integrate an open-weight model for more useful document classification and descriptions, improve handling of scanned PDFs, and keep the review-and-approve workflow under the user's control.

TidyByte is a small step toward making everyday digital housekeeping less tedious—one document at a time.

I Built AlgoBuddy: An Open-Weight AI DSA Mentor That Teaches, Not Just Solves

hrishu802 — Mon, 19 Oct 2026 05:00:47 +0000

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

What I Built

I built AlgoBuddy, a personal Data Structures and Algorithms (DSA) mentor designed to help students understand how to solve problems instead of simply copying solutions.

The idea came from a familiar frustration: getting stuck on a DSA problem, looking at the solution, understanding it for a moment, and then getting stuck again on the next problem.

I wanted to build something that encourages learners to think independently.

AlgoBuddy follows one simple philosophy:

Think first. Hint second. Solution last.

It offers three learning modes:

Problem Mode: Work through a DSA problem step by step, from understanding the constraints to exploring an approach.
Concept Mode: Learn concepts and understand the reasoning behind them.
Code Mode: Discuss code, review approaches, and understand mistakes instead of blindly accepting corrected code.

Demo

🚀 Live Demo: https://algo-buddy-gamma.vercel.app/

💻 GitHub Repository: https://github.com/hrishu802/AlgoBuddy

You can explore the application and try its different learning modes.

Code

AlgoBuddy is open source, and the source code is available on GitHub:

https://github.com/hrishu802/AlgoBuddy

The project uses React, TypeScript, and Vite for the frontend, with a server-side API layer for AI inference.

The AI provider is configurable, allowing the application to work with hosted inference rather than requiring every user to run a large language model locally.

How I Built It

I built AlgoBuddy using React, TypeScript, Vite, and a server-side API architecture.

One important part was designing an AI service abstraction so that the learning experience would not be tightly coupled to a single model provider.

For hosted inference, I integrated OpenAI's open-weight GPT-OSS-20B model through Groq Cloud. I also preserved Hugging Face support and a deterministic mock provider for development and fallback scenarios.

The integration keeps API credentials on the server instead of exposing them in the frontend bundle.

I also worked on error handling, persistent settings, testing, and deployment so the project could run as a real web application rather than just a local prototype.

Why Does Open Innovation Matter?

Open innovation makes powerful AI models more accessible to independent developers and students.

I wanted to experiment with an AI-powered learning tool without needing to train a model from scratch or operate expensive GPU infrastructure.

Using an open-weight model through a hosted inference provider made it possible to focus on what matters most for AlgoBuddy: the learning experience, the interaction design, and the teaching approach.

It also gave me the flexibility to experiment with different providers without rebuilding the entire application.

For me, open source is not just about publishing code. It is about giving other developers something they can inspect, learn from, adapt, and improve.

My Agent Session

I used an AI-assisted development workflow to build and improve AlgoBuddy, from working on the AI integration to testing and deployment.

Rather than treating AI as a one-shot code generator, I used an iterative process:

Inspect the existing code and architecture.
Implement changes while preserving the application's learning philosophy.
Run TypeScript checks, tests, linting, and production builds.
Investigate integration failures and fix their underlying causes.
Verify the deployed application with real HTTP requests.

One lesson I learned was that a successful build does not necessarily mean a working application. My Groq integration initially encountered deprecated model IDs, so I updated the model configuration, added migration handling for saved settings, and verified that live inference worked in production.

That process reinforced the importance of testing the entire path from the frontend to the actual AI provider.

Challenges and What I Learned

The biggest challenge was not simply connecting an AI model. It was making the integration reliable without losing the original purpose of the project.

I learned the importance of separating the AI service from the user experience, keeping credentials server-side, handling provider errors clearly, and testing changes before deploying them.

I also learned that an AI learning tool should not optimize only for giving the fastest answer. It should help the learner understand why an approach works.

What's Next?

I want to keep improving AlgoBuddy's teaching quality, make its hints more adaptive, and help learners build stronger problem-solving habits over time.

I'd also love feedback from students and developers who use AI tools to learn DSA.

If you try AlgoBuddy, I'd love to know: would you prefer an AI mentor that gives you the answer immediately, or one that helps you discover the answer yourself?

Thanks for checking out my project! ❤️

I Built Sproutly for My Mom, Who Loves Gardening 🌱

hrishu802 — Mon, 12 Oct 2026 03:03:16 +0000

My mom loves gardening. She spends time taking care of her plants, but keeping a garden healthy means dealing with many questions:

Why are the leaves turning yellow?
What should I look for when checking for pests?
How often should I water a particular plant?
What care does a plant need as the seasons change?

I wanted to build something that makes finding answers easier and lets her spend more time caring for her garden.

So I built Sproutly — Your AI Gardening Companion.

The idea is simple: use AI to make gardening guidance more accessible, practical, and personal.

🌿 What I Built

Sproutly is a gardening companion designed to bring several plant-care activities together in one place.

The application includes a collection of gardening features, including:

Garden Coach: Ask questions about watering, pruning, pest control, and seasonal plant care.
My Garden: Keep your garden and connected plants organised.
Plant Doctor: A dedicated place for plant-health questions and diagnosis workflows.
Missions: Turn gardening into manageable activities.
Journal: Keep track of your gardening journey.
Regional context: The interface is configured for North India (Subtropical), making regional context part of the experience.

Rather than building another generic chatbot, I wanted Sproutly to feel like a companion for someone who already enjoys gardening and wants help making better decisions.

🚀 Live Demo

Try Sproutly:

Open Sproutly

The frontend is deployed on Vercel, and the backend is hosted on Render.

Note: The live application is deployed, but AI-generated responses are temporarily unavailable because the current inference provider has exhausted its credits. The AI integration is implemented, and I am exploring sustainable alternatives for hosting inference.

💻 Source Code

The project is open source:

View Sproutly on GitHub

I built the application using:

React
TypeScript
Vite
Tailwind CSS
Express
Hugging Face Inference Providers
An open-weight Meta Llama model

The frontend and backend are deployed separately, allowing the application interface and AI services to evolve independently.

🛠️ How I Built It

I wanted to build more than a simple question-and-answer interface. The goal was to create an application with dedicated gardening workflows.

The architecture follows a straightforward flow:

User
  ↓
React + TypeScript Frontend
  ↓
Express Backend on Render
  ↓
AI Inference Provider
  ↓
Gardening Guidance

The frontend handles the user experience, while the backend manages API requests and communication with the AI inference service.

Keeping AI requests on the server also means the inference API key does not need to be exposed in the browser.

One of the practical lessons from deployment was that getting an AI application working locally is only part of the job. Production routing, CORS configuration, environment variables, provider limits, and error handling all matter.

During deployment, I had to troubleshoot a CORS preflight failure between Vercel and Render. After correcting the production configuration, requests reached the AI endpoint successfully. I then discovered that the inference provider had run out of credits.

That was a useful reminder: a successful deployment does not automatically mean every external service is available.

🌍 Why Open Innovation Matters

For Sproutly, open-weight AI offers the flexibility to experiment with different models and inference providers instead of tying the entire application to a single model service.

That flexibility matters for a personal project because hosting costs and usage limits can affect whether an application remains usable over time.

It also creates room to explore different approaches in the future, including alternative hosted providers and potentially local inference.

My goal is not to use AI simply because it is available. I want it to make gardening guidance more useful and accessible.

🌱 Building for Someone Real

The most important part of this project is the person who inspired it.

Building for my mom gave me a concrete user to think about. Instead of starting with a long list of AI features, I could start with a real interest and ask what might make that experience easier.

Gardening is something people do away from their screens. Ideally, an app like Sproutly should help someone find the information they need and then get back outside to care for their plants.

That is the experience I want to keep working toward.

📚 What I Learned

This project taught me a few important lessons:

Build around a real need. A personal motivation gives the project a clearer purpose.
Deployment is part of development. Frontend and backend integrations need to be tested in production, not just locally.
AI reliability matters. Choosing a model is only one part of building a dependable AI-powered application.
Design for the person using it. Gardening knowledge should be easy to access without making the user navigate an unnecessarily complicated interface.

🔮 What's Next?

I want to continue improving Sproutly with a focus on:

More reliable AI inference
Better plant-health guidance
More useful seasonal recommendations for regional gardens
Improved garden tracking and progress history
A smoother experience for everyday gardening tasks

The long-term goal is simple:

Spend less time wondering what your plants need, and more time helping them grow. 🌱

🔗 Links

Live Demo: https://sproutly-zeta.vercel.app
GitHub Repository: https://github.com/hrishu802/Sproutly

Sproutly started with a simple idea: build something useful for someone I care about. I am excited to keep improving it and see how far the idea can grow.

I Built AlgoBuddy for a Friend Who Was Tired of Getting Stuck on DSA Problems

hrishu802 — Mon, 05 Oct 2026 05:56:18 +0000

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

What I Built

A friend of mine regularly practices DSA and kept running into the same problem:

"I often get stuck deciding which DSA topic to study next and spend too much time searching for the right problems. I also struggle to understand why my solution is wrong when practising."

The problem wasn't a lack of solutions. There are already plenty of platforms that can give you the answer.

The problem was getting unstuck without immediately being handed the answer.

So I built AlgoBuddy — Your DSA Problem-Solving Mentor.

The core idea is simple:

Think first. Hint second. Solution last.

Instead of acting like another answer generator, AlgoBuddy is designed to behave more like a mentor.

It currently has three main modes:

Problem Mode

Paste a DSA problem and work through it step by step.

AlgoBuddy guides the learner through:

Understanding the constraints
Thinking about a brute-force approach
Identifying the underlying pattern
Progressive hints
Optimized approach
Time and space complexity
Full solution only when the learner asks for it

The hints become progressively stronger:

Nudge → Hint → Strong Hint → Explain → Show Solution

The goal is to help the learner discover the solution rather than simply copy it.

Concept Mode

Concept Mode is designed for DSA revision.

Instead of only defining a topic, AlgoBuddy focuses on:

What the concept means
When to recognize it
Common patterns
Complexity
Common mistakes
Practice questions

Code Mode

Paste your own code and ask AlgoBuddy to mentor you through it.

It can help identify:

Correctness issues
Time complexity
Space complexity
Bottlenecks
Optimisation opportunities

Again, the mentor tries to guide the learner before revealing a complete solution.

Demo

Try AlgoBuddy here:

https://algo-buddy-gamma.vercel.app

The deployed version uses real AI-powered mentoring with Google Gemma 3 12B Instruct.

AlgoBuddy's landing page — a focused DSA mentor built around three modes: Problem Solving, Concept Learning, and Code Optimisation.

Problem Mode in action — Gemma guides the learner through the problem instead of immediately revealing the solution.

Concept Mode — structured DSA revision with recognition triggers, patterns, complexity, common traps, and mentor guidance.

Code

The complete project is open source:

https://github.com/hrishu802/AlgoBuddy

The project is built with:

React
Vite
TypeScript
Tailwind CSS
Vercel
Hugging Face Inference Providers
Google Gemma 3 12B Instruct

The AI integration is kept behind a server-side /api/gemma endpoint so the Hugging Face token is never exposed to the browser.

How I Built It

The core AI model powering AlgoBuddy is Google Gemma 3 12B Instruct, an open-weight model served through Hugging Face Inference Providers.

The architecture is intentionally simple:

User
  ↓
React + TypeScript Frontend
  ↓
Vercel /api/gemma
  ↓
Hugging Face Inference Providers
  ↓
Google Gemma 3 12B Instruct
  ↓
Mentor Response

The interesting part isn't just connecting a model to a chat interface.

I wanted the AI to follow a specific teaching philosophy.

AlgoBuddy uses a dedicated pedagogical system prompt built around:

Think first. Hint second. Solution last.

Instead of immediately giving the learner a solution, the mentor is designed to ask questions, explore the constraints, and provide progressively stronger hints.

For example, when a learner says:

"I don't know how to solve this. Don't give me the solution yet."

The mentor starts by asking about the constraints and how the learner might approach the problem manually.

This makes the interaction feel more like tutoring than a traditional chatbot.

I also kept the AI layer modular, so the model or inference provider can be changed without rebuilding the entire application.

For this project, I chose hosted Gemma inference rather than local inference so I could deploy the complete experience quickly.

Why Does Open Innovation Matter?

Open-weight AI makes it possible to build applications where the model and the experience around it can be customized rather than treating a closed API as a black box.

For AlgoBuddy, that matters because the goal isn't simply to generate an answer.

It's to control how the AI teaches.

The pedagogical system, progressive hinting, problem flow, and learning experience are all designed specifically for DSA education.

Using an open-weight model also gives the project room to evolve:

Different Gemma models can be tested
Inference providers can be changed
Local inference can be explored
The mentoring behavior can be further customized
The experience can eventually become more personalized

For this version, Gemma 3 12B Instruct provides the conversational capability needed for the mentoring experience while keeping the project centered around an open-weight model.

Building for a Real Friend

After building the first version, I gave it to the friend I originally built it for.

Their feedback was especially useful because it wasn't just about whether the app worked.

They said:

"The interface feels simple and focused on learning. I liked having guidance instead of jumping between multiple websites."

They also found the structured learning experience useful:

"The structured recommendations and explanations helped me understand concepts faster. The topic-wise organisation made it easier to track progress."

But they also pointed out something I hadn't focused on enough:

"Some buttons/features weren't immediately obvious. I wasn't always sure what to do next after finishing a problem. More onboarding would help."

That is now one of the clearest areas I want to improve.

They also requested:

Personalised study plans
Company-wise problem lists
Mock interview mode
Contest reminders
Better personalised recommendations
Continued progress tracking

Most importantly, they said:

"Yes, especially if it consistently recommends the right problems and tracks my progress. I would use it alongside LeetCode rather than as a complete replacement."

That last point is important to me.

AlgoBuddy isn't trying to replace platforms like LeetCode.

It's meant to sit alongside them as the mentor that helps you understand what you're doing and why you're doing it.

What I Learned

The biggest lesson from this project was that building for one person changes how you make product decisions.

Instead of asking:

"What features can I add?"

I started asking:

"What would actually help my friend get unstuck?"

That led me away from building another giant DSA platform and toward a smaller, more focused experience.

I also learned that adding AI to an application isn't enough.

The interesting engineering challenge is designing the interaction around the model.

For AlgoBuddy, that meant deciding:

When should the AI ask a question?
When should it provide a hint?
How strong should that hint be?
When should it explain a concept?
When should it finally show the solution?

Those decisions are what turn a general-purpose model into a more focused learning tool.

Prize Category

Best Use of Gemma

I'm entering Best Use of Gemma because Google Gemma 3 12B Instruct is the core model powering AlgoBuddy's mentoring experience.

Rather than using Gemma as a generic chatbot, I built a teaching workflow around it that prioritises guided problem-solving over immediately generating solutions.

What's Next

The next version of AlgoBuddy would focus heavily on personalisation.

Some of the ideas from my friend's feedback include:

Personalised DSA study plans
Smarter problem recommendations
Company-wise problem sets
Mock interview mode
Contest reminders
Better onboarding
More detailed learning analytics

The goal remains the same:

Don't just get the answer. Learn how to find it.

Links

Live Demo:

https://algo-buddy-gamma.vercel.app

GitHub:

https://github.com/hrishu802/AlgoBuddy

Thanks for checking out AlgoBuddy!