DEV Community: Ariba Sayed

OutThere: An AI That Gets You Off Your Screen and Outside

Ariba Sayed — Wed, 07 Oct 2026 20:45:08 +0000

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

What I Built

OutThere is a minimalist web application designed to be the "anti-app." Its primary goal is to give users a compelling, AI-powered reason to put their phones down and reconnect with the physical world.
It serves as a bridge between digital convenience and physical exploration. For anyone feeling "screen-locked," OutThere provides real-time, context-aware triggers to go outside—whether it's a personalized "OutThere Moment" based on the time of day, an AI-curated list of nearby parks and gardens tailored to the current weather, or a custom-generated "Outdoor Mission" that turns a simple walk into a small adventure.

Demo

demo.mp4 - Google Drive

drive.google.com

Code

ariba-sayed / OutThere

🌿 OutThere

OutThere is a minimalist web application designed to encourage people to disconnect from their screens and reconnect with the physical world. It uses real-time weather data and AI-powered recommendations to give users a reason to "touch grass."

✨ Features

Dynamic Home Experience: A personalized greeting and "OutThere Moment" card that changes based on the time of day (Sunrise, Morning, Afternoon, Sunset, Evening, Stargazing).
Real-time Weather Integration: Fetches current temperature, wind speed, and celestial events (sunrise/sunset) via the Open-Meteo API.
AI-Powered Explore: Uses Gemma AI to suggest the best nearby places to visit based on current weather conditions.
Event Discovery: Integrates with Google Search (via SerpApi) to find real-world events happening today, tomorrow, and over the weekend.
Outdoor Missions: A "Mission Builder" that generates a custom outdoor adventure based on the user's available time and desired mood.
Direct Navigation: One-click "Get Directions" buttons…

View on GitHub

How I Built It

I built OutThere using a modern full-stack architecture focused on real-time data and open-weight AI:

AI Core: I used Gemma (google/gemma-4-26B-A4B-it) via the Hugging Face Inference API. Gemma powers two critical features:
- The Recommendation Engine: It analyzes a list of nearby outdoor locations (fetched via SerpApi) alongside real-time weather data to rank the top 3 best places to visit right now.
- The Mission Builder: It generates structured, JSON-based "Outdoor Missions" based on the user's available time, budget, and desired mood, ensuring the activities are realistic and encourage physical movement.
Backend: A Python/Flask server that orchestrates data between the frontend and multiple APIs.
Frontend: A responsive React application using Lucide-React for a clean, nature-inspired aesthetic.
External Data:
- Open-Meteo API for hyper-local weather and celestial events (sunrise/sunset).
- SerpApi (Google Maps) for discovering actual parks, gardens, and outdoor spaces in the user's vicinity.

Key User Journeys:

The OutThere Moment: Instead of a static dashboard, the home screen changes based on the celestial clock. Whether it's "Golden Hour" or "Stargazing" mode, the app tells you exactly why right now is the best time to be outside.
AI-Curated Exploration: Using a combination of local geospatial data and LLM reasoning, the app suggests the top 3 best places to visit based on current weather (e.g., "It's cloudy, so Ulsoor Lake is a strong sunset candidate").
Outdoor Missions: To gamify the experience, I built a "Mission Generator" that creates structured, low-budget, time-bound adventures (e.g., "The Urban Explorer") to turn a boring walk into a mindful mission. Hyper-Local Discovery via SerpApi To avoid the "generic list" problem, I integrated SerpApi's Google Maps engine. Most apps just search for a city. OutThere uses the user's exact latitude and longitude with a specific 14z zoom level to query for "parks, gardens, and outdoor places." This ensures the results are not just "in the city," but within walking or short-driving distance. The Pipeline: User Location -> SerpApi (google_maps engine) -> Filtered Local Results (Titles, Ratings, Hours, Images) -> Backend Processing.

Gemma AI Reasoning
Raw data from SerpApi is just a list. To make it "smart," I piped this data into Gemma (google/gemma-4-26B-A4B-it).
I implemented a two-stage AI pipeline:

The Recommendation Engine: I pass Gemma the current weather (temp, wind, precipitation) and the list of places. Gemma then acts as a local guide, ranking the places and writing a concise, persuasive reason why that place fits the current weather.
The Mission Builder: A separate prompt architecture that takes user constraints (Time, Budget, Mood) and generates a valid JSON object containing a title and a step-by-step itinerary.

The core magic happens in the interaction between the explore route (fetching raw data) and the recommendations route (AI reasoning).

# Validating that Gemma didn't invent a fake place
valid_names = {place["name"] for place in simplified_places}
validated = []

for recommendation in gemma_recommendations:
    name = recommendation.get("place")
    if name not in valid_names:
        continue  # Reject hallucinated places

    validated.append({
        "place": name,
        "rank": len(validated) + 1,
        "reason": recommendation.get("reason") or "A good nearby outdoor option."
    })

LLMs are prone to hallucinations. To ensure the app never sends a user to a non-existent park, I implemented a Strict Validation Layer. The AI provides the reasoning, but the system cross-references every suggestion against the ground-truth data fetched from SerpApi. If the AI 'invents' a place, the system silently filters it out, ensuring 100% reliability.

places_params = {
    "engine": "google_maps",
    "q": "parks gardens outdoor places",
    "ll": f"@{latitude},{longitude},14z", # Hyper-local zoom
    "type": "search",
    "api_key": SERPAPI_KEY
}

