DEV Community: Aditya Goyal

NecroGit: I built an AI necromancer to resurrect dead open-source repositories

Aditya Goyal — Wed, 28 Oct 2026 19:46:47 +0000

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

What I Built

Over 40 million open-source repositories on GitHub lie dead in the digital graveyard—abandoned by creators, killed by bitrot, and haunted by deprecated APIs and unpatched CVEs.

In the spirit of Día de los Muertos and Halloween, NecroGit honors open-source history by summoning the ghosts of dead codebases and resurrecting them into modern, hardened software.

Point NecroGit at an abandoned repository (e.g., dead Python 2 tools from 2012). It:

Calculates repository "Time of Death" and bitrot risk using Prior Labs TabPFN-3.5.
Hunts the Internet Archive via Browserbase (Stagehand v4) to unearth vintage documentation.
Cleanses deprecated ASTs and synthesizes modern tests using local Gemma 2 (via Ollama).
Narrates the codebase's resurrection in the voice of the original author using ElevenLabs.

Who gets to benefit: Any developer inheriting legacy technical debt, or anyone who hates watching brilliant open-source software die.

Demo

Runs 100% local (privacy-first: vintage internal codebases never leave your machine):


bash
git clone https://github.com/SynthReaper/ghw-hacktoberfest26.git
cd ghw-hacktoberfest26/necrogit
pnpm install
pnpm agent:seance   # Runs digital séance across vintage graveyard repos
pnpm web:dev        # Launches Next.js 15 Séance Crypt Dashboard on localhost:3000

CouchPotato Expenses: I built an autonomous sloth agent to never look at a utility bill again

Aditya Goyal — Fri, 23 Oct 2026 10:42:23 +0000

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

What I Built

Every month, freelancers and small business owners dread the same chore: logging into 10 different utility and cloud portals, waiting for 2FA codes, downloading statements, figuring out IRS tax lines, and missing billing spikes.

CouchPotato Expenses is built for pure, unapologetic laziness.

Once a week, a background worker wakes up, drives a real browser via Browserbase (Stagehand v4) to log into recurring utility portals, downloads PDFs, extracts financial metadata using local Gemma 2 (via Ollama), uses Prior Labs' TabPFN-3.5 to classify IRS Schedule C tax write-offs and flag abnormal bill spikes, and quietly files them into your encrypted local vault.

You do literally nothing. You take a nap.

Who gets to be lazy: Anyone who would rather sleep than spend 38 hours a year managing receipts.

Demo

Runs 100% local (privacy-first: your financial records and utility account numbers never touch any third-party server):


bash
git clone https://github.com/SynthReaper/ghw-hacktoberfest26.git
cd ghw-hacktoberfest26/couchpotato
pnpm install
pnpm agent:hunt   # Runs autonomous browser + Gemma OCR + TabPFN pipeline
pnpm web:dev      # Launches Next.js 15 Sloth Command Center on localhost:3000

I tried to fire my LLM API. Open models passed one task and failed the other.

Aditya Goyal — Wed, 14 Oct 2026 19:48:25 +0000

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

What I Built

Open-Switch answers one question: can an open model replace your closed LLM API on YOUR data?

It runs your workflow through open-weight models, scores them with bootstrap 95% CIs, and gives a verdict: Safe Switch or No Safe Switch. It also tells you if a LoRA fine-tune pays for itself.

Who pays: B2B SaaS teams cutting LLM bills, and consultants selling migration audits. Hypothesis: $49/mo self-serve, $199/mo agency.

Demo

Runs fully local (no hosted link, by design: your data never leaves your machine):

git clone https://github.com/SynthReaper/ghw-hacktoberfest26.git
cd ghw-hacktoberfest26/switchable && pip install -e .
openswitch run --models gemma-2b-local,gemma-9b-local --task specs/task.yaml

Code

SynthReaper / ghw-hacktoberfest26

MLH x Hacktoberfest Challenge Projects (2026)

Workspace containing hackathon projects for DEV Hacktoberfest Challenges.

Projects

paper-trail/: Paper Trail — Offline Local Walk Generator & Analog Field Card (DEV Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass).
switchable/: Open-Switch — Autonomous evaluation and migration engine to verify whether open-weight models (Gemma 2, Llama 3, Qwen 2.5) can safely replace expensive closed LLMs with honest statistics (10k bootstrap 95% CIs), default-deny provenance guard, calibrated pairwise judging, and LoRA fine-tuning break-even economics (DEV Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle).

View on GitHub

The project lives in the switchable/ folder. Key files:

provenance.py: default-deny guard against training on closed-API outputs
evaluator.py: AB/BA position-bias defense
stats.py: 10k-resample bootstrap CIs

How I Built It

Models: Gemma 2 (2B/9B), Llama 3.1/3.2, Qwen 2.5 7B via Ollama
Judge: every pair is scored in AB and BA order; disagreements are flagged (90% agreement with human labels, κ = 0.85)
Provenance guard: blocks fine-tuning on closed-API outputs, then regenerates references with an open teacher
109 tests, 10k-resample bootstrap CIs on every metric

