DEV Community: Shaurya Aryan

The Last Commit 👻: A Haunted Code Archaeologist Powered by Open-Weight AI

Shaurya Aryan — Mon, 26 Oct 2026 20:26:15 +0000

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

Every codebase leaves a trace. Some refuse to disappear. 👻

What I Built

Meet The Last Commit — a haunted code archaeologist that uses open-weight AI to help developers understand forgotten code, investigate potential bugs, and breathe new life into legacy snippets.

The idea came from a familiar developer experience: opening an old file, discovering a strange function, and wondering why anyone wrote it that way in the first place.

Instead of treating legacy code analysis like another ordinary chatbot interaction, I wanted to turn it into an investigation inside a mysterious, retro-futuristic computer system.

The result combines practical AI-powered code analysis with a cinematic horror atmosphere inspired by haunted CRT terminals, digital ghosts, and the feeling that an old program still has something to say.

Three ways to investigate forgotten code

🕯️ Séance Mode

Summon the fictional spirit of a code snippet. It narrates what the code used to do while providing a grounded technical explanation of its behaviour, assumptions, and missing context.

🩸 Autopsy Mode

Investigate potential bugs, deprecated patterns, security concerns, error-handling gaps, and other maintenance risks. Findings are presented with explanations and suggested next steps, rather than simply declaring code broken.

⚡ Resurrection Mode

Give an old snippet a fresh start. Generate a proposed modernized version, understand the changes, and review compatibility caveats and suggested tests before using it.

The Forgotten System — a playable Matrix terminal

The experience extends beyond the code-analysis workspace.

The Forgotten System features an interactive Matrix-style terminal with falling characters, pointer-reactive ripples, spectral signals, and a Code Graveyard where developers can discover old code fragments and send them into the AI workspace for further analysis.

The terminal includes configurable animation performance and optional retro-computer ambience, creating an interactive Halloween atmosphere without making the developer tools themselves unusable.

A personal archive

The Archival Vault stores selected analysis sessions in the browser, letting developers revisit previous investigations, search saved records, copy reports, and download Markdown artefacts.

The project never executes submitted code. It analyses the snippet as text, keeping the experience focused on explanation and static inspection.

Demo

👻 Enter The Last Commit — Live Demo

Explore the haunted terminal, investigate a code snippet, and see what the ghost has to say.

Code

💻 Explore the source code on GitHub

The repository includes the application source, server-side model integration, tests, configuration examples, and setup documentation.

How I Built It

I built The Last Commit using Google AI Studio Build mode, React, TypeScript, Vite, Tailwind CSS, Node.js, Express, and the official @google/genai SDK.

The AI component uses Google's open-weight Gemma 4 model, configured as gemma-4-26b-a4b-it.

The application sends code snippets to a server-side endpoint, which requests structured analysis from the configured model. The frontend then presents the response in one of the three analysis modes.

I kept the interactive Matrix renderer separate from the AI service. The falling characters, pointer interactions, visual effects, and animation controls run in the browser; they do not require an AI request for every frame.

Saved investigations use browser localStorage, so a remote database or user account is not required for the current version.

Why Does Open Innovation Matter?

A tool that analyses code should not have to be permanently tied to one closed model or one fixed way of interpreting software.

Using an open-weight model gives developers the opportunity to inspect the published model and its applicable licence, experiment with prompts and analysis workflows, and explore alternative inference environments as the project evolves.

Gemma is central to the analysis rather than an optional chatbot added to the interface. It provides the reasoning and language-generation component behind the explanations, potential findings, and modernization suggestions.

There is an important distinction in the current implementation: The Last Commit uses hosted inference through the Gemini API. Submitted source code is sent to the model provider for analysis, and the current deployment is not an entirely offline application. Saved reports remain in browser storage, but this does not mean inference happens locally.

The separation between the model service, the browser interface, and the local archive leaves room to experiment with self-hosted inference in environments where keeping source code on a local machine is a requirement.

For me, open innovation is not just about using a different model. It is about having room to understand, adapt, and eventually change the technology behind the tools we build.

The Spirit of It 👻

Halloween seemed like the perfect excuse to give an ordinary developer problem a slightly unsettling personality.

Old code often feels haunted: unexplained decisions, forgotten dependencies, strange behaviours, and functions nobody remembers writing. The Last Commit turns that feeling into an interactive experience while keeping the underlying goal practical.

The ghost is fictional. The code investigation is real work for the AI to assist with.

This is an early version, and I intend to keep improving it beyond Hacktoberfest — exploring better analysis, more useful developer workflows, and alternative ways to run open-weight models.

Every codebase leaves a trace. This one just happens to whisper back.

SlothPlate 🦥: Let Open-Weight AI Handle Your Meal Planning

Shaurya Aryan — Mon, 19 Oct 2026 22:39:28 +0000

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

What I Built

Meet SlothPlate 🦥 — a low-effort meal-planning assistant that helps you spend less time deciding what to cook.

We've all opened the fridge, stared at a few random ingredients, and still had no idea what to make. SlothPlate tackles that everyday problem by turning the ingredients you already have into simple meal ideas and a consolidated grocery list.

Here's how it works:

Scan your fridge: Upload a fridge or pantry photo, or enter ingredients manually. AI helps identify the ingredients, which you can review and correct.
Get easy meal ideas: Generate three meal suggestions based on your available ingredients, cooking time, and effort preferences.
Generate your grocery list: Select the meals you like and combine their missing ingredients into one organised shopping list.
Save your plans: Keep meal plans and grocery lists in your browser so you can return to them later.

