DEV Community: Abhishek Singhania

Ghost in the Machine: Keep Family Stories Alive with Local AI 👻

Abhishek Singhania — Tue, 27 Oct 2026 14:54:20 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

I built Ghost in the Machine, a local-first oral-history archive designed to help preserve family stories and memories before they are lost.

The idea is simple: a person's voice can hold memories that never make it into a diary or a photo album. This project gives those stories a place to live, while keeping the workflow focused on preserving what people actually said rather than inventing or impersonating them.

The application lets users:

1.Record a story or upload an audio recording.

2.Transcribe speech using an open-weight Whisper model through faster-whisper.

3.Review and edit the transcript before saving it.

4.Add a story title, date, and tags.

5.Search saved memories and export individual stories or the full archive as JSON.

6.Try a fictional sample story without uploading personal recordings.

The application is designed to run on the user's own computer. Its archive is a simple JSON file, making the data format easy to inspect and back up.

Demo

Try Ghost in the Machine here:
https://ghost-in-the-machine-exh72mtphvwp8iwk96lovq.streamlit.app/

Code

GitHub repository:
https://github.com/godGamerz812/Ghost-in-the-Machine

The repository includes the Streamlit interface, story archive helpers, dependency files, automated tests, GitHub Actions workflow, and MIT license.

How I Built It

The project uses:
1.Python for the application and archive logic.
2.Streamlit for the interactive interface.
3.Whisper with faster-whisper for open-weight speech transcription.
4.JSON for saving and exporting stories.
5.Pytest and GitHub Actions for automated checks.

The speech model is loaded on the machine running the application. Its weights may need to be downloaded on first use; once cached, transcription can run locally without sending audio to a hosted AI API.

The automated checks cover the archive logic and application startup across Python 3.10, 3.11, and 3.12. They do not establish transcription accuracy with real audio, so the model's end-to-end behavior still needs to be checked with a suitable recording.

Why Does Open Innovation Matter?

A memory archive should not depend on a proprietary AI service being available forever.

Using an open-weight model and an inspectable codebase makes this project easier to study, adapt, and run independently. Developers can examine how stories are stored, choose a model size that fits their hardware, and improve the application without depending on a closed AI API.

There is also an important privacy boundary: local processing means running the app on your own machine. A cloud-hosted demonstration is convenient for showing the interface, but it is not a substitute for local handling of sensitive recordings.

The Spirit of It

A family story can feel like a ghost: still present in someone's memory, but gradually fading when nobody records it.

I wanted to build something that helps people preserve those stories without turning them into synthetic versions of the people who told them. The goal is to keep the original words, give them context, make them searchable, and let families carry them forward.

This is an early prototype, not an encrypted digital vault. Transcripts can contain mistakes, and anyone with access to the archive file may be able to read it. The intention is to make preservation more accessible while being honest about the care personal memories require.

abhishek_singhania_e3a2cd

SlothSort AI: A Safer Way to Tidy Up Your Files

Abhishek Singhania — Tue, 20 Oct 2026 01:26:10 +0000

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

What I Built

SlothSort AI is a safety-focused file organization assistant built with Python and Streamlit. It helps users categorize files into groups such as Documents, Images, Videos, and Archives.

Instead of immediately moving or deleting files, SlothSort AI displays suggested categories first, allowing users to review the proposed organization before taking any action.

The project includes a simple web interface, reusable categorization logic, automated tests, and GitHub Actions checks. It also includes an optional integration path for Ollama and open-weight AI models.

⏱️ The Problem and Potential Time Savings

Manually sorting downloads, documents, images, recordings, and archives can become repetitive and time-consuming.

SlothSort AI aims to reduce this effort by suggesting categories automatically. I have not yet measured actual time savings, so I am presenting this as the project's intended benefit rather than a verified result.

Demo

Try SlothSort AI here:

https://slothsort-ai-4ctucnjvgaqubsivd3kore.streamlit.app/

The live demo includes sample filenames and displays suggested categories. The starter version previews suggestions without moving or deleting files.

Code

GitHub repository:
https://github.com/godGamerz812/SlothSort-AI

The repository includes the Streamlit application, categorization logic, tests, setup instructions, and a GitHub Actions workflow.

How I Built It

Python: Core categorization logic.
Streamlit: Interactive web interface.
File extensions: Fallback categorization for common file types.
Pytest: Automated tests for the categorization logic.
GitHub Actions: Automated Python checks.
Ollama / open-weight AI models: An optional integration path that still needs successful end-to-end inference testing.

I tested the deployed interface with sample filenames and confirmed that the expected categories appear. The optional AI inference has not yet been verified.

Why Does Open Innovation Matter?

Open-source development makes useful tools accessible, inspectable, and adaptable. By sharing SlothSort AI publicly, I hope other developers can explore its implementation, contribute improvements, add new file categories, and help develop a more capable privacy-conscious organization assistant.

The project is designed around a review-first workflow: users should understand the proposed organization before files are changed.

My Agent Session

I used AI assistance during development to help plan the project, build and refine the application, and work through implementation and testing tasks. The repository and deployed demo provide the current project artifacts.

I have not included a DevRelay session recording or claimed successful Gemma/Ollama inference because those have not been verified.

The Lazy Payoff

The goal is simple: spend less time deciding where files belong and more time doing meaningful work.

