DEV Community: Ujwala Shetty

👻 GhostLog: The Haunted Digital Archive — Turning Computer Logs into Ghost Stories

Ujwala Shetty — Thu, 29 Oct 2026 17:25:42 +0000

What I Built

What if your computer logs were not just records of what happened, but clues to a haunting?

Meet GhostLog — The Haunted Digital Archive, a spooky AI-powered web application that transforms fictional computer logs into eerie ghost stories.

I wanted to build something that combined my interest in AI with the atmosphere of a haunted digital world. Instead of showing ordinary log messages, GhostLog reimagines them as mysterious events and unsettling narratives.

Users can enter fictional computer logs, choose a haunting style and story length, and generate a ghost story. They can then copy the story or click “Hear the Ghost” to listen to it through voice narration.

✨ Key Features

AI-powered storytelling: Turn fictional computer logs into creepy narratives.
Customizable horror: Choose the haunting style and story length.
Voice narration: Listen to the generated story using ElevenLabs.
Dark, spooky interface: A digital archive designed for the Ghost in the Machine theme.
Local AI inference: Generate stories using an open-weight language model running locally through Ollama.

GhostLog explores the idea that even an ordinary digital trace can become the beginning of a mysterious story.

Demo

Demo:https://youtu.be/5c1n62dQcyU

The project currently runs locally. To try it, clone the repository, install the required dependencies, configure Ollama and the narration settings, and launch the Streamlit application.

I haven't deployed a public web demo yet, so the repository is the main project link.

Code

GitHub Repository: github.com/Ujwalashetty18/ghostlog

Tech stack: Python · Streamlit · Ollama · Open-weight LLM · ElevenLabs

The main application is implemented in app.py.

The repository contains the application code and .gitignore. Setup instructions and a dependency file can be added to make it easier for others to run the project.

How I Built It

I built GhostLog as a Python application with Streamlit for the interface.

The main technologies are:

Python — application logic.
Streamlit — interactive web interface.
Ollama — local model inference.
Llama 3.2 3B — open-weight language model for generating ghost stories.
ElevenLabs API — voice narration for the generated stories.
Git and GitHub — version control and source-code hosting.

The workflow is straightforward:

The user enters fictional computer logs.
The user selects a haunting style and story length.
The local language model turns the input into a ghost story.
The generated story appears in the interface.
The user can copy the story or listen to its narration.

One of the most interesting parts was getting the narration feature working. I had to troubleshoot voice configuration and API restrictions before I could hear the generated stories aloud.

Building the project taught me that creating an AI application involves more than connecting a model to a user interface. Configuration, integration, debugging, and testing all matter.

Why Does Open Innovation Matter?

Open innovation made it possible for me to experiment with AI storytelling using a model that I could run on my own computer.

With Ollama and an open-weight model, I could generate stories locally instead of depending entirely on a hosted language-model API. This gave me more control over the development process and helped me experiment without needing a paid hosted LLM service.

It also made the project easier to explore and modify. I can experiment with prompts, change the storytelling logic, and investigate other compatible models as the project grows.

The voice narration currently uses ElevenLabs, so not every component is local. This combination let me explore how local AI generation and an external voice service can work together.

For me, open innovation means having the freedom to experiment, learn by building, and make technology my own.

The Spirit of It 👻

Imagine opening an old computer and finding a log entry that should not exist.

A timestamp in the middle of the night. A process that nobody remembers starting. A message that seems to know something it shouldn't.

What happened?

GhostLog takes that little spark of mystery and turns it into a story.

The part that made the idea exciting for me was hearing a story generated from computer logs spoken aloud. The archive no longer felt like a collection of text. It felt as though something inside the machine had finally found a voice.

That is the spirit of GhostLog: giving a voice to the mysteries hidden in our digital world.

Prize Categories

Best Use of ElevenLabs — for integrating voice narration into the ghost-story experience.

Final Thoughts

GhostLog started as an experiment in combining local AI, storytelling, and voice narration. Along the way, I learned how to build the interface, connect the model, debug API integration, and publish my code on GitHub.

This project is a reminder that AI doesn't have to be only about productivity or solving serious problems. It can also be creative, playful, and a little spooky.

Sometimes, all it takes is a few lines in a log file to wake the ghost in the machine. 👻

devchallenge #hf26challenge #hacktoberfest #ai #python #opensource

🌱 GreenBuddy AI: Your Local AI Companion for Getting Outdoors

Ujwala Shetty — Thu, 22 Oct 2026 14:55:22 +0000

What I Built

GreenBuddy AI is a small AI-powered outdoor activity assistant built to encourage people to spend less time staring at screens and more time exploring the world around them.