Task	Best open model	Score [95% CI]	Verdict
Support triage	Qwen 2.5 7B + LoRA	90.0% [80, 98]	✅ Safe switch, 85% cheaper
Banking intent	Gemma 2 2B	41.2% [27.5, 54.9]	❌ Not safe

The tool says "no" when the answer is no. That's the point.

Why Does Open Innovation Matter?

Closed APIs rent you a fine-tune. Open models give you a LoRA adapter you own forever. A $1.03 fine-tune broke even at ~10k requests/month, while 3-shot prompting quadrupled per-request cost.

My Agent Session

Built with Antigravity under a strict AGENTS.md: pre-flight gates, TDD, and a no-fabricated-metrics rule.

Prize Categories

Best Use of Gemma: 2B runs locally; 9B is the open teacher
Best Use of Tinker: LoRA training in 85s for $1.03

Paper Trail: Leaving the Phone Behind with Local Open AI and a Printed Walking Card

Aditya Goyal — Sat, 10 Oct 2026 16:39:07 +0000

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

What I Built

Most outdoor AI apps do the exact opposite of touching grass: they trap your attention behind an augmented camera viewfinder or buzz with continuous notifications.

Paper Trail turns the screen into the shortest part of the experience. It is a local-first walk generator that builds a calibrated loop route from OpenStreetMap data, extracts verified real-world points of interest (trees, water, shrines, historic markers, benches), synthesizes multi-sensory observation prompts (look, listen, count, touch, sketch) with an open LLM, and compiles an ink-friendly, monochrome PDF pocket card.

You enter a start point and your available time budget (30, 45, or 60 minutes). You click print, slip the folded card and a pencil into your pocket, and leave your phone at home.

Demo

Repository & Code: github.com/SynthReaper/ghw-hacktoberfest26/tree/main/paper-trail
Local Web UI & Field Cards: Check the /examples folder in the repository for compiled vector PDF cards (cubbon_park_calibrated.pdf) ready for A4/A5 printing.

Code

SynthReaper / ghw-hacktoberfest26

MLH x Hacktoberfest Challenge Projects (2026)

Workspace containing hackathon projects for DEV Hacktoberfest Challenges.

Projects

paper-trail/: Paper Trail — Offline Local Walk Generator & Analog Field Card (DEV Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass).

View on GitHub

The complete codebase lives under /paper-trail:

ingest.py: Overpass spatial ingest, POI extraction, and offline cache loader.
route.py: NetworkX walkable graph builder with perimeter-calibrated loop routing.
facts.py: Strictly typed, isolated fact records containing verifiable map ground truth.
clues.py: Sensory observation generator with a strict programmatic Anti-Hallucination Validator.
render.py: ReportLab monochrome vector field card PDF renderer.
cli.py: Unified offline/online CLI tool.
tests/: Pytest suite verifying routing boundaries and validator edge-case rejections.

How I Built It

The Core Architectural Invariant: The Model Never Owns Facts

When language models generate exploration clues, they inevitably invent nonexistent landmarks—hallucinating a "banyan tree next to the temple" where none exists.

Paper Trail eliminates this through a strict architectural rule: Code selects the facts; the model only phrases them.

Deterministic Graph Loop: route.py builds a walkable pedestrian graph from OpenStreetMap ways and solves a loop through 4–7 spatially diverse POIs. It dynamically scales the perimeter radius to calibrate total walking distance to within ±15% of the walker's target duration (at 4.5 km/h).
Fact Isolation: facts.py packages each stop into a minimal, whitelisted FactRecord containing only verified tags, compass bearing, and distance in meters.
The Anti-Hallucination Validator: Every clue generated by Gemma (via local Ollama inference) passes through an automated rule engine:
- Rejects unverified proper nouns not present in the OSM tags or navigation stopwords.
- Rejects unverified biological species (e.g., claiming "oak" or "pine" when the map only tags natural=tree).
- Rejects unverified metrics and numbers.
- If an open model fails validation across 3 retries, Paper Trail deterministically falls back to a fact-grounded template and logs the rejection to runs/<id>_clues.jsonl.
Physical Vector Card: render.py compiles an ink-friendly, high-contrast monochrome PDF featuring a topological route polyline, numbered waypoints, north indicator, sensory prompt badges, and physical pencil boxes for notes and field sketches.

Why Does Open Innovation Matter?

Zero Location Data on Remote Servers: Where, when, and how you walk is sensitive personal telemetry that should never leave your hardware. Because Paper Trail uses open-weight models (Gemma) and local OSM extracts, not a single byte of coordinate data or personal habits is sent to third-party cloud APIs.
True 100% Offline Capability: Using bundled OSM extracts, Paper Trail generates routes, evaluates spatial graphs, and generates observation prompts on a laptop with Wi-Fi completely disabled.
Auditability & Grounding: With proprietary APIs, guardrails are opaque black boxes. With open weights and local code, we can inspect every token, measure latency, track hallucination rates, and prove that map truth is strictly enforced.

Prize Categories

Best Use of Gemma: Used Gemma as the local open-weight clue generation model, with low-temperature structured JSON prompting and strict validator enforcement.
Best Use of Entire: AI agent pairing and architecture session tracked with DevRelay.