DEV Community: AMAN BASOR

Week-4 DEV challenge

AMAN BASOR — Sat, 31 Oct 2026 18:25:29 +0000

What I Built

I built the 🎃 Horror Story Generator — a fully browser-based web app that lets you craft personalized, spine-chilling horror stories powered by Google’s open Gemma models via the Gemini API.

The “Ghost in the Machine” theme hit me immediately: what if the machine itself became the storyteller? What if you could whisper a few details into it — a name, a place, a face — and it breathed life into your worst nightmare? That’s the ghost: an intelligence hiding inside your browser, conjuring darkness on command.

You give it characters (with names and descriptions you define), choose a creepy setting like “an abandoned hospital” or “a fog-drenched village”, pick how long you want the terror to last, and hit 🕯️ Generate Horror Story. Then you watch the story stream out token by token — like something typing at you from the other side.

Features:

🔍 Auto-detection of Gemma models — pastes your API key and the app queries the Gemini API live, ranking and pre-selecting the best available Gemma model (prefers gemma-3-27b-it down to gemma-3-1b-it)
🧑‍🤝‍🧑 Custom characters — add, edit, or remove characters with names and descriptions
📏 Story length control — Short (~200 words) to Epic (~2000 words)
🏚️ Custom setting — you define the atmosphere
⌨️ Real-time streaming — SSE streaming so the story types itself out with a blinking cursor
🎨 Full horror aesthetic — floating red ember particles, Creepster typography, deep dark UI
Code

link - https://github.com/amanbasor/horror-story-generator

How I Built It

The project is built entirely with vanilla HTML, CSS, and JavaScript — zero frameworks, zero build tools, zero dependencies to install. Just open index.html and it works.

The open-source AI at the core: Google Gemma

Gemma is Google’s family of open-weight models derived from the same research behind Gemini. They’re open — you can run them locally with tools like Ollama or LM Studio, inspect their weights, fine-tune them, and deploy them however you want. In this app, I use them through the Gemini API (which gives free-tier access), but the model itself is open-weight.

How the AI integration works:

Model discovery — On API key input, the app hits generativelanguage.googleapis.com/v1beta/models and filters for Gemma models that support generateContent, then ranks them by capability (27B → 12B → 4B → 1B) and auto-selects the best one available to you.
Prompt engineering — A structured prompt is built from the user’s characters, setting, and length preference. It instructs Gemma to write with suspense, realistic dialogue, vivid sensory detail, and an unsettling twist — and to lead with a creative horror title.
Streaming via SSE — The app calls models/model, reads the response body as a ReadableStream, decodes SSE events chunk by chunk, and renders each token to the story box in real time — complete with a blinking cursor while it’s typing.
GitHub Copilot assisted throughout the development — helping autocomplete event handler logic, refine the SSE parsing loop, and suggest CSS animation keyframes for the particle system and streaming cursor.

Stack:

HTML5 / CSS3 / Vanilla JS (ES2020+)
Fetch API + ReadableStream (for SSE)
Google Gemini API (models.list + streamGenerateContent)
Gemma open-weight models (auto-detected)
Google Fonts (Creepster for the horror title, Inter for body)
Why Does Open Innovation Matter?

A closed API would have handed me one model, at one price, with no insight into what’s running under the hood.

Open Gemma changed the entire shape of what I built:

Model flexibility without a rewrite. Because Gemma models are queryable and openly listed, I could write a live auto-detection system. The app doesn’t hardcode a model name — it asks the API “what Gemma models do you have?” and adapts. A closed system would never let me do that; I’d be locked to whatever name the provider exposes.
Free-tier access with open-weight backing. The free Gemini API tier gives access to Gemma models. That meant I could build and ship this without spending a rupee. A closed GPT-4 equivalent would have made this project financially inaccessible for a student building on weekends.
Trust and transparency. When the story takes a dark, creative turn, I know the family of model behind it. Open weights mean the research community can audit, fine-tune, and understand the model’s behavior. That matters for creative tools where you want predictable, imaginative (not harmful) output.
Local inference as the future escape hatch. Right now the app uses the cloud API — but because Gemma is open-weight, a user could swap the endpoint to a local Ollama instance running gemma3:27b and the app would work identically, completely offline. That’s only possible because the model isn’t locked behind a proprietary wall.

Open innovation didn’t just make this cheaper. It made it architecturally better — more adaptive, more transparent, and more future-proof.

The Spirit of It

The first time I tested the finished streaming feature, I typed in two characters — Anya (a curious college student) and Mr. Hollow (a mysterious old caretaker) — set the location to “an abandoned university library after midnight”, and hit generate.

