🌿 Walk & Notice — AI That Gets You Off the Screen

Gourav Chhatwani — Sat, 10 Oct 2026 13:35:19 +0000

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

What I Built

🌿 Walk & Notice

AI should help you leave the screen — not keep you on it.

For Hacktoberfest Week 1, I built Walk & Notice, an AI-powered outdoor observation mission generator built around one simple idea:

The AI interaction should end when the real-world experience begins.

Instead of creating another chatbot that encourages people to spend more time on their phones, Walk & Notice uses AI to create a short, personalized outdoor mission — and then tells the user to put the phone away.

The project has a proper Streamlit frontend where users configure the experience before generating their mission.

The interface lets users choose:

🤖 AI provider
⏱️ Available time
🌳 Outdoor environment
🔎 What they want to notice
⚡ Energy level

The application turns those choices into a short four-step observation mission.

Every mission ends with:

Now put your phone away.

The idea is intentionally simple:

Generate it. Read it. Go outside. Notice something.

The screen is supposed to be the shortest part of the experience.

Demo

GitHub may not preview the video directly because of its file size. The original high-quality video is available for download.

🔄 Alternative Video Download

Download the demo from JioCloud

Alternative download option if the GitHub file is inconvenient to access.

📸 Evidence

View screenshots and supporting evidence

Code

💻 GitHub Repository

View Walk & Notice on GitHub

The repository contains the complete implementation, including:

Streamlit frontend
AI provider abstraction
Gemma 4 E4B + Ollama integration
OpenRouter integration
Prompt engineering
Automated tests
Docker configuration
GitHub Actions CI/CD
GitHub Container Registry publishing
Render deployment
Documentation
Demo and supporting evidence

How I Built It

I wanted the AI to be part of the solution without making the AI interaction itself the main experience.

The project therefore has two AI inference paths: a local open-weight path for development and a production path through OpenRouter.

🦙 Local AI — Gemma 4 E4B + Ollama

During development, I run Gemma 4 E4B locally through Ollama.

The local architecture is:

Streamlit
    ↓
Python
    ↓
Ollama
    ↓
Gemma 4 E4B
    ↓
Outdoor Mission

This allows the application to generate missions locally using an open-weight model.

The local model runs on my RTX 3060, allowing me to develop and test the core AI experience without requiring a hosted AI API.

☁️ Production AI — OpenRouter

For the public deployment, I added a second provider using OpenRouter with:

openai/gpt-oss-20b

The application keeps the AI provider behind the same Python interface, allowing the frontend and mission-generation logic to work with different inference providers.

The overall application flow is:

                     Streamlit Frontend
                           │
              ┌────────────┴────────────┐
              ↓                         ↓
       Local AI Provider        Production Provider
              ↓                         ↓
       Gemma 4 E4B                 OpenRouter
              ↓                         ↓
           Ollama                  GPT-OSS-20B
              └────────────┬────────────┘
                           ↓
                  Personalized Mission
                           ↓
                  "Put your phone away."
                           ↓
                         🌳 Outdoors

🎨 Streamlit Frontend

Rather than asking users to interact directly with an LLM, I built a proper Streamlit frontend around the model.

The interface collects structured preferences and passes them to the mission generator.

This turns the project from a raw model experiment into a small usable application.

The frontend controls the experience.

The model handles the generation.

And then the user leaves the screen.

🧠 Prompt Engineering

The mission generator is intentionally constrained.

The model is instructed to:

Generate exactly four numbered steps
Keep each step short
Match the user's selected preferences
Create safe outdoor activities
Require no special equipment
Avoid interacting with wildlife
Avoid traffic and dangerous locations
Avoid requiring a phone, camera, or recording

The final instruction is always:

Now put your phone away.

The goal isn't to generate a long AI response.

The goal is to generate something useful enough to read quickly and then act on in the real world.

🛡️ Safety by Design

Because Walk & Notice encourages people to go outdoors, safety is built into the generation instructions.

The model is explicitly prevented from creating missions involving things such as:

Traffic
Approaching wildlife
Dangerous climbing
Dangerous objects
Unsafe locations
Required equipment
Recording or photographing

The activities are designed around observation rather than risky physical challenges.

🧪 Automated Testing

I added automated tests for both AI provider paths:

Ollama generation
OpenRouter generation

The local test suite currently passes:

2 passed

These tests are also executed automatically through GitHub Actions before the production image is built.

🐳 Docker

The application is containerized with Docker.

The production image is published to GitHub Container Registry:

ghcr.io/gouravgc/walk-and-notice:latest

This provides a reproducible production artifact that can be deployed without manually configuring the application environment.

⚙️ GitHub Actions CI/CD

I built an automated GitHub Actions pipeline for testing and container delivery.

The workflow is:

GitHub Push
     ↓
Run pytest
     ↓
Build Docker Image
     ↓
Push Image to GHCR
     ↓
Render
     ↓
Production Application

View the successful GitHub Actions workflow

This means a code change can move through testing and container publishing automatically instead of requiring a manual Docker build and registry push.

🚀 Render Deployment

The production application runs on Render using the Docker image published to GHCR.

Open the production application

This takes Walk & Notice beyond a local prototype and gives the project a publicly accessible production deployment.

Why Does Open Innovation Matter?

Open innovation matters to Walk & Notice because the AI itself is part of the project's philosophy.

The application was built around an open-weight model that can run locally.

With Gemma 4 E4B and Ollama, I can run the AI on my own hardware, experiment with prompts, change the model configuration, and develop the application without making a proprietary hosted API the only way the system can work.

That is particularly relevant to this project.

Walk & Notice is designed to reduce unnecessary screen time.

A local inference path means the core mission-generation experience can work without sending every development interaction to a remote AI provider.

It also gives me more control over experimentation.

I can:

Run the model locally
Modify the prompts
Experiment with the model
Change the application's behavior
Keep the core AI workflow under my control

The production deployment adds an OpenRouter path for public access, but the application architecture still keeps local open-weight inference as a first-class option.

For me, that is where open innovation fits this project best:

The AI can be experimented with locally, while the experience itself is designed to get the user away from the screen.

Prize Categories

I am entering the following partner categories:

🟢 Best Use of Gemma

Walk & Notice uses Gemma 4 E4B locally through Ollama as one of its AI providers.

Gemma is directly responsible for generating the personalized outdoor observation missions.

🟠 Best Use of Render

The production version of Walk & Notice is deployed on Render using the Docker image published to GitHub Container Registry.

Open the production application

🟣 Best Use of GitHub Copilot

Walk & Notice uses GitHub Actions to automate its software delivery workflow.

The pipeline automatically runs tests, builds the Docker image, and publishes the production image to GHCR.

This uses the GitHub Actions automation route explicitly listed in the challenge's Best Use of GitHub Copilot category.

🌍 The Idea Behind Walk & Notice

The easiest thing for an AI application to do is give us another reason to stay online.

I wanted to build something different.

Walk & Notice uses AI to create the starting point for a real-world experience — and then gets out of the way.

The AI generates the mission.

You do the walking.

You do the noticing.

The real world does the rest.

🌿

DEV Community: Gourav Chhatwani