The goal is simple: fewer repetitive decisions, less unnecessary shopping, and more time for everything else.

Demo

🌿 Try SlothPlate — Live Demo

Code

💻 View SlothPlate on GitHub

How I Built It

I built SlothPlate using Google AI Studio Build mode, React, TypeScript, and a Node.js backend.

The application uses Google's open-weight Gemma 4 model through a server-side API integration. Gemma powers the ingredient-analysis and meal-generation workflow, helping transform a list of available ingredients and user preferences into structured meal suggestions.

The shopping-list logic runs in application code, consolidating ingredients from the selected recipes rather than relying on the AI to perform every calculation.

I also implemented browser-based storage for saved plans, keeping the first version simple without requiring accounts or a separate cloud database.

Why Does Open Innovation Matter?

I wanted to build something where open-weight AI performs a useful task rather than simply adding a chatbot to an application.

Gemma gives SlothPlate an open-weight model foundation that developers can inspect, adapt, and explore in alternative inference environments. It also keeps the model integration separate from the main application logic, making future experimentation with other compatible models possible.

The current version uses hosted inference, so AI generation requires an internet connection and submitted images or ingredient information are sent to the model provider for processing. Saved plans are stored in the browser's local storage; the application does not currently provide fully local AI inference or cloud synchronisation.

That distinction matters: open-weight models create opportunities for more control and adaptability, but privacy and offline operation depend on how the model is deployed.

For this version, I focused on making the experience practical and easy to use while leaving room to explore local inference and further improvements later.

SlothPlate is my attempt to make an everyday task a little less tedious. Sometimes, the smartest productivity tool is simply the one that saves you from having to think about dinner again. 🌿

ScopeMate: An Open-Weight AI Assistant to Protect Freelancers from Scope Creep

Shaurya Aryan — Tue, 13 Oct 2026 21:34:05 +0000

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

What I Built

ScopeMate is an AI-powered scope and quote assistant designed for freelancers who want to spend less time managing vague client requirements and more time doing the actual work.

A simple client request can quickly turn into an unclear project, unrealistic expectations, or endless additional requests. ScopeMate helps freelancers turn those rough briefs into structured project proposals with clear deliverables, exclusions, assumptions, milestones, and clarification questions.

It includes three core capabilities:

AI-powered proposals: Turn rough client briefs into structured, editable project scopes.
Deterministic quote calculations: Build estimates using editable line items, rates, hours, discounts, and other supported pricing options. The application calculates totals instead of relying on AI-generated arithmetic.
Scope Change Analyzer: Compare a new client request with a saved project scope, identify potential additional work, and draft a professional response.

Projects can be saved locally in the browser, reopened, edited, and used again when analyzing new client requests.

The people I built this for are freelance developers, designers, writers, and other independent professionals who need a simple way to define work and communicate changes to clients.

Demo

Try ScopeMate — Live Demo

Code

ScopeMate GitHub Repository

How I Built It

I built ScopeMate using Google AI Studio Build mode, React, TypeScript, and a Node.js/Express backend.

The AI features use Google's open-weight Gemma 4 model through a server-side API integration. The model helps interpret client briefs, propose project scopes, and assess new requests against existing requirements.

I kept quote calculations in application code so that financial totals are deterministic and can be edited by the freelancer.

For the first version, I used browser localStorage to keep project history simple, without requiring user accounts or a cloud database.

Why Does Open Innovation Matter?

Freelancers need tools they can adapt to their own workflows rather than being locked into one proprietary AI model or product ecosystem.

Using an open-weight model such as Gemma gives ScopeMate a foundation that developers can inspect, adapt, and potentially run through alternative inference setups as the project evolves.

The current version uses hosted inference, so AI generation requires an internet connection and the relevant client brief is sent to the model provider for processing. I am not claiming that the current application runs its AI entirely locally or guarantees that client data never leaves the device.

The goal is to demonstrate how open-weight AI can support a focused, practical business tool, while keeping important operations such as quote calculations deterministic and giving the freelancer control over the final scope and client communication.

ScopeMate is an early version, and I plan to continue improving it beyond the challenge.

GullyGames 🌿: Less Screen Time, More Real-World Play with Open-Weight AI

Shaurya Aryan — Sat, 10 Oct 2026 12:58:24 +0000

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

What I Built

GullyGames is an AI-powered app that creates short, collaborative outdoor games for friends, students, and community groups.

Users choose their environment, group size, available time, and preferred activity style. GullyGames generates a structured activity designed to encourage real-world interaction and reduce unnecessary screen time.

Demo

https://gullygames.ai.studio

Code

GitHub repository — Gully-Games

How I Built It

I built GullyGames using Google AI Studio Build mode, React, TypeScript, and a Node.js/Express backend.

The application uses Google's open-weight Gemma 4 model through a server-side API integration to generate outdoor activities. It includes an activity setup flow, timed instructions, a distraction-free Pocket Mode, and local session history.

Why Does Open Innovation Matter?

Open-weight models give developers more flexibility to inspect, adapt, and experiment with AI models rather than depending entirely on a closed model ecosystem.

GullyGames keeps its model integration modular so that alternative inference setups can be explored as the project develops. The current version uses hosted inference, so it requires an internet connection for AI generation; it does not claim that model inference runs locally.

By keeping the experience lightweight and using browser-based storage for session history, the project can stay simple while leaving room for future improvements.