What If AI Helped You Put Your Phone Down? 🌿 I Built Outside to Make That Happen
Most apps want more of your attention. I wanted to build one that helps you give it back to the real world.
Waiting for a friend? Scroll.
Have 20 minutes between classes? Scroll.
Feeling stressed and looking for a break? Somehow, you're still staring at a screen.
We open our phones without thinking. Sometimes we're looking for something specific. Other times, we're just filling a quiet moment because we don't know what else to do.
And even when we decide to step outside, another problem appears: What should I do? Where should I start? Is 15 minutes even enough?
That got me thinking.
What if AI didn't give us another reason to stay on our phones? What if it helped us put them down?
That question inspired me to build Outside — an AI-powered outdoor companion designed to turn spare time into small, practical opportunities to explore, notice our surroundings, and reconnect with the world outside our screens.
The idea is simple: use technology to make the first step easier, then get out of the way.
🌐 Try Outside: https://outside-lmth.onrender.com
🎬 Watch the demo: https://youtu.be/umWsHyiBCoo
💻 Explore the code: https://github.com/tribhu05/outside
🌱 1. The problem I wanted to solve
I wasn't trying to build another productivity dashboard or a chatbot that could talk endlessly about healthy habits.
I wanted to explore a smaller, more practical problem: the gap between wanting to do something outside and actually doing it.
Imagine you have 20 minutes free.
You could take a short walk, explore a nearby street, listen to the birds, notice something interesting, or simply take a break from your usual routine.
But deciding what to do takes effort. When you're tired or distracted, doing nothing can feel easier than making a plan.
A generic list of outdoor activities doesn't necessarily help, either. It doesn't know whether you have 10 minutes or an hour, whether you want something relaxing or active, or what kind of experience you're looking for.
I wanted to make that decision easier.
Instead of asking people to plan everything themselves, Outside lets them describe what they want in natural language and turns that intent into a structured outdoor activity.
The goal isn't to optimize every minute of someone's life.
It's to make it a little easier to start living that minute.
🍃 2. Meet Outside
Outside is built around a different kind of app experience.
Instead of encouraging you to stay and explore endless content, it helps you prepare an activity and then transition away from the screen.
The experience brings together natural-language activity planning, sensory challenges, a dedicated GO OUTSIDE mode, and a way to reflect on the experience afterwards.
Let's walk through how it works.
🧭 3. From a vague idea to an actual plan
Sometimes, the hardest part of doing something is deciding what that something should be.
Outside is designed to accept everyday requests rather than requiring users to describe their plans in rigid technical terms.
For example:
"I have 20 minutes, feel a little stressed, and want to get some fresh air."
That request contains several pieces of intent: the available time, the user's mood, and the kind of experience they're looking for.
Outside interprets the request and uses its planning engine to organize an outdoor activity.
The intention is to make the process feel closer to explaining what you need to a person than filling out a complicated form.
Figure 1: The Outside interface, where the user begins planning an outdoor activity.
This is the first important part of the experience. The user shouldn't need to understand AI models, prompts, or planning algorithms to get started.
They should be able to describe what they want and move on.
✨ 4. The plan is only the beginning
Generating an activity isn't the entire point.
Outside is designed to make the resulting experience more intentional through small sensory challenges and prompts.
Instead of walking while looking at a screen, you might be encouraged to:
- Listen carefully to the sounds around you.
- Notice patterns in leaves, branches, or clouds.
- Look for something interesting that you would normally walk past.
- Pay attention to the environment without constantly checking your phone.
These are small actions, but they change the purpose of a walk.
You're no longer simply trying to fill 20 minutes. You're giving yourself a reason to notice the world around you.
The challenges aren't intended to make every moment competitive or turn relaxation into another productivity target.
They're gentle prompts for paying attention.
Figure 2: An example of the activity-planning experience. Use an actual generated result from your application.
📵 5. GO OUTSIDE mode: the most important part
This is the feature that best represents the philosophy behind the project.
Think about the typical AI application experience.
You ask a question. You receive an answer. Then you ask another question. Before you know it, you've spent 30 minutes interacting with a screen.
Outside is intended to work differently.
Once you've prepared your activity, GO OUTSIDE mode provides a transition from planning to doing.
You have your activity. You know what to focus on. Now it's time to leave the application and experience it.
The screen should help you prepare for the experience, not become the experience itself.
Figure 3: GO OUTSIDE mode. This is where the application encourages the user to shift attention away from the screen.
I think this is an important product-design distinction.
A wellness app doesn't necessarily become useful by adding more features, more notifications, or more reasons to return.
Sometimes, its most valuable contribution is helping someone take a small action and then letting them go.
🌤️ 6. After the walk: reflection and local history
Going outside shouldn't have to become another activity you measure obsessively.
Still, being able to reflect on an experience can help make it meaningful.
Outside includes reflection and local history features so users can look back on their outdoor activities.
Rather than treating an activity as something that disappears as soon as it's finished, the application gives users a way to record their experience and revisit their history.
The purpose is simple: remember the moments you made time for, without creating another demanding digital routine.
Figure 4: The reflection and history experience after completing an outdoor activity.
This also gives the project room to grow. Future improvements could explore more adaptive reflection prompts, better personalization, and ways to make activities accessible to people with different schedules and energy levels.
🧠 7. Why use AI for this?
This was one of the most interesting engineering decisions in the project.
I didn't want to add an LLM simply because AI applications are popular. I wanted it to solve a specific problem: understanding what someone means when they describe the kind of outdoor experience they want.
People don't naturally speak in structured data.
They say things like:
"I've got a little time before my next class."
"I don't have much energy today."
"I want to get outside, but I don't want anything too intense."
Interpreting requests like these is a useful role for a language model.
But there is an important distinction between understanding a request and reliably executing a plan.
I designed Outside to separate those responsibilities.
The AI interprets; the planning engine organizes
The Gemma-compatible integration helps interpret natural-language intent. A separate deterministic activity engine handles the structured planning process.
This separation means the language model isn't responsible for every part of the application.
The model helps understand the request. The application logic is responsible for turning that interpretation into a plan in a predictable structure.
That makes the system easier to reason about, test, and improve independently.
It also avoids treating every model response as something the application should automatically trust.
What happens when the AI endpoint is unavailable?
An application shouldn't become completely unusable just because an AI service is unavailable.
Outside includes a local heuristic fallback for supported requests. When the configured model endpoint cannot be used, this fallback can handle the requests it supports.
It isn't equivalent to a language model's flexible interpretation, and I don't want to pretend otherwise.
Its purpose is to preserve basic functionality rather than leave the user with a broken experience.
This was an important architectural principle for me: AI should improve the experience, but the application should still behave honestly when AI isn't available.
🔓 8. Exploring open-weight AI with Gemma
Outside also gave me an opportunity to explore open-weight AI models in a practical application.
The project supports Gemma-compatible integration through an OpenAI-compatible endpoint, including a local configuration using Ollama.
When configured to use a local model, the application can perform its language-model inference on the user's machine rather than depending on a hosted AI service for that step.
This is useful for experimentation, flexibility, and privacy-conscious development.
It also comes with trade-offs.
Local inference depends on the available hardware, the selected model, and its configuration. Response speed and output quality can differ from a hosted setup.
The important part is that the model isn't an unexplained black box sitting behind the interface. Its responsibility is clearly defined within the larger application.
I wanted to explore how an open-weight model could contribute to a small, focused product without allowing the model to dictate the entire user experience.
🛠️ 9. How I built Outside
The application uses a combination of frontend development, AI integration, deterministic application logic, and browser-based persistence.
Here's the role each part plays.
| Component | Purpose |
|---|---|
| React | Builds the interactive user interface. |
| TypeScript | Makes application data and logic easier to reason about through static types. |
| Gemma-compatible integration | Interprets natural-language activity requests when the model endpoint is configured. |
| Deterministic activity engine | Organizes the interpreted intent into a structured plan. |
| Local heuristic fallback | Supports basic planning when the configured AI endpoint is unavailable. |
| Browser local storage | Persists saved activity history and reflections locally in the browser. |
One lesson from this project is that the quality of an AI application depends on more than the model itself.
The surrounding application determines how requests are handled, how model outputs are used, what happens when something fails, and how the result is presented to the user.
A useful AI feature needs that supporting engineering to work well.
🔒 10. Privacy: local-first doesn't mean every setup is identical
Privacy is particularly relevant when an application may receive information about a person's mood, preferences, or personal reflections.
Outside stores saved history and reflections in browser local storage. It can also use a local model endpoint for inference.
When inference happens locally, the prompt for that model interaction does not need to be sent to a hosted AI service.
However, the actual privacy properties depend on the configuration.
If a remote endpoint is used, the information sent to that endpoint may be processed by the provider. Browser storage also isn't the same as encrypted storage or a secure backup system.
I think it's important to explain those distinctions instead of describing every possible configuration as completely private.
The goal is to give users a clear understanding of where their data goes and what their setup actually does.
🎨 11. Designing an application that doesn't compete for attention
The interface is part of the idea, not merely a wrapper around the AI.
If the goal is to encourage people to spend less time looking at their phones, it would be contradictory to build a cluttered experience full of distractions.
I wanted Outside to feel calm and focused.
The user should understand what to do next without navigating a complicated dashboard. Planning should be straightforward, the activity should be clear, and leaving the screen should feel like a natural part of the experience.
That principle influenced how I thought about the interface and the overall flow.
It also provides a useful design constraint for future features: any new functionality should make the outdoor experience better, not simply give users another reason to stay in the application.
🚧 12. What I would like to improve
Outside is an experiment in using AI to support a real-world behavior, and there is plenty of room to improve it.
Some areas I'd like to explore include:
- More adaptive activities: Better handling of different time constraints, preferences, and energy levels.
- Better activity quality: Making generated plans practical, varied, and appropriate for the user's stated intent.
- Accessibility: Designing activities and interfaces that work for people with different needs and abilities.
- Local-model experience: Improving setup guidance and making the distinction between model-generated results and fallback results clear.
- Reflection: Exploring ways to make post-activity reflection useful without turning it into another obligation.
I would also like to evaluate the experience with more users and learn whether the activities genuinely help people take that first step outside.
That is a more meaningful measure of progress than simply counting how many times someone opens the app.
🚀 13. Try it yourself
Outside is my contribution to the DEV Community's Hacktoberfest Open-Source AI Challenge, Week 1: Touch Grass.
The project explores a simple question: can we use AI to help people spend less time interacting with technology and more time experiencing the world around them?
You can explore the working application, watch the demo, or inspect the source code.
🌐 Live application: https://outside-lmth.onrender.com
🎬 Demo video: https://youtu.be/umWsHyiBCoo
💻 GitHub repository: https://github.com/tribhu05/outside
If you'd like to run the project locally, check the repository's README for the current setup instructions.
I'd especially appreciate feedback on three questions:
- Do the activity suggestions feel practical enough to use during an ordinary day?
- Do the sensory challenges make a short walk more engaging?
- Does the transition into GO OUTSIDE mode feel natural, or is there anything that would make it easier to put the phone away?
I'm also interested in contributions that improve the planning logic, accessibility, local-model integration, and overall user experience.
🌿 One last thought
Technology is becoming increasingly good at capturing our attention.
I wanted to experiment with a different direction.
What if an AI application helped you make a plan, gave you a small reason to explore, and then encouraged you to stop using it?
Not because the technology failed to keep you engaged.
Because it succeeded at helping you do something else.
Less scrolling. More living. 🌿
Top comments (0)