I watched the title appear first: “The Catalogue of Lost Souls”

Then the story started typing itself. Sentence by sentence. A flickering light. Footsteps on the floor above. Anya finding a book with her own name on the spine — dated 1987.

Nobody was in the room with me. It was past 1 AM. And for a second — just a second — I genuinely didn’t want to scroll down to see how it ended.

That’s the ghost in the machine. It was there the whole time.

Prize Categories
Gemma — The app is built around Google’s open Gemma models as its AI core, with live model auto-detection, capability-ranked model selection, and SSE-streamed story generation using Gemma via the Gemini API.
GitHub Copilot — GitHub Copilot was used throughout development to assist with JavaScript logic, SSE stream parsing, and CSS animations, accelerating the build significantly.

WEEK 3 CHALLENGE

AMAN BASOR — Sat, 24 Oct 2026 09:49:32 +0000

Here is a complete template tailored for your DEV post submission for Hacktoberfest Week 3 (Slow and Steady).

*This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady*

What I Built

Turtle Steady is an interactive, low-stress daily productivity companion designed to turn overwhelming task lists into manageable, bite-sized steady steps.

Instead of overwhelming you with long, stressful to-do lists, Turtle Steady pairs intelligent task decomposition with lightweight Gemini-powered guidance to help users pace themselves, avoid burnout, and accomplish goals "slow and steady." It saves time and cognitive effort by automatically breaking down broad project objectives into small, actionable sub-tasks.

Anyone who struggles with executive dysfunction, task paralysis, or workplace burnout gets to be a little lazier—and much more effective—because of it.

Code

amanbasor / WEEK-3

🐢 Slow & Steady — Minimalist Cadence Companion

"Nature does not rush, yet everything is accomplished." — Lao Tzu

Slow & Steady is an unhurried, minimalist web application built to counteract hurry sickness, overcommitment, anxiety, and burnout. Inspired by the age-old truth that slow and steady wins the race, this app champions tiny, deliberate daily compounding actions over frantic sprints.

The intelligence is powered by Google Gemma open models (gemma-2-9b-it & gemma-2-27b-it) hosted on the Google Gemini API, crafted in a minimalistic white and shades of red visual language.

🎨 Design Philosophy & Color Palette

The entire interface strictly adheres to a minimalist aesthetic using white and shades of red:

Pristine Whites (#FFFFFF, #FFFBFB, #FFF1F2): Evokes breathability, quiet space, and calm clarity.
Deep Burgundy / Wine (#4C0519, #340913): Ensures crystal-clear typographic contrast without harsh jet-blacks.
Crimson…

View on GitHub

How I Built It

Backend: Python (app.py), integrating Google Gemini API (gemini_client.py) for AI orchestration and structured task breakdown.
Frontend: Clean, responsive UI built with vanilla JavaScript (static/app.js), HTML5 (static/index.html), CSS3 (static/styles.css), and custom SVG assets (turtle-steady.svg).
Environment & Config Management: Secured local environment configuration utilizing .env files and .steady_config.json for custom behavior parameters.

The application leverages open-source AI frameworks and agentic reasoning patterns to parse user inputs, calculate optimal task pacing, and maintain local user activity history inside user_data.json.

Why Does Open Innovation Matter?

Open innovation and open-weight AI ecosystems allow developers to build transparent, privacy-respecting agents without lock-in to rigid proprietary platforms.

For a daily productivity assistant like Turtle Steady:

Local Control & Privacy: Users retain full control over personal data (user_data.json) and task schedules without sending sensitive work patterns into closed black-box models.
Custom Adaptability: Open standards allow seamless integration across lightweight backends (Python/Flask) and custom client-side frontends without restrictive API wrappers or hidden costs.

My Agent Session

You can view the full agent development session and coding workflow here: DevRelay Session / Log Link

The Lazy Payoff

Before Turtle Steady, planning out a 5-day project meant spending 30–45 minutes manually organizing schedules and breaking down sub-tasks. Turtle Steady automates this entire planning loop in under 3 seconds.

By taking care of the mental overhead of project scoping, it frees up focus for execution—saving roughly 3–5 hours of setup time every week.

Prize Categories

Main Track: Open-Source AI Challenge Week 3: Slow and Steady
Google Gemma / Open AI Partner Tracks *

Week 2 GHW Dev challenge

AMAN BASOR — Tue, 13 Oct 2026 15:55:49 +0000

Hacktoberfest 2026 Week 2: Side Hustle — Menu Translator

What I Built

I built a web-based Menu Translator as part of the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

The project is designed around a simple idea: helping users understand restaurant menus that may be written in a language they do not understand. The interface includes an option to upload a menu image and a text input area, providing a starting point for making menu information easier to access.

My goal with this project is to explore how web development and AI-powered language tools can help solve practical, everyday problems.

Demo

Live Demo: Not deployed yet.

Code

GitHub Repository: https://github.com/amanbasor/week-2-ghw---restaurant-app.git

How I Built It

I developed the project as a web application with a mobile-friendly interface. The current interface includes a menu image upload area and a text input section.

The project focuses on making the interaction straightforward so users can provide menu information through an image or text.

Technologies used: HTML, CSS, and JavaScript, subject to confirmation against the complete project source.

The next step is to verify and complete the translation workflow and connect an appropriate AI or translation model if it is not already integrated.

Why Does Open Innovation Matter?

Open innovation makes it possible for developers to learn from one another, share ideas, and build on existing work rather than solving every problem from scratch.

Open-source challenges such as Hacktoberfest provide an opportunity to experiment with new technologies, improve development skills, and contribute to a community-driven ecosystem.

For me, this project is an opportunity to practise building a practical application and explore how language technology can make information more accessible.

My Agent Session (Optional)

Not included.

My First User (Optional)

Not included yet.

Prize Categories

Side Hustle — Hacktoberfest Open-Source AI Challenge Week 2.

thank you

Planti-Fier

AMAN BASOR — Sun, 11 Oct 2026 16:49:37 +0000

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

What I Built

PLANTI-FIER is a web app that identifies plants from a photo. You upload a picture and it returns the plant's scientific name, common names, a confidence score, the regions where it grows naturally, and search links to find it online.

It gets people off the screen by turning a walk into a curiosity game. Instead of walking past an unknown plant, you stop, photograph it and learn its name. You can then look at it, smell it and find out where else in the world it grows. The app is built so the AI step takes seconds and the real world does the rest.

It is for hikers, gardeners, students, curious kids and anyone who has ever wondered "what is that plant?" It includes a disclaimer: "It is AI used to identify and not sell any product."

Demo

🔗 Live app: https://amanbasor.github.io/planti-fier/

Open the link, paste your own API key into the API_KEY field, upload a plant photo and click Identify plant.

Code

🔗 GitHub: https://github.com/amanbasor/planti-fier

It is a single index.html file with plain HTML, CSS and JavaScript, so there is no build step and no framework. There are no private files or secrets in the repo.

How I Built It

Open-weight AI: the app calls Google's Gemma models through the Gemini API. It asks the API which models your key can use, picks Gemma models first, and falls back to Gemini models only if Gemma isn't available on that key. The page shows which model produced each answer.
Flow: the photo is read in the browser and converted to base64. The image and a prompt that asks for strict JSON go to the model. The reply is parsed and shown as result cards.
Bring your own key: the user pastes their own key into the API_KEY field. It stays in the browser and is not stored in the code or the repo.
UI: the styling is inspired by Pl@ntNet Identify, with a green palette, a hero banner and rounded cards.
Hosting: GitHub Pages.
Shopping links: these are search URLs built from the scientific name, so the app does not sell anything or pick a seller.

I built it with AI assistance, in a loop of describing the app, testing it and fixing errors. One real bug was a hard-coded model name that stopped working, which is why the app now discovers available models on its own.

Why Does Open Innovation Matter?

No lock-in: model names change and models get retired. My app broke once because a fixed model became unavailable. Because it works with several models, it adapts instead of dying.
Accessibility: a student can build and host a working AI app for free, with their own key and no backend.
Trust and inspection: plant identification can affect real decisions, such as foraging. Open-weight models and open code let people inspect, question and improve how the tool behaves.
Room to grow: the same design could run a small open model locally, so identification would work on a trail with no signal. A closed API makes that path much harder.

AI plant identification can be wrong, so please never eat or use a plant based only on an AI result.

DEV Community: AMAN BASOR

Week-4 DEV challenge

WEEK 3 CHALLENGE

What I Built

Code

amanbasor / WEEK-3

🐢 Slow & Steady — Minimalist Cadence Companion

🎨 Design Philosophy & Color Palette

How I Built It

Why Does Open Innovation Matter?

My Agent Session

The Lazy Payoff

Prize Categories

Week 2 GHW Dev challenge

Hacktoberfest 2026 Week 2: Side Hustle — Menu Translator

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session (Optional)

My First User (Optional)

Prize Categories

Planti-Fier

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

Prize Categories

INNOVATE

devchallenge

hf26challenge.

Hello ! I am new to this community