Touch Grass Challenge — AI Gives You a Reason to Go Outside

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

What I Built

outside | AI plans. You go.
It is a local-first outdoor challenge planner powered by an open-weight AI model.

You tell it:

where you are
what you enjoy
how often you want to go outside
how much time you have each day
what you want to get out of the experience

The AI then creates a personalized set of outdoor challenges for the current month.

Instead of giving you another chatbot to talk to, the app gives you something to do.

For example:

Take a different route home
Find five signs of the current season
Explore somewhere you've never walked
Watch the sunset somewhere new
Notice three unfamiliar plants

You can complete challenges as you go, optionally leave a short note about the experience, and track your progress throughout the month.

When all challenges are completed, the AI generates a reflection based on what you actually did and the notes you left.

Then you can:

repeat the experience
create something new
let the AI decide what comes next

The app also uses the current month and season when creating plans, so the experience can evolve as the year changes.

Most importantly, the AI isn't the destination. It's the reason to leave the screen.

Demo

touch grass challenge.mkv - Google Drive

drive.google.com

Code

coderSuresh / touch-grass-challenge

Touch Grass Challenge

This project is the Touch Grass Challenge for the Hacktoberfest 2026 #### Week 1 DEV Challenge.

Touch Grass Challenge creates personalized outdoor plans with AI. The project contains a Next.js frontend and a NestJS API backed by PostgreSQL and Prisma.

Prerequisites

• Node.js 20 or newer
• PostgreSQL
• Ollama with the configured model available locally

Setup

Install dependencies in both packages:

cd backend
npm install

cd ..\frontend
npm install

Create backend/.env:

DATABASE_URL="postgresql://postgres:postgres@localhost:5432/touch_grass"
PORT=3001
FRONTEND_URL="http://localhost:3000"
OLLAMA_BASE_URL="http://localhost:11434"
OLLAMA_MODEL="gemma4:7.5b"

Create frontend/.env.local:

NEXT_PUBLIC_API_URL="http://localhost:3001"

Make sure the PostgreSQL database exists, then generate Prisma Client, apply migrations, and optionally seed sample data:

cd backend
npm run prisma:generate
npm run prisma:migrate
npm run prisma:seed

If using Ollama locally, pull the configured model before starting the API:

ollama pull gemma4:7.5b

…

View on GitHub

How I Built It

This full-stack web app is built around local AI inference.

Stack
Next.js
TypeScript
Tailwind CSS
NestJS
PostgreSQL
Prisma
Ollama
Gemma 4

The architecture is:

Next.js
↓
NestJS REST API
↓
AI Service
↓
Ollama
↓
Gemma 4
↓
PostgreSQL

The browser never communicates directly with the AI model.

The NestJS backend sends the user's preferences and the current temporal context to the local AI service.

Gemma is used for the parts that actually benefit from generative AI:

creating personalized outdoor challenges
adapting incomplete challenges when circumstances change
generating an end-of-month reflection
creating the next set of challenges based on previous experiences

The rest is deterministic application logic.

For example, the application handles progress, completion state, dates, seasons, and database operations rather than asking the AI to calculate them.

The AI also returns structured JSON, which is validated by the backend before anything is stored in PostgreSQL.

There is no authentication in this version. I wanted the experience to start immediately without turning a simple outdoor tool into another account-based platform.

Why Does Open Innovation Matter?

The biggest reason I chose local open-weight AI is independence.

This application isn't fundamentally dependent on sending someone's preferences, plans, and personal reflections to a closed AI API.

With Ollama and Gemma running locally, the AI inference can happen on the user's own machine.

That also makes the idea of an offline AI application much more tangible.

Once the model and application are installed, I can disconnect from the internet and still generate outdoor challenges locally.

That's particularly fitting for this project.

A tool whose purpose is to get you away from the internet shouldn't necessarily require the internet to think.

Open models also made experimentation much easier. I could build the AI layer around a model running on my own hardware, control the prompts and structured output, and design the product around the capabilities of the model rather than around a remote API dependency.