Sometimes, we want to go outside but don't know what to do or where to start. GreenBuddy helps solve that problem by suggesting simple activities based on our available time, surroundings, interests, and energy levels.

With GreenBuddy AI, users can:

🌿 Get outdoor activity suggestions for 10, 20, or 30 minutes, or an hour.

🌱 Discover simple gardening activities.

🐦 Explore nature observation and birdwatching.

🚶 Find ideas for a short walk or mindful outdoor break.

🌼 Follow practical, step-by-step instructions for their chosen activity.

The goal is simple: use AI to help people spend less time on their screens and more time in the real world.

Demo

The project currently runs locally.

To try it, clone the repository, install the dependencies, start Ollama with the required Gemma model, and launch the Streamlit app.

Code

🌱 GreenBuddy AI — GitHub Repository

Explore the source code, setup instructions, and implementation here:

View GreenBuddy AI on GitHub

The repository contains the Python application, dependency list, and setup instructions.

How I Built It

I built GreenBuddy AI using Python, Streamlit, Ollama, and Google's open-weight Gemma model.

Technology stack:

Python: Application logic.

Streamlit: Interactive web interface.

Gemma: Generates personalized outdoor activity suggestions.

Ollama: Runs the model locally on the user's computer.

The user selects their available time, surroundings, preferred activity, and energy level. These details are included in a prompt sent to the local Gemma model, which generates a suggested activity with actionable steps and a nature-observation prompt.

Instead of depending on a hosted AI API, the application uses Ollama's local API endpoint to communicate with the model.

Why Does Open Innovation Matter?

Open innovation makes projects like GreenBuddy AI more accessible to developers and users.

By using an open-weight model locally, I can experiment with AI without requiring a paid hosted-model API for the core functionality.

This approach offers several benefits:

More control: I can modify prompts and experiment with different compatible models.

Local processing: The user's activity preferences can be processed on their own computer rather than sent to a third-party hosted AI API.

Accessibility: Developers can build and experiment without paying per-request model API fees.

Learning by building: Running an AI model locally helps me understand how model inference and application integration work.

For this project, open-weight AI isn't just an extra feature. It is the core technology that generates the activity recommendations.

My Agent Session

I don't have a DevRelay agent session to share yet.

Prize Categories

Potential category: Best Use of Gemma.

GreenBuddy AI uses Google's open-weight Gemma model through Ollama to generate outdoor activity recommendations.

What's Next?

I'd like to improve GreenBuddy AI by adding an outdoor activity journal, a daily nature streak, and seasonal gardening suggestions.

Ultimately, I want GreenBuddy to do more than generate recommendations. I want it to help people take small, meaningful steps toward spending more time outdoors.

Thanks for checking out my project! 🌱

ErrorBite: Explain Python Errors Without Leaving Your Laptop 🦥

Ujwala Shetty — Wed, 21 Oct 2026 18:51:39 +0000

What I Built

Have you ever encountered a Python error, copied it into a search engine, opened several tabs, and still struggled to understand what went wrong?

I built ErrorBite, a local AI-powered Python error explainer that helps developers understand errors in plain English.

Instead of spending time searching through documentation and forum posts, users can paste an error message into ErrorBite and get an explanation of:

Plain-English Explanation: What the error means.

Likely Cause: What may have caused it.

Suggested Fix: How to approach fixing it.

Step-by-Step Debugging: What to check next.

The goal is simple: spend less time deciphering error messages and more time writing code.

ErrorBite is built with Python and Streamlit, using a locally running Ollama model for inference. It is a small developer tool with one purpose: make debugging a little less frustrating.

Demo

Live demo: ErrorBite currently runs locally on my laptop.

To try it, the application needs to be running along with Ollama and the configured model. I have not published a public deployment yet.

Demo video: https://youtu.be/eTg6hZ9yMkc

Code

GitHub repository: https://github.com/Ujwalashetty18/-ErrorBite

The project includes the Streamlit interface, an Ollama client, and automated tests for the client.

The test suite currently passes 15 tests.

How I Built It

I built ErrorBite using:

Python for the application logic.

Streamlit for the user interface.

Ollama for local model inference.

Llama 3.2 (3B) as the language model.

pytest for automated testing.

Git and GitHub for version control and sharing the source code.

The application sends the supplied error text to the locally running Ollama API and displays the model's explanation in the Streamlit interface.

I also added automated tests for the Ollama client. The tests run without requiring a live model for every test, helping me check important response and error-handling paths.

My focus was to build something small, understandable, and useful rather than add unnecessary complexity.

Why Does Open Innovation Matter?

For a tool that handles code errors, keeping control over the inference environment matters.

Using a locally run open-weight model means ErrorBite can process error messages on the user's machine instead of requiring every request to be sent to a hosted AI API. This can help reduce exposure of source-code snippets to external services.

