DEV Community: Ankush

NecroCode: The Open-Source Codebase Necromancer & Spectral Auditor 👻

Ankush — Tue, 27 Oct 2026 12:45:26 +0000

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

What I Built

In open-source software, there is a quiet tragedy that unfolds every single day: over 80% of open-source repositories on GitHub end up abandoned.

They become digital ghosts. They sit dormant in the digital cemetery—haunted by deprecated Python 2 syntax, collision-broken cryptographic digests (MD5/SHA-1), unpatched CVEs, dead dependencies, and elusive concurrency heisenbugs that spawn phantom crashes and zombie threads.

For Week 4's theme, "Ghost in the Machine", I built NecroCode: an autonomous, privacy-first open-source AI platform and CLI powered by Google Gemma (open weights) that serves as a digital necromancer for forgotten software.

The Core Capabilities:

⚰️ The Cemetery & Bit Rot Audit: Analyzes legacy source code using Python Abstract Syntax Trees (AST) and regex heuristics, calculates a real-time Bit Rot Score (0–100), categorizes its resting state (Restless Spirit, Haunted Legacy, or Decomposed Zombie), and diagnoses dangerous bit rot and memory leaks.
⚡ Modernization Necromancy: Uses Google Gemma open-weight reasoning and AST transformers to transmute legacy syntax to modern Python 3.12+, upgrades broken cryptographic digests to SHA-256, wraps shared memory race conditions in threading.Lock(), and auto-synthesizes self-healing pytest suites and non-root Dockerfiles.
🔮 The Séance Chamber (Ghost in the Machine): Opens an interactive séance where developers can speak directly with the digital spirit of the original maintainer—synthesized via Gemma open-weight prompt chaining and voiced by ElevenLabs (with an offline Web Audio procedural fallback).
📡 Spectral Observability: Traces multi-agent reasoning steps, tool calls, and LLM completions via Sentry Agent Tracing.
🏛️ The Graveyard Vault: Indexes and tracks audited repositories using MongoDB Atlas.

Demo

GitHub Repository: https://github.com/BOTPranav-01/DevSumbsion
Deployment Blueprint: Fully containerized with a 1-click render.yaml deployment blueprint on Render.

The Crypt UI in Action

The application features a Gothic Cyberpunk Terminal interface with CRT scanline shaders, binaural procedural ambient audio drones generated via the Web Audio API, and real-time Server-Sent Events (SSE) streaming the resurrection ritual:

LedgerPilot: a private cashflow copilot for the one-person business

Ankush — Sat, 17 Oct 2026 18:53:10 +0000