To achieve true hyper-locality, I leveraged SerpApi's ll (latitude/longitude) parameter with a 14z zoom level. This transforms a generic search into a precise geospatial query, ensuring that the suggested 'touch grass' locations are within the user's immediate physical neighborhood, removing the friction of long-distance travel.

Why Does Open Innovation Matter?

Building this with open-weight models like Gemma was a conscious choice. Closed APIs often force you into a "one-size-fits-all" response style. By using an open model, I could:

Control the Output: I implemented strict JSON formatting to ensure the AI-generated missions didn't "hallucinate" and instead integrated perfectly with the React frontend.
Contextual Flexibility: I could tune the temperature and prompts to ensure the "guide" persona felt encouraging and minimalist, not corporate. Open innovation allows us to build tools that encourage us to leave technology, without being beholden to the very ecosystems that try to keep us engaged for as long as possible. Open innovation was central to the "Touch Grass" philosophy of this project. Open innovation allows developers to build specialized, lightweight agents that can be fine-tuned or swapped as better models emerge, ensuring that tools designed to "liberate" users from screens aren't themselves built on proprietary "black boxes."

Prize Categories

Google Gemma — Used Gemma 4 26B as the open-weight AI reasoning layer for recommendations and personalized outdoor missions.
SerpApi — Used SerpApi to discover real nearby outdoor places and events instead of relying on static or manually entered data.
ElevenLabs — Used ElevenLabs to generate the voiceover narration for the OutThere demo video.

I built a bedtime-story generator for my sister and her new baby

Ariba Sayed — Sun, 04 Oct 2026 10:46:03 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

My sister is also my best friend. Back when we were both in college and working, we'd get home exhausted and spend hours on the phone, complaining about everything that went wrong that day.
Then she got married and had a BABYYYYY.
Now, most nights, she falls asleep while tucking the baby in. I don't blame her at all, but I'll be honest: I miss those calls.
So when this challenge said "build for a friend," I knew who it was for. That's how DreamTales happened.
You tell it a few things about your child: their name, age, favourite animal and character, where the story should take place, the mood, and how long you want it. Out comes a bedtime story made just for them. You can pick the language, and you can change the details to get a different story every night. And on the nights you're too tired to read it yourself, an ElevenLabs voice does it for you.
Parents shouldn't have to invent a brand-new story every single night. And maybe a little story can help us stay connected on the nights we can't talk.

Demo

Live Demo :

bedtime-ai.onrender.com

Code

GitHub repo:

ariba-sayed / bedtime-ai

DreamTales turns a child's preferences into a personalized bedtime story using Gemma and brings it to life with ElevenLabs narration.

🌙 DreamTales

DreamTales is a personalized AI bedtime-story companion that creates gentle, imaginative stories based on a child's preferences.

Built for the Hacktoberfest Weekend Challenge: Build for a Friend.

✨ Features

Personalized bedtime stories
Custom child name, favorite animal, character, setting, mood, and story length
AI-generated stories
Optional AI voice narration
Simple, child-friendly interface

🧠 How It Works

The user provides the child's story preferences.
DreamTales creates a personalized prompt.
Gemma generates the bedtime story.
ElevenLabs converts the story into natural-sounding narration.
Render hosts the application.

🌐 LIVE DEMO Try DreamTales Live

🛠️ Tech Stack

Gemma — Story generation
ElevenLabs — Voice narration
Render — Deployment

🚀 Run Locally

Clone the repository git clone YOUR_GITHUB_REPO_URL cd DreamTales
Create a virtual environment python3 -m venv .venv source .venv/bin/activate

On Windows:

.venv\Scripts\activate 3. Install dependencies pip install -r requirements.txt 4. Add environment variables

Create a .env file:

ELEVENLABS_API_KEY=your_api_key_here GEMMA_MODEL=google/gemma-3-1b-it

Never commit your…

View on GitHub

How I Built It

DreamTales runs on Gemma, which writes each story from the child's details and whatever the parent picks.

I didn't want to just hand the model a blank text box. The app asks only for the details that matter and turns them into a careful prompt behind the scenes. That prompt keeps the child and their companions as separate characters with the same names all the way through, writes the entire story in the chosen language, keeps everything gentle with no scary scenes, and ends with a short four-line rhyme so the story finishes on a calm note.

For the voice, I added ElevenLabs, so the story can be listened to in different voices. After a long day, a parent shouldn't have to read one more thing out loud.

It's a Streamlit app hosted on Render. I wanted my sister to be able to open a link and use it, with nothing to install.

Most of my effort went into keeping it simple. A tired parent doesn't need to know anything about prompts or AI settings. Fill in a few boxes, choose the kind of story, and that's it.

Why Does Open Innovation Matter?

I started out with a small Gemma model, but none of the providers I had access to were hosting it. Since Gemma is open-weight, I could switch to a bigger Gemma model on a different provider without redesigning the app or rewriting my prompts.

That freedom matters here. With a children's story app, the hard part isn't getting text out of a model. It's controlling the characters, the tone and what's safe for a kid to hear. An open model let me build around that, instead of bending my idea to fit one company's API.

Prize Categories

Gemma: Gemma powers the personalized bedtime-story generation, turning a few details about a child into an original story designed specifically for their bedtime experience.

ElevenLabs: ElevenLabs brings the generated stories to life through AI narration and different voices, giving parents the option to listen to the story instead of narrating it themselves.

Render: Render hosts the live DreamTales app.