DEV Community: Saksham Sontakke

My Friend Wanted to Start Gardening, So I Built Her an AI Gardening Companion

Saksham Sontakke — Sun, 11 Oct 2026 05:56:07 +0000

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

🌱 GrowMate — Your AI Gardening Companion

What I Built

GrowMate is an AI-powered gardening companion designed to help home and balcony gardeners grow healthier plants while spending less time on screens and more time in nature.

Gardening can be challenging for beginners. People often struggle to decide which plants suit their space, understand their plants' needs, or identify potential leaf diseases. GrowMate aims to make these tasks easier through AI-powered guidance and practical outdoor activities.

The project focuses on three main features:

AI Garden Planner: Get personalized plant suggestions and gardening guidance based on your available space, sunlight, and gardening preferences.
Plant Health Scanner: Upload a leaf image to receive AI-assisted plant health classification and guidance on possible next steps.
Touch Grass Mode: Get practical gardening missions that encourage you to step away from your device, interact with your plants, and build a real-world gardening habit.

The idea behind GrowMate is simple: AI should help us experience more of the real world, not keep us trapped in front of a screen.

Instead of endlessly researching gardening online, users can get guidance, put their devices aside, and start caring for their plants.

GrowMate is built for beginners, home gardeners, balcony gardeners, and anyone who wants to develop a greener lifestyle.

Demo

Live Demo: https://growmate-beta.vercel.app/

Explore GrowMate and see how AI can support practical, real-world gardening.

Code

GitHub Repository: https://github.com/CyborgX-hash/Growmate

The project source code is available on GitHub.

How I Built It

I built GrowMate with a focus on combining a modern web application with AI-assisted gardening and practical outdoor activities.

Technology stack:

Frontend: React, Vite, and Tailwind CSS
Backend: Node.js and Express.js
Database: MySQL with Prisma ORM
AI: Open-weight language and computer-vision models for gardening assistance and plant health classification
Deployment: Vercel for the frontend, with backend and AI services configured separately as required

The planned AI components include:

Gemma 3 4B IT for generating gardening guidance, personalized plans, and outdoor missions.
PlantVillage ViT leaf-disease classifier for AI-assisted classification of uploaded plant leaf images.

The goal is to use models with accessible weights and customizable deployment options rather than building the entire experience around a proprietary, closed AI system.

Note: The model names above describe the intended AI components. Confirm which models are actually integrated and responding in the deployed version before publishing this as a description of the finished implementation.

Why Does Open Innovation Matter?

Open innovation matters because gardening assistance should be adaptable, accessible, and transparent.

Using models with accessible weights gives developers more control over how AI features are deployed and customized. It also creates opportunities to experiment with different models, choose infrastructure that fits the project's needs, and improve the application without depending entirely on one proprietary AI provider.

For GrowMate, this approach could make it easier to:

Customize gardening recommendations for different environments and growing conditions.
Replace or upgrade AI models as better options become available.
Keep API credentials and sensitive processing on the server rather than exposing secrets in the frontend.
Experiment with different inference providers and deployment approaches.
Build tools that connect AI assistance with meaningful offline activities.

Open innovation is especially relevant to the Touch Grass challenge because the AI is intended to act as a guide—not as the destination. The real outcome is a person learning about plants, stepping outdoors, and caring for something in the physical world.

My Agent Session

I used an AI-assisted development workflow to help plan and build GrowMate.

Prize Categories

Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass

Built with 🌱 for a greener, more hands-on world.

My Roommate Sends Chaotic Grocery Messages. So I Built an AI for It.

Saksham Sontakke — Mon, 05 Oct 2026 08:15:16 +0000

What I Built

MessyList — Turn chaotic grocery messages into a shopping list

My roommate has a very particular way of asking me to buy groceries.

It's rarely:

"Buy 1 packet of milk, 1 brown bread, and 5kg of atta."

Instead, it looks more like:

"bhai milk le aana"
"bread bhi"
"brown wali"
"eggs bhi khatam hai"
"actually Rahul eggs la raha"
"atta bhi le aa"
"5kg wala"

And somehow, I'm supposed to remember all of that while standing in a grocery store. 😭

So I built MessyList, a personal AI grocery assistant that turns those chaotic conversations into a clean, actionable shopping list.

The idea is simple:

