πΏ WildStep: I Built an AI That Wants You to Close the App
Most apps want your attention.
More scrolling. More recommendations. More time spent looking at a screen.
What if an AI app was designed to help you leave it?
That question led me to build WildStep β an AI-powered outdoor mission generator that turns your mood, available time, personal goal, and surroundings into a personalized set of real-world activities.
The idea is simple:
AI generates the mission. You go experience it.
WildStep is built around a different kind of product philosophy: the digital interaction should be short, useful, and focused on encouraging people to spend more time in the real world.
What I Built
WildStep helps people turn an ordinary break into a small, actionable outdoor mission.
Instead of offering the same generic suggestion to everyone, it lets users personalize a mission using:
- Available time: Choose how much time you have for a break.
- Mood: Select how you're feeling.
- Personal goal: Describe what you'd like to achieve.
- Surroundings: Select a campus, park, neighborhood, or another supported environment.
- Difficulty and companions: Tailor the mission to your preferences.
The AI generates a mission with individual tasks and estimated durations. Users can work through an interactive checklist, track progress, retrieve saved missions, and earn Grass Points when they finish.
The experience
- Tell WildStep how you're feeling.
- Choose your available time and surroundings.
- Generate a personalized mission.
- Step away from the screen and complete the activities.
- Return to record your progress and earn Grass Points.
The task checklist is intentionally simple. You shouldn't need another feed to scroll through when you're trying to take a break.
Demo
π Live application: https://wildstep-six.vercel.app/
π» Source code: https://github.com/pushptandekar24-glitch/wildstep
The public demo uses Vercel for the frontend, Render for the Spring Boot backend, TiDB Cloud for persistence, and Cloudflare Workers AI for hosted inference.
The application has been deployed and tested with live mission generation and task completion. Free-tier services may introduce cold starts, latency, or usage limits.
What It Looks Like
1. A mission generated for your situation
WildStep doesn't stop at suggesting an activity. It turns the idea into a sequence of tasks with progress tracking so users can see what they've completed.
2. Completing a mission
When all required tasks are marked complete, the backend updates the mission state and calculates the Grass Points reward.
Completion is self-reported through the checklist. The current application does not independently verify physical activity through GPS or photo evidence.
How I Built It
WildStep is a modular full-stack application. The frontend handles the user experience, while the backend owns mission generation orchestration, validation, persistence, task completion, and rewards.
Technology stack
| Layer | Technologies |
|---|---|
| Frontend | React, TypeScript, Vite, Tailwind CSS |
| Backend | Java 21, Spring Boot REST APIs |
| Persistence | Spring Data JPA, Hibernate, MySQL-compatible database |
| Database migrations | Flyway, where configured |
| Local inference | Ollama with Gemma 2 |
| Hosted inference | Cloudflare Workers AI with Llama 3.2 |
| Deployment | Vercel, Render, TiDB Cloud |
| Testing | JUnit, Mockito, controller and integration tests |
The architecture
The browser never calls the AI provider directly. It sends requests to the Spring Boot API, which manages the AI request and owns the mission lifecycle.
User preferences
|
v
React + TypeScript
|
v
Spring Boot REST API
|
v
Mission generation service
|
+-----------------------------+
| |
v v
Ollama + Gemma 2 Cloudflare Workers AI
(local development) (hosted deployment)
| |
+--------------+--------------+
|
v
Structured mission output
|
v
Backend validation
|
v
TiDB Cloud / MySQL
|
v
Tasks, progress and rewards
Why not let the AI control everything?
Language models can generate creative activities, but generated output should not automatically be trusted as application data.
WildStep separates responsibilities:
- The model proposes mission content.
- The backend parses the response and checks validation and safety rules.
- The database stores missions and tasks.
- The mission service manages task completion and status transitions.
- The Grass Points service calculates rewards deterministically.
This separation helps preserve consistent behavior even when an AI provider returns malformed output or becomes unavailable.
Grass Points and mission progress
Grass Points add a lightweight reward loop to encourage users to finish their missions.
The backend calculates rewards rather than asking the model to choose arbitrary points. Repeated task-completion requests are handled so that a completed task doesn't award its reward repeatedly.
The result is a clear loop:
Generate mission
β
Go outside
β
Complete tasks
β
Track progress
β
Earn Grass Points
β
Close the app
The last step is the most important part of the product.
Why Does Open Innovation Matter?
This is the part of WildStep that made the project particularly interesting to build.
Open-weight models give developers more control over experimentation, deployment, and the way AI behavior is integrated into a product.
During local development, WildStep can use Gemma 2 through Ollama. Developers can experiment with mission prompts on their own machines, subject to their hardware capabilities.
For the public demo, WildStep uses Cloudflare Workers AI with an open-weight Llama model. Visitors don't have to download a model before trying the application, although inference requests are processed by the hosted provider.
These two modes offer different trade-offs:
- Local inference: More control over the runtime and the opportunity to keep inference on the local machine.
- Hosted inference: Easier public access without requiring each visitor to install and run a model.
- A replaceable provider integration: The frontend and mission lifecycle don't need to be rewritten every time the inference provider changes.
Open weights do not automatically make hosted inference private or offline. In the deployed version, prompts are sent to the configured inference service. In local mode, processing can remain local when the selected configuration and runtime support it.
Open innovation matters because developers can inspect their stack, experiment with different models, change prompts, and adapt their systems rather than building everything around a single closed API.
For WildStep, AI is not the destination. It is the trigger for an experience outside the screen.
Building and Debugging the Real Thing
One of the most valuable parts of this project was taking it beyond a local prototype.
The application went through frontend integration, backend testing, cloud database configuration, Docker deployment, frontend deployment, and live API verification.
The hosted AI integration also exposed an important debugging lesson: a successful HTTP request doesn't guarantee that an application can correctly interpret the returned JSON.
I had to investigate response parsing and error handling so that Cloudflare's response envelope could be handled more robustly without bypassing the mission validation layer.
That reinforced an important principle: reliable AI applications require more than a working model call. They need validation, persistence, failure handling, and predictable application logic.
The project includes automated tests for mission generation, validation, lifecycle behavior, and deterministic rewards. The latest local verification report recorded 74 passing backend tests and a successful frontend production build; the final repository should be checked for the latest fixes before treating that test count as the published version's result.
A Note on Safety
WildStep is intended to suggest approachable activities, not encourage risky adventures.
The backend applies validation and safety checks to generated mission content. Users should still skip activities that feel unsafe, respect public and private property, follow local rules, and avoid hazardous areas.
WildStep is a recreational activity tool, not a medical or mental-health treatment.
My Agent Session
I used Antigravity as an AI-assisted development tool while building, refining, and debugging WildStep.
The implementation, tests, and application architecture can be explored in the GitHub repository.
I haven't included a DevRelay agent-session link in this post.
Prize Categories
Best Use of Gemma: WildStep supports Gemma 2 through Ollama in its local development mode. The deployed public demo currently uses Cloudflare Workers AI with Llama 3.2, so the distinction between local and hosted inference is intentional.
Community Context
I also enjoyed reading other interpretations of the same challenge, including:
- AI Nature Quest β an AI that wants you to stop using it
- WildPulse β a zero-signal trail naturalist
It's exciting to see different ways open-source AI can encourage people to spend more time outside.
WildStep takes its own approach: short, context-aware missions, a persistent task checklist, backend-controlled progress, and a simple reward system.
The Idea Behind WildStep
The question wasn't how to make people generate more AI content.
It was how to make AI useful for a moment, so a person could do something meaningful without it.
Generate a mission. Go outside. Complete it. Come back when you're ready.
πΏ WildStep β AI that gets you to close the app.
Top comments (0)