This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.
Touch Grass: Less Screen Time, More Real-World Adventures
What if AI didn't try to keep you staring at a screen—but actually encouraged you to put your phone away?
That's the idea behind Touch Grass, an AI-powered outdoor adventure application I built for the Hacktoberfest Open-Source AI Challenge.
Instead of endlessly scrolling, users choose an adventure style, pick how much time they have, and let AI generate a mission that encourages them to explore their surroundings.
The goal is simple: use technology to help people spend less time using technology.
What I Built
Touch Grass turns an ordinary walk into an opportunity for discovery.
Users can choose from three adventure styles:
- Investigate: Follow clues and uncover details.
- Observe: Slow down and notice nature.
- Discover: Find something unexpected.
They also choose an adventure duration, ranging from 10–15 minutes to 30–45 minutes.
The application generates a mission with a premise, an objective, a safety briefing, and a first clue. Once the adventure begins, users can put their phones away, explore their surroundings, return to record observations, and receive their next AI-generated clue.
The experience is designed around a simple principle: the screen should be the shortest part of the adventure.
A Look at Touch Grass
1. Plan Your Adventure
Choose how you want to explore and how much time you have. The interface is designed to make starting an adventure straightforward.
*
Caption: First look of the home screen.
2. Generate a Mission
The AI creates an outdoor mission tailored to the selected adventure style and duration, giving users a starting point for their exploration.
Caption: Each mission includes an objective and an initial clue to get the adventure started.
3. Explore, Observe, and Discover
After receiving the first clue, users are encouraged to put their phones away and observe their surroundings. When they return, they can describe what they noticed and request the next clue.
Caption: Progressive clues help turn real-world observations into an interactive adventure.
How I Built It
I built Touch Grass using a React frontend, a Python backend, and locally running open-weight AI.
Technology stack
- React + Vite: Frontend and interactive adventure interface.
- Python + FastAPI: Backend API and mission-generation workflow.
- Ollama: Local model inference.
- Qwen3 4B: The open-weight language model powering AI-generated missions and clues.
- Pytest: Backend testing.
The backend handles mission requests and generates follow-up clues based on the user's observations. I also implemented clue-progression logic so the experience can move through different stages of exploration.
One of the challenges was making language-model output predictable enough for an application. AI responses can vary in structure, so I worked on normalizing responses, validating expected fields, and testing clue progression.
At the time of submission, the backend test suite passes 33 tests, and the frontend production build succeeds.
Why Does Open Innovation Matter?
For Touch Grass, open innovation wasn't just a technology choice. It changed how I could build and experiment with the project.
Using Ollama and Qwen3 4B allowed me to run inference locally instead of making a paid, proprietary AI API a required dependency.
That gave me several advantages:
1. More control over the AI experience
I can experiment with prompts, adjust the mission-generation process, and explore different models without redesigning the entire application around one proprietary provider.
2. Local inference
The model can run on a compatible local machine, allowing experimentation without sending every prompt to a third-party inference API. The initial model download and setup still require the appropriate installation and model files.
3. Lower dependency on paid APIs
For a student project, avoiding a mandatory paid inference API makes experimentation more accessible and removes usage-based API charges from the core development workflow. Local inference still uses the computer's resources.
4. A more open development path
Other developers can inspect the code, experiment with the prompts, change the model, and build on the idea.
I especially like that the technology can be used to encourage people to disconnect. AI provides the initial guidance, but the actual experience happens outside the application—in the world around the user.
What I Learned
Building Touch Grass taught me that integrating AI into an application involves more than calling a model and displaying its response.
I had to think about structured output, API validation, clue progression, frontend state, error handling, and testing. I also learned how important it is to keep the interface focused on the user's real-world goal instead of adding unnecessary screen interactions.
There is still room to improve the experience, particularly through more field testing, refining mission progression, and eventually making the app easier to access outside a local development environment.
My Agent Session
I used AI-assisted development tools while building and debugging the project.
What's Next?
I'd like to continue improving Touch Grass with better mission variety, more reliable clue progression, and feedback from people actually using it outdoors.
The most important test isn't whether someone spends more time inside the app. It's whether the app gives them a reason to close it, step outside, and discover something they might otherwise have missed.
Try the Project
GitHub repository: Touch Grass — anmolchaudhary617-ux/touch-grass
The project currently runs locally. A public deployment is not available yet.
If you try the idea, I'd love to hear what kind of outdoor mission would get you to put your phone away and explore.
Build with open AI. Step away from the screen. Touch Grass.
Top comments (0)