It also gives developers more control over the model and inference setup. They can experiment with different supported models without redesigning the entire application.

Local inference does have trade-offs: the user needs to install Ollama, download the model, and have sufficient local computing resources. Also, the model may make mistakes, so suggested fixes should be reviewed rather than blindly executed.

For me, open innovation made it possible to experiment with AI-powered debugging without building the project around a paid, closed-model API.

My Agent Session

I used GitHub Copilot in VS Code to help with development.

Agent session: I haven't published a DevRelay session yet.

The Lazy Payoff 🦥

The payoff is fewer context switches while debugging.

Instead of immediately searching the web whenever an unfamiliar Python error appears, a developer can paste the error into ErrorBite and get an initial explanation in one place.

I haven't measured the actual time saved with users yet, so I won't claim a specific number. The next step is to test it with real debugging tasks and compare the time taken with and without ErrorBite.

Prize Categories

Overall Hacktoberfest Week 3 challenge: Open-source AI — Slow and Steady.

Partner category: Best Use of GitHub Copilot — include this only if the final project and your documented Copilot usage meet the category requirements.

Built as part of Hacktoberfest 2026. One error at a time, a little less debugging pain. 🦥

devchallenge #hf26challenge #python #ai #opensource

SideHustle AI: Turning Client Briefs into Freelance Project Plans with Llama 3.2

Ujwala Shetty — Tue, 13 Oct 2026 16:11:33 +0000

This is my submission for the Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle.

What I Built

I built AI Side-Hustle Assistant, an AI-powered tool that helps freelancers turn client requirements into structured project plans.

Freelancers often receive incomplete project briefs, unclear deadlines, and uncertain budgets. Planning everything manually can be difficult, especially for beginners.

My application helps freelancers organize project requirements and prepare before starting development.

It generates:

Project overview and proposal
Deliverables and task breakdown
Estimated timeline and budget in INR
Questions to clarify with the client
Scope risks with severity and explanations
Optional recommendations
A downloadable JSON project plan

The goal is to make project planning easier for freelancers and small businesses.

Demo

Watch the demo video of my application:

https://youtu.be/VlCcoCxGpG0

Code

The complete source code and setup instructions are available in my GitHub repository.

Ujwalashetty18 / ai-side-hustle-assistant

AI-powered freelance project planner using Python, Streamlit, and Ollama.

💡 AI Side-Hustle Assistant

An AI-powered freelance planning tool that transforms client requirements into a project proposal, task breakdown, estimated budget, and scope risk analysis.

Built with Python, Streamlit, and Ollama, using the open-weight Llama 3.2 model locally.

✨ Features

AI Project Proposal: Generate a professional proposal from a client's brief.
Task Planning: Break projects into practical tasks and estimated workdays.
Budget Estimation: Calculate an estimated budget in Indian rupees from task-level costs.
Scope Risk Checker: Identify uncertainties such as vague deadlines, changing requirements, and missing budget details.
Client Clarification Questions: Suggest questions to ask before accepting a project.
Optional Recommendations: Separate extra ideas from required deliverables.
Project Plan Export: Download the generated plan as a JSON file.

🛠️ Tech Stack

Python
Streamlit
Ollama
Llama 3.2 (3B)
Requests

⚙️ Prerequisites

Install Python and Git. Install Ollama and download the model:

ollama pull llama3.2:3b

🚀 Run Locally

Clone the repository:

…

View on GitHub

Repository: https://github.com/Ujwalashetty18/ai-side-hustle-assistant

How I Built It

I built this application using Python, Streamlit, Ollama, and the Llama 3.2 3B model.

The user enters a project name and client requirements. The model generates structured project-planning content, including a proposal, tasks, client questions, and potential scope risks.

Python handles the application workflow, displays the results, and calculates task and budget estimates. Streamlit provides the user interface, while Ollama runs the language model locally.

I also added a JSON export feature so users can download their generated project plans.

Why Does Open Innovation Matter?

Open-weight AI models make it easier for developers to experiment, customize applications, and build useful tools without relying entirely on proprietary hosted AI APIs.

This project uses Llama 3.2 through Ollama for local inference. When the application runs entirely locally, client briefs can remain on the user's machine rather than being sent to an external AI service.

Building this project helped me explore how open-weight AI can support freelancers and small businesses with everyday project-planning challenges.

My Agent Session (Optional)

I used Ollama with the local Llama 3.2 3B model. I did not use DevRelay for this project.

My First User (Optional)

I tested the application locally using sample client briefs. I have not yet confirmed use by a real client, so I am not claiming real-world customer results.

Prize Categories

I am submitting for the overall Hacktoberfest Open-Source AI Challenge. I am not claiming a partner-specific prize category.

Thank you for checking out my project!