Messy messages → AI understands the context → Clean grocery list

But it isn't just extracting nouns from a message.

MessyList can understand things like:

"bread bhi" → add bread

"brown wali" → understand that it refers to the bread

"get 5kg atta" → understand quantity and unit

"actually Rahul is bringing eggs" → remove eggs from the list

"same milk as last time" → use a saved preference

corrections and conversational context

After the AI interprets the conversation, I can review and edit the result before saving it as a shopping list.

The app also remembers grocery preferences and previous lists, so it can become more useful over time.

I built this specifically around a real, everyday problem rather than trying to make another generic AI chatbot.

Demo

Try MessyList:
https://grocery-ai-indol.vercel.app/

The deployed app includes a demo flow so you can try the idea without having to prepare your own grocery messages.

A typical flow looks like:

Paste the messy messages

bhai milk le aana
bread bhi
brown wali
eggs khatam hai
actually Rahul eggs la raha
atta bhi 5kg wala

MessyList understands them
Review the AI's interpretation
Save the shopping list
Check items off while shopping

The goal was to make the interface simple enough that my roommate could actually use it instead of needing a tutorial.

Code

The complete source code is available on GitHub:

👉 https://github.com/CyborgX-hash/Grocery-ai

The repository contains the frontend, backend, Prisma database layer, AI integration, and demo mode.

How I Built It

The application is built as a full-stack web application.

Tech Stack

React

Node.js

Express.js

Prisma ORM

Database persistence

Open-weight AI / Gemma

Vercel for deployment

The important part of the architecture is the AI parsing layer.

The grocery conversation is sent to the AI with relevant context such as saved grocery preferences and previous purchases.

The model converts the natural language into structured data rather than simply generating a conversational response.

For example:

{
"items": [
{
"name": "Brown Bread",
"quantity": 1,
"unit": "pack",
"status": "active"
},
{
"name": "Eggs",
"status": "cancelled",
"notes": "Rahul is bringing them"
},
{
"name": "Atta",
"quantity": 5,
"unit": "kg",
"status": "active"
}
]
}

The application then validates that response and lets the user review it before saving anything.

I also added a development/demo mode so the application can still demonstrate the complete product flow without exposing or hardcoding AI credentials.

The data layer

I used Prisma ORM to manage the persistent data layer.

The application stores things like:

Grocery lists

Grocery items

Purchase status

Grocery preferences

Previous shopping history

This allows the AI to use relevant personal context instead of treating every grocery request as completely independent.

Why Does Open Innovation Matter?

This is probably the most important part of the project for me.

A grocery list might not sound like sensitive information, but when you start giving an AI access to someone's messages, habits, preferences, purchases, and household information, privacy becomes important.

I wanted the architecture to be built around an open-weight model rather than making the application completely dependent on a closed AI provider.

Using an open model such as Gemma gives the project much more flexibility.

The model can potentially be:

self-hosted

swapped for another open model

adapted for a specific use case

run in a more private environment

changed without rebuilding the entire application around one proprietary API

That matters because the long-term idea behind MessyList isn't just:

"Send my messages to an AI and get a list."

It's:

"Give me a personal AI tool that I can actually control."

For a personal assistant dealing with someone's everyday messages and preferences, that distinction matters.

My Agent Session

I used an AI-assisted development workflow to build and iterate on the application, from the initial architecture and UI through the AI parsing flow and database integration.

Prize Categories

🏆 Best Use of Gemma

MessyList is built around an open-weight AI architecture using Gemma for understanding natural-language grocery conversations and converting them into structured grocery data.

I'm entering the Best Use of Gemma category.

What's Next?

MessyList started with one very specific problem: my roommate's chaotic grocery messages.

But there are a few directions I'd love to take it next:

Voice messages — turn voice notes into shopping lists.

WhatsApp integration — automatically process grocery conversations.

Receipt scanning — update purchase history from receipts.

Budget mode — build a grocery list around a spending limit.

Shared household lists — allow multiple roommates to contribute to the same list.

For now, though, I'm happy that a conversation that normally looks like this:

"milk le aana"
"bread bhi"
"wait don't get eggs"
"actually get eggs"

can become something a little more useful:

☐ Milk
☐ Brown Bread
☐ Atta — 5kg

And hopefully, a little less chaotic. 😄

Thanks for checking out MessyList!