SlothSort AI is an early, working starter project. Future improvements could include better content-aware categorization, configurable rules, additional file types, and a tested local AI workflow.

Prize Categories

Best Use of Gemma

Abhishek Singhania

PocketLedger AI: Private Expense Management with Open-Source AI

Abhishek Singhania — Wed, 14 Oct 2026 09:45:49 +0000

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

What I Built

PocketLedger AI is a lightweight expense organizer designed for freelancers, tutors, creators, and small businesses. It helps users record expenses, categorize transactions, review monthly spending, and export their records to CSV.

The application supports categorization through an open-weight model served by Ollama, with a transparent rules-based fallback when the model is unavailable.

Demo

https://pocketledger-ai-emv2vdb45nposflpkyt7gw.streamlit.app/

Code

https://github.com/godGamerz812/PocketLedger-AI

How I Built It

I built PocketLedger AI using Python and Streamlit, with Pandas for expense records and monthly summaries. The optional model integration uses Ollama to connect to an open-weight language model. The app also includes a rules-based fallback, CSV exports, automated tests, and a GitHub Actions workflow.

Why Does Open Innovation Matter?

Open-weight AI gives users greater control over model choice, deployment, privacy, and cost. By supporting Ollama, PocketLedger AI can use a model on infrastructure controlled by the user rather than requiring a closed, hosted AI API.

The open-source implementation allows developers to inspect, modify, and extend the project. Its transparent fallback also makes basic expense categorization usable when a model is not available.

My Agent Session

My First User

My first user is me. I built and tested PocketLedger AI to explore how a lightweight expense tracker can help organize daily spending, categorize expenses, and generate monthly summaries. My next step is to get feedback from freelancers or students who want a simple way to manage their expenses.

No paying customer yet — the goal is to validate the idea with real users and improve the app based on their feedback.

Prize Categories

Best Use of Gemma: PocketLedger AI supports optional expense categorization using the Gemma open-weight model through Ollama. The goal is to help freelancers and small businesses organize expenses while retaining greater control over where their data is processed.

Abhishek Kumar

Thanks for participating in Hacktoberfest 2026!

devchallenge #hf26challenge

PlantCare Adventure AI

Abhishek Singhania — Tue, 06 Oct 2026 14:15:01 +0000

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

What I Built

I built PlantCare Adventure AI, an open-source AI companion designed to get people off the screen and into the real world.

The app asks for the user's location/environment and preferences, suggests outdoor activities, generates a short outdoor mission, and gives the user things to look for while outside.

It also provides an offline adventure checklist and lets users record observations, photos, and notes before creating a small Adventure Journal.

Demo

GitHub Repository: https://github.com/godGamerz812/Plant-Care-AI

Code

GitHub Repository: https://github.com/godGamerz812/Plant-Care-AI

How I Built It

I built the project using Python and Streamlit, with Gemma as the open-source AI model integration.
The app asks for:

Location/environment
Outdoor activity preference
User preferences It then creates a practical outdoor mission and suggests things to look for while exploring. The project also includes a local fallback so the basic outdoor experience can work without a configured remote Gemma endpoint. The goal is to make the AI interaction short and useful, then encourage the user to put the phone away and actually go outside.

Why Does Open Innovation Matter?

Open-source AI makes it possible for developers to experiment with AI without depending completely on closed APIs.
For this project, Gemma makes it possible to build an AI experience focused on outdoor exploration, observation, and digital wellbeing.
Instead of encouraging users to spend more time chatting with AI, this project uses AI to encourage users to spend more time in the real world.

Prize Categories

I am entering:

Best Use of Gemma

The project uses Gemma to generate personalized outdoor activities and observation missions.

@godGamerz812

Thanks for participating in Hacktoberfest 2026 and for the Touch Grass challenge! 🌿

I Built DostStudy, a Private AI Study Buddy for a Classmate

Abhishek Singhania — Sun, 04 Oct 2026 20:23:42 +0000

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

What I Built

I built DostStudy, a private AI study buddy designed around a common
problem faced by a college student: difficult textbook explanations can
take too long to understand.

DostStudy turns a study question into a simpler explanation and can also
summarize material or generate a quick quiz.

The interface supports English, Hindi, and Hinglish so the learner can
choose the explanation style that feels most natural.

Demo

GitHub repository:
https://github.com/godGamerz812/doststudy

Demo video:
https://youtube.com/shorts/WfbHxrnq8AE?si=ITySnc1B8-Ssphwq

Code

Source code:
https://github.com/godGamerz812/doststudy

How I Built It

DostStudy uses:

Gemma 3 as the open-weight AI model
Ollama for model serving
Python for application logic
Streamlit for the user interface

The application is built around the AI model rather than using AI as an
optional add-on.

Why Does Open Innovation Matter?

Open innovation matters because the AI model is not locked behind one
closed provider.

DostStudy can use an open-weight model through Ollama, which gives the
project more control over the model and how it is run.

For a study application, local inference can also be valuable because
study material does not have to be sent to a third-party AI API when the
model is running locally.

The model can be swapped, the prompts can be changed, and the application
can be adapted without rebuilding the entire product around a single
closed API.

That flexibility is the main reason open AI was important to this project.

My Agent Session

Prize Categories

Best Use of Gemma

Thanks for participating!

Happy to join Hactoberfest

Abhishek Singhania — Fri, 02 Oct 2026 15:18:49 +0000

Hello @ I'm