What I Built:

As developers, we spend a ridiculous amount of time staring at screens. We build applications to solve problems, automate tasks, and make life easier, but sometimes we forget to step away from our desks and actually experience the world outside.

That got me thinking: What if AI could help us spend less time on our screens instead of finding more reasons to stay on them?

Meet The Gardening Assistant (TGA), an AI-powered gardening planner built for the Hacktoberfest 2026 Touch Grass challenge.

TGA helps users figure out what to grow based on their available sunlight, garden type, experience level, and available space. Instead of dumping a massive list of plants and expecting beginners to figure everything out, it creates a personalized gardening plan with three targeted plant recommendations, care instructions, and an actionable four-week outdoor checklist.

But the most important feature isn't the AI itself. It's what happens after the AI finishes its job.

Every recommended plant comes with a hands-on outdoor activity, from pruning stems to crushing mint leaves and observing morning blooms. The weekly checklist encourages users to spend approximately 15–25 minutes outdoors per session, turning gardening from an overwhelming hobby into something manageable.

Here's what TGA offers:

Personalized plant recommendations: Find plants suited to your sunlight, available space, gardening experience, and garden type.

Practical care guidance: Get watering schedules, growing-cycle information, and companion-planting tips.

Touch Grass activities: Turn recommendations into real-world sensory experiences and gardening tasks.

A four-week action plan: Follow weekly tasks, track your progress, and build a consistent gardening habit.

Progress tracking: Save completed tasks locally in your browser.

A fallback recommendation engine: Continue generating garden plans even when the local AI model is unavailable.

The philosophy behind TGA is simple: The screen should be the shortest part of gardening.

Demo

Explore the source code: The Gardening Assistant on GitHub

The repository includes the implementation, architecture documentation, screenshots, and setup instructions.

The project is designed to run locally. Follow the README to start the frontend and backend and explore the gardening planner.

Code

Check out the complete repository:

github.com/DaKaufeeBoii/The-Gardening-Assistant

The project is organized into a React frontend, a FastAPI backend, and a curated botanical dataset.

The recommendation flow looks like this:

The user provides their gardening conditions.

The frontend sends the garden profile to the backend.

The backend evaluates suitable plants using curated botanical information.

Gemma personalizes the recommendations when local inference is available.

The application returns a structured garden plan and generates actionable outdoor tasks.

The user tracks progress directly in the browser.

The important design decision here is that the model isn't expected to invent everything from scratch. The botanical dataset provides factual grounding, while a deterministic recommendation engine provides a reliable alternative when the model isn't available.

How I Built It

The main challenge was figuring out how to use AI meaningfully without making the entire application dependent on an AI API.

Here's the stack behind TGA:

Frontend: React 19 and Vite, with a custom CSS design system and Lucide icons.

Backend: Python, FastAPI, and Pydantic for API handling and validation.

AI model: Google's open-weight Gemma model, running locally through Ollama.

Knowledge base: A curated JSON dataset containing plant information, sunlight requirements, watering frequencies, and climate notes.

Recommendation engine: A rule-based scoring system that evaluates sunlight compatibility, space constraints, gardening experience, and garden type.

Persistence: Browser localStorage for saving the generated plan and checklist progress.

Why Gemma?

For this challenge, I wanted AI to be useful without requiring every user to send personal information to a remote inference service.

TGA uses Gemma through local Ollama inference, with support for models such as gemma:2b and gemma2:9b, depending on the available hardware and configuration.

The model receives curated plant facts alongside the user's gardening conditions. This gives it a grounded starting point for producing personalized recommendations rather than relying entirely on whatever it generates from its parameters.

And if Ollama isn't running? The deterministic botanical recommendation engine takes over.

That hybrid approach matters because a gardening assistant should still be useful when an AI model is unavailable. A broken model connection shouldn't prevent someone from figuring out what to plant.

Designing for the Real World

Another important decision was keeping the application focused on action rather than engagement.

The four-week checklist gives users a clear sequence of tasks they can follow away from their computers. It also supports progress tracking, so users can return to the application when they need guidance without having to remain online throughout the activity.

The result is an application where AI helps plan the experience, but the actual experience happens outdoors.

Why Does Open Innovation Matter?

Open innovation made it possible to build TGA around a different idea of what an AI-powered application should look like.

Using an open-weight model such as Gemma gives developers the freedom to experiment with local inference, inspect the surrounding application architecture, customize prompts, and choose how and where inference happens.

For TGA, this creates three practical advantages.

1. More control over privacy

Garden profiles can include information about someone's home, available outdoor space, and personal habits. Running inference locally allows the application to personalize recommendations without sending that profile to a remote model provider.

1. Less dependence on external AI services

Local inference avoids requiring a paid hosted-model API for the core recommendation workflow. It does require suitable local hardware and a working model installation, which is why the rule-based fallback is important.

1. More freedom to experiment

The model, botanical dataset, and recommendation engine can be developed and improved independently. Developers can adjust the plant data, change the model configuration, refine the scoring rules, and contribute improvements without rebuilding the entire application around a proprietary service.

Open innovation isn't just about using something free. It's about having the ability to understand, adapt, and build upon the technology you're using.

TGA is a small example of what that freedom makes possible.

My Agent Session

TGA combines model-assisted recommendations with a deterministic fallback rather than relying on an autonomous agent to control the entire workflow.

The main flow is straightforward:

Garden profile → Botanical grounding → Gemma inference or rule-based fallback → Personalized plan → Outdoor action checklist

This keeps the model's role focused and makes the recommendation process easier to reason about.

Prize Categories

Best Use of Gemma: Local, open-weight AI inference combined with curated botanical knowledge and a deterministic fallback.

Best Use of ElevenLabs: Planned voice narration for hands-free gardening guidance, with browser speech synthesis as a fallback.

Best Use of SerpApi: Planned real-time frost-date research to improve planting recommendations.

Best Use of Sentry Agent Tracing: Backend observability for inference latency, token usage, and fallback events.

The core implementation centers on Gemma. The additional integrations are intended extensions of the project and should be evaluated against their actual configuration and working state.

Building TGA reminded me that AI doesn't always need to help us do more things on a screen. Sometimes, its best use is helping us decide what to do after we close the laptop.

Now, time to touch grass.

Repository: The Gardening Assistant (TGA)

Hacktoberfest #OpenSource #Gemma #AI #Gardening #TouchGrass