*This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle](https://dev.to/challenges/hacktoberfest-week2-2026-10-12).*

## What I Built

LedgerPilot is a small cashflow copilot for freelancers and one-person businesses.

I built it around a simple observation: most independent workers do not need another finance dashboard. They need to know whether this month is healthy, how long their cash will last if work slows down, and what to do next.

LedgerPilot takes a CSV export from a bank, Stripe, PayPal, or accounting tool and turns it into:

- a clear income, expense, and net-cashflow summary
- category-level spending signals
- a six-month expected and cautious-case projection
- three specific actions, written in plain language

The product is intentionally narrow. It is a five-minute monthly review for someone who invoices clients, not an attempt to replace an accountant or become a full accounting platform. The thing it sells is reduced uncertainty.

## Demo

**Try it here:** [LedgerPilot on Render](https://ledgerpilot.onrender.com)

Open the app and click **Try live demo** to see the complete flow with sample data. You can also upload a CSV with these columns:

text
date,description,amount,category






The deployed health endpoint is available at [`/api/health`](https://ledgerpilot.onrender.com/api/health).


## Code


The complete source is on GitHub:


[github.com/BOTPranav-01/ledgerpilot](https://github.com/BOTPranav-01/ledgerpilot)


The project is deliberately small enough to understand in one sitting:



- [`server.py`](https://github.com/BOTPranav-01/ledgerpilot/blob/main/server.py) handles the API, CSV parsing, summaries, forecasts, and AI adapter

- [`public/index.html`](https://github.com/BOTPranav-01/ledgerpilot/blob/main/public/index.html) contains the product experience

- [`public/styles.css`](https://github.com/BOTPranav-01/ledgerpilot/blob/main/public/styles.css) contains the responsive visual system

- [`public/app.js`](https://github.com/BOTPranav-01/ledgerpilot/blob/main/public/app.js) connects the interface to the analysis API

- [`render.yaml`](https://github.com/BOTPranav-01/ledgerpilot/blob/main/render.yaml) describes the Render deployment



## How I Built It


The important design decision was to keep the numbers and the language separate.


First, the server parses the CSV and calculates the facts: income, expenses, category totals, monthly net cashflow, average monthly change, volatility, and runway. The forecast is deterministic and explainable. It is not asking a language model to do arithmetic that ordinary code can do more reliably.


Then the product can pass that structured summary to an open-weight model for interpretation. If `OLLAMA_URL` is configured, LedgerPilot uses Ollama and the `qwen2.5:3b` model by default. The model is asked for a short JSON action plan: a headline, three actions, and one watchout.


There is also a deterministic fallback. That matters because the product should still work on the first visit, without a model download, an API key, or a surprise bill. The interface makes the provider visible, so the user can tell whether the briefing came from a local model or the built-in fallback.


The app has no database and does not require a bank connection. A user can run it locally with:


PowerShell

plaintext
python server.py








It is deployed as a Python web service on Render, with `/api/health` used as the health check.


## Why Does Open Innovation Matter?


A financial export is not generic text. It can contain client names, invoice amounts, recurring expenses, and a very accurate picture of a small business. Sending all of that to a closed API is a serious product decision for the exact people LedgerPilot is meant to help.


Open AI makes the privacy promise practical rather than aspirational. A freelancer can run the workflow locally with Ollama and keep the file on their own machine. They can choose a different open-weight model, host inference somewhere they trust, or use the deterministic fallback when they do not want inference at all.


It also changes the economics. A solo business checking its cashflow once a month should not need to accept an unpredictable per-request cost before the product is useful.


The open model is not being used as decoration. It is the replaceable reasoning layer that turns calculated facts into a short, useful plan. The arithmetic stays in ordinary code; the model adds interpretation. That division makes the system easier to audit, cheaper to run, and less dependent on one vendor.


## Prize Categories



- **Best Use of Render** — Render hosts the public LedgerPilot app, serves the frontend and API, and monitors the `/api/health` endpoint.

Outside Window: A Local AI Agent That Gets You Off the Screen

Ankush — Tue, 06 Oct 2026 20:04:55 +0000

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

What I Built

Outside Window is a privacy-first personal agent that helps someone take one realistic outdoor break today.

Most wellness apps turn going outside into another dashboard to manage. Outside Window takes the opposite approach: the screen should be the shortest part of the experience.

The app gives the user:

A recommended time window for today.
A short ten-minute outdoor micro-quest.
A one-tap “I went outside” or “Not today” check-in.
A local outing log that can be exported as CSV.
A learning loop that can eventually improve its recommendation from the user’s real outcomes.

The first recommendation is intentionally transparent rather than pretending to be a highly accurate model before enough personal data exists. The current demo uses a clear heuristic and records the outcome needed to train a personal model later.

The project is for people who work, study, or spend too much time online and want a gentle nudge rather than another productivity system.

Synthetic seed rows are clearly labelled and are not presented as real user behaviour or model evidence.

Demo

Repository: github.com/BOTPranav-01/outside-window

Run the local demo:

PowerShell

git clone https://github.com/BOTPranav-01/outside-window.git
cd outside-window
npm install
Copy-Item .env.example .env
npm run seed
npm run dev

Open:

Plain text

http://localhost:8787/

The demo flow is:

Load today’s recommendation.
Read the generated ten-minute quest.
Tap I went outside or Not today.
Inspect the saved event at /api/outings.
Export the user-owned log from /api/export.

The Gemma path can be enabled locally with Ollama:

PowerShell

ollama pull gemma3:4b
npm run dev

Without Ollama, the app uses a safe deterministic fallback quest so the core demo remains functional offline.

A deployed URL and short screen recording should be added here before publishing. Do not submit a fake URL:

Plain text

Live demo: TODO — add after Render deployment
Video demo: TODO — add a 60–90 second recording

Code

The complete open-source code is available here:

View the Outside Window repository on GitHub

The repository includes:

TypeScript Hono API
Node SQLite persistence
CSV import/export
Zod validation for model-generated quests
Open-Meteo client with coarse coordinate rounding and caching
Feature builder for time, weather, and outcome data
Python prediction sidecar
Leave-one-out evaluation against a fixed 6 PM baseline
Docker Compose configuration
Render service and worker configuration
Tests for the contracts, database, weather features, and workflow recovery
MIT license

How I Built It

Local-first data ownership

The outing history is stored in SQLite on the machine running the app. The user can export it to CSV or import it again. There is no hosted user database in the default setup.

This makes the privacy boundary understandable:

Outing history stays local.
Synthetic seed data is explicitly labelled.
Open-Meteo receives only coarse-rounded coordinates when weather is enabled.
Gemma can run locally through Ollama.
Optional external providers are isolated behind configuration.
No raw voice recordings are stored by the application.

Open-source AI with Gemma

The micro-quest generator uses a provider adapter pointed at Ollama:

Plain text

OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_MODEL=gemma3:4b

The prompt asks Gemma to return only a strict JSON object containing:

quest title
one to three steps
exactly ten minutes
a safety note

The response is parsed and validated with Zod. Invalid or unavailable model output cannot silently become a success-shaped response; the application falls back to a safe deterministic quest.

This is where open innovation matters technically. The model provider can run on the user’s machine, can be swapped through environment variables, and does not require sending a personal outing history to a closed AI API.

Prediction and honest evaluation

The prediction sidecar defines the intended features:

hour
weekday
temperature
apparent temperature
precipitation probability
rain
humidity
wind
eventual outing outcome

The evaluation script compares a fixed 6 PM baseline with a leave-one-out classifier and prints a Markdown table.

The included demo dataset is synthetic and labelled as synthetic. It is only a repeatable smoke test for the evaluation pipeline. It is not evidence that the model predicts real people accurately. Real accuracy requires real user-owned observations collected over time.

Durable state

The user-day workflow stores its state locally and has a recovery test that simulates a worker restart without duplicating the user-day state.

The next production integration is Temporal: the same state machine will compute a window, sleep durably, send a nudge, wait up to 45 minutes for a check-in, record the outcome, and trigger a refit.

I kept that distinction explicit rather than claiming a local state test is already Temporal Cloud.

Why Does Open Innovation Matter?

A closed wellness assistant could produce a polished recommendation, but the user would have little ability to inspect or own the system making decisions about their daily behaviour.

Open innovation makes several things possible here:

Local inference: Gemma can run offline through Ollama.
Model choice: the provider can be swapped without rewriting the application.
Inspectable features: the recommendation inputs are visible rather than hidden.
User-owned history: SQLite and CSV make the outing log portable.
Honest evaluation: the fixed 6 PM baseline is included instead of reporting only a model score.
Community improvement: the feature builder, validator, and workflow state are open to review and extension.

The project is intentionally modest about what it knows. It does not claim that a model can solve motivation. It creates a small feedback loop that respects the user and improves only when the user supplies real outcomes.

My Agent Session

This section is optional. Add the public DevRelay session link after saving and making the session public.

Plain text

TODO — add public DevRelay agent session link

I used AI assistance during implementation and will disclose that accurately in the DEV article settings.

Prize Categories

Gemma

I am entering the Gemma category only when the submitted demo runs Gemma locally through Ollama. Gemma generates the structured ten-minute quest, and the application validates the output before showing it to the user.

I am not claiming categories for integrations that are only configuration placeholders.

Limitations

This is a new project built during the Week 1 challenge window.

Current limitations:

The recommendation is still a transparent demo heuristic.
The included evaluation rows are synthetic and cannot demonstrate real-world accuracy.
The real TabPFN integration is not yet claimed.
Temporal Cloud orchestration is not yet claimed.
ElevenLabs audio is not yet claimed.
Sentry tracing is not yet claimed.
A public Render deployment still needs to be added before submission.
Voice check-in is planned but not part of the current validated demo.

These limitations are deliberate. The goal is to show what works, identify what remains, and avoid presenting scaffolding as a finished integration.

Credits and Disclosure

Built with TypeScript, Hono, Node SQLite, Zod, Vitest, Python, FastAPI, Open-Meteo, Ollama/Gemma, Docker, and Render configuration.

The project is MIT licensed. No non-trivial borrowed code is included without attribution.

AI tools assisted with implementation. The repository, application structure, tests, documentation, and integration decisions were created for this challenge project.

OpenBrief: A local-first AI reading desk for clearer, more thoughtful summaries

Ankush — Sun, 04 Oct 2026 21:10:50 +0000

What I Built

I built OpenBrief for a friend who regularly reads long articles, research summaries, and technical notes but does not always have time to process everything carefully.

OpenBrief turns pasted reading into three useful outputs:

a short plain-English summary
claims that are worth checking
questions to think about next

I wanted it to be more than a tool that simply makes text shorter. The goal is to help someone understand what they read while also reminding them not to blindly trust an AI-generated answer.

Demo

Try the live demo here:

https://botpranav-01.github.io/OpenBrief/

Click Load example, then click Build my brief.

The public demo works with a clearly labeled demo fallback. For real local AI inference, install Ollama and run:


bash
ollama run llama3.2:3b

**Prize Categories**

I am entering **Best Use of Gemma**. Gemma is used as the project's actual local inference model through Ollama.

<!-- Team Submissions: Please pick one member to publish the submission and credit teammates by listing their DEV usernames directly in the body of the post. -->

<!-- Thanks for participating! -->