DEV Community: Ravi Teja Bhagavatula

The Last Commit 👻: Giving Abandoned Open-Source Projects a Voice

Ravi Teja Bhagavatula — Sat, 31 Oct 2026 15:53:20 +0000

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

What I Built

What happens when a software project is abandoned?

The developer stops committing code. Issues remain unanswered. TODO comments stay buried in source files. Eventually, the repository becomes another forgotten corner of GitHub.

But what if that project could tell us its story?

Introducing The Last Commit — an AI-powered digital archaeologist that brings abandoned software repositories back to life.

The idea is simple: every repository has a history, and every history has a story.

You provide a local Git repository, and The Last Commit examines its commit history, README, source code, and unfinished TODOs. It then creates an interactive ghost persona that you can talk to.

You can ask questions like:

"Who created you?"
"What were you originally supposed to do?"
"What happened during your final days?"
"Why did development stop?"
"What was left unfinished?"
"How can I bring you back?"

The ghost uses actual repository information to answer questions, rather than simply inventing a spooky story.

The project interprets Ghost in the Machine quite literally: the ghost is the history of software that nobody remembers anymore.

How I Built It

I wanted the AI to be more than a chatbot with a Halloween-themed interface. The actual intelligence and functionality needed to come from open technology.

Here's the stack I'm using:

Technology	Purpose
Python	Repository analysis and backend logic
FastAPI	Backend API
React + Vite	Interactive frontend
Ollama	Local model inference
Qwen3 1.7B	Open-weight language model
Git	Repository history extraction
SQLite	Local data storage

1. Understanding the repository

The backend uses Git to examine a repository's history.

It extracts information such as:

Commit messages and timestamps.
Development activity.
README content.
TODO and FIXME comments.
Relevant source-code information.

This information becomes the ghost's memories.

2. Giving the repository a voice

I'm using Qwen3 through Ollama to power the ghost.

Instead of sending repository information to an external AI API, the application communicates with a locally running model.

The model receives repository context and responds in the personality of the abandoned project.

For example, a repository with years of development history followed by a sudden stop might respond:

"I remember when everything was moving so quickly. New features every week, bugs disappearing, and plans for the future. Then came my final commit. Nobody returned after that."

The personality is generated by the model, while the underlying memories are grounded in repository evidence.

3. Building the experience

The frontend provides a haunted terminal-inspired interface where users can:

Summon a repository.
Talk to its ghost.
Explore its development timeline.
Inspect repository evidence.
Generate a resurrection roadmap.

The goal is to make software archaeology feel like an interactive experience rather than reading Git logs.

Why Does Open Innovation Matter?

This is probably the most important part of the project.

I could have connected a commercial AI API and built a chatbot around it. That would have been easier in some ways, but it would have missed the point.

I wanted the project to be independent of a closed AI service.

Using an open-weight model and local inference makes several things possible:

1. Privacy

Source code can contain sensitive information. Keeping repository analysis and inference on the user's own machine means the application doesn't need to upload that code to an external inference provider.

2. Offline operation

Once the model and dependencies are downloaded, the intended workflow can run without an internet connection. You can explore a repository and talk to its ghost without depending on a cloud AI service.

3. Freedom to experiment

I can replace Qwen3 with another compatible open-weight model, experiment with different prompts, and change the ghost's personality without rebuilding the entire application around a proprietary API.

4. Accessibility

There is no required per-request commercial inference API fee. Users can run the model using their own hardware.

For me, open innovation isn't simply about using free software. It's about being able to understand, modify, control, and preserve the technology that powers something you build.

A project about preserving forgotten software should itself be built using technology that people can preserve and modify.

The Spirit of It

There is something interesting about abandoned software.

A repository can contain thousands of lines of code, hundreds of commits, and months or years of someone's effort. Yet one day, nobody remembers why it was created.

The code remains. The commit history remains. The comments remain.

But the voice behind the project disappears.

I wanted to build something that gives that history a voice again.

Maybe the project was abandoned because its developer ran out of time. Maybe the original idea became irrelevant. Maybe there was simply nobody left to maintain it.

The Last Commit doesn't claim to know why someone disappeared. Instead, it helps us discover what they left behind.

Every repository has a last commit. But does that really have to be the end of its story?

ScopeShield: A Local-First AI Agent That Turns Client Scope Creep Into Paid Change Orders (Gemma + TabPFN-3.5)

Ravi Teja Bhagavatula — Sun, 18 Oct 2026 17:03:23 +0000

Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Every freelance developer and designer knows the dread of the "quick favor" message:

"Hey! Loving the staging build. Can we just add a quick role-based export button and tweak the webhook payload before Friday? Should only take 15 minutes!"

Saying yes destroys your hourly rate; saying no feels confrontational. According to freelance industry surveys, independent contractors lose 18% to 25% of their annual revenue to unbilled scope creep simply because diagnosing the contract violation, estimating the real effort, and writing a polite pushback email takes too much mental energy in the middle of a sprint.

ScopeShield is a local-first AI Contract & Change-Order Agent built specifically for independent freelancers and micro-agencies.

Instead of acting like a generic chat wrapper, ScopeShield performs a deterministic 4-stage workflow:

Contract Clause Auditing (Gemma 3): Ingests your signed Statement of Work (SOW) PDF and incoming client messages (Slack/Email/WhatsApp) locally, identifying the exact deliverables clause being stretched.
Historical Effort Forecasting (TabPFN-3.5): Looks at your CSV of past completed tickets/projects and predicts the actual hours required and schedule slip probability (because a "15-minute tweak" historically takes 4.2 hours once QA and deployment are factored in).
Live Market Rate Benchmarking (SerpApi): Pulls current freelance market rates and comparable specialized task pricing so you don't undercharge on the addendum.
Zero-Friction Change Order Generation: Outputs a polite, psychologically calibrated client response paired with a 1-click PDF Change Order addendum.

Who pays for this? Freelance full-stack developers, UI/UX designers, and boutique 2–5 person dev shops billing $40–$150/hr. Recovering just one unbilled 3-hour "quick tweak" a month pays for a $19/month tool ten times over.

Pipeline in Action

ScopeShield Dashboard Screenshot

Above: ScopeShield flagging a "minor webhook adjustment" against Section 3.2 of the original SOW, alongside TabPFN-3.5's prediction of 4.6 actual engineering hours.

Code

Core Repository Structure

scopeshield/
├── agent/                  # Mastra agent orchestration & tool definitions
│   ├── workflows/          # Multi-step SOW audit + TabPFN forecasting pipeline
│   └── tools/              # SerpApi rate lookup & PDF parser tools
├── backend/                # FastAPI inference bridge + TabPFN-3.5 client
├── frontend/               # React + Tailwind UI (hosted on Render)
├── sample_data/            # Pre-loaded historical ticket CSVs & sample SOW PDFs
└── render.yaml             # Infrastructure-as-Code for 1-click Render deployment

How I Built It

ScopeShield is architected around an open-source reasoning core combined with specialized tabular foundation models and full observability:

[Signed SOW PDF] + [Client Message]
         │
         ▼
┌─────────────────────────────────────────────────────────┐
│             Mastra Agent Orchestrator                   │
│  (Instrumented end-to-end with Sentry Agent Tracing)    │
└────────┬───────────────────────┬────────────────────────┘
         │                       │
         ▼                       ▼
┌─────────────────────┐ ┌─────────────────────────────────┐
│   Gemma (Local/vLLM)│ │  TabPFN-3.5 (Prior Labs API)    │
│ Semantic SOW diff & │ │  Reads historical_tasks.csv to  │
│ clause extraction   │ │  predict real hours & overrun % │
└────────┬────────────┘ └────────┬────────────────────────┘
         │                       │
         ▼                       ▼
┌─────────────────────────────────────────────────────────┐
│   SerpApi Live Market Benchmark                         │
│   Grounds change-order hourly pricing in live comps     │
└────────┬────────────────────────────────────────────────┘
         │
         ▼
[Polite Pushback Email + Itemized Change Order PDF]

Open-Weight Reasoning Core (Gemma): We use Google's open-weight Gemma model (running locally via Ollama for strict offline NDA mode, and served via containerized runtime for our public demo) to perform structured semantic comparison between the signed SOW sections and the unstructured client request. Gemma outputs strict JSON containing violated_clause_id, scope_delta_summary, and severity_score.
Tabular Foundation Model (TabPFN-3.5): LLMs are notoriously bad at doing regression math over historical spreadsheets. Instead of asking an LLM to guess how long a task will take, we pass the freelancer's historical_projects.csv (task category, complexity, client revision count, stack, actual vs. estimated hours) directly to Prior Labs' TabPFN-3.5. With zero training wait time, TabPFN predicts the realistic hour distribution and overrun risk.
Agent Harness (Mastra): Orchestrates the deterministic handoff between document parsing, Gemma's semantic extraction, SerpApi's rate check, and TabPFN's tabular inference.
Observability (Sentry Agent Tracing): Every tool call, prompt token count, and latency span is tracked via Sentry.

Debugging with Sentry Agent Tracing

During early testing, our end-to-end change-order generation was taking 8.4 seconds. Looking at our Sentry Agent Tracing waterfall immediately revealed the culprit.

Sentry Agent Trace Screenshot

What we found: Our SerpApi tool was passing raw, unstripped search snippet metadata directly into Gemma's context window (burning 2,140 extra input tokens per run), and TabPFN was being called sequentially after SerpApi despite having zero dependency on it.
The fix: We parallelized the TabPFN-3.5 and SerpApi tool calls inside our Mastra workflow and stripped the SerpApi payload down to top-5 structured rate cards. Total pipeline latency dropped from 8.4s to 2.9s (-65%), and token consumption dropped by 71%.

Why Does Open Innovation Matter?

When I talked to freelancers about why they don't paste client contracts and Slack arguments into ChatGPT or Claude, two hard blockers came up immediately: NDA Legal Liability and Unit Economics.

Strict NDA & Data Privacy Compliance: Standard freelance MSA/SOW contracts contain strict non-disclosure clauses prohibiting contractors from uploading proprietary architecture specs, pricing tables, and internal correspondence to third-party closed SaaS APIs that retain data. Because ScopeShield runs Gemma locally on the freelancer's laptop, confidential client PDFs never leave localhost. Open weights make this product legally usable.
Right-Sized Models Beat Monolithic APIs: By pairing a compact, fast open-weight language model (Gemma) for text extraction with a specialized tabular foundation model (TabPFN-3.5) for numerical hour prediction, we outperform a massive closed frontier LLM on both accuracy and cost.

Metric	Closed Frontier LLM Wrapper	ScopeShield Open Stack (Gemma + TabPFN-3.5)
NDA / Offline Compliance	Fails strict agency NDAs (cloud data retention)	100% compliant (runs locally on laptop)
Effort Estimation Method	Hallucinates numbers via text token prediction	True tabular regression on historical CSVs via TabPFN-3.5
Marginal Cost per 1,000 Audits	~$18.50 (multi-page PDF context + reasoning)	$0.00 local (or <$0.80 on self-hosted cloud)
Schema Lock-in	Vulnerable to silent model deprecations	Full weight control & fine-tunable on domain SOWs

My First User

To put the "Side Hustle" prompt to the test, I gave ScopeShield to Kumar, a freelance full-stack React/Node developer who builds MVP web portals for local businesses.

The Real Test: He uploaded a real 4-page SOW from a current project and pasted a WhatsApp message where his client asked to "quickly add multi-branch role filtering and WhatsApp invoice alerts"—claiming it was already implied under "Dashboard Views."
What Happened: ScopeShield pinpointed Section 2.4 (Single-Tenant Admin Scope) in 3 seconds, ran his past 40 Jira ticket exports through TabPFN-3.5, and showed him that similar "notification + role" requests previously took him 6.5 hours (not the 1 hour he was about to quote). It drafted a friendly reply offering to bundle it as a Phase 1.1 mini-addendum for ₹8,500 (~$100).
Did they pay / Would they pay? He sent the generated reply with almost zero edits—and the client approved the paid addendum that same evening! He told me:

"Honestly, having the breakdown table showing why it's 6.5 hours based on past sprints gave me the confidence not to cave. I'd easily pay $15/month if this had a Chrome extension that sits right inside Gmail and WhatsApp Web."

What he asked for next: A direct Razorpay/Stripe payment link generator embedded directly inside the exported Change Order PDF so clients can approve and pay the deposit in one click.

Prize Categories

Best Use of Gemma: Uses Google's open-weight Gemma model as the core semantic contract auditor and structured JSON change-order generator.
Best Use of TabPFN: Uses Prior Labs' TabPFN-3.5 inside our prediction agent to forecast realistic task hours and schedule overrun probabilities directly from the freelancer's historical project CSVs.
Best Use of Render: Hosted the full-stack ScopeShield web application and FastAPI agent bridge on Render via Blueprint (render.yaml).
Best Use of Mastra: Orchestrates the multi-step agent workflow, parallel tool execution, and state transitions across Gemma, TabPFN, and SerpApi.
Best Use of Sentry Agent Tracing: Instrumented the agent pipeline with Sentry Agent Tracing to inspect token burn, debug sequential tool bottlenecks, and cut latency by 65%.
Best Use of SerpApi: Grounds every generated Change Order in live freelance market rate comps fetched via SerpApi.
Best Use of a .tech Domain: Deployed live on a .tech domain claimed via the Hacktoberfest promo.

touchgrass — an offline, open-weight agent whose only job is to make you stop using it.

Ravi Teja Bhagavatula — Sun, 11 Oct 2026 12:01:45 +0000

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

What I Built

touchgrass — an offline, open-weight agent whose only job is to make you stop using it.

It runs Gemma locally (via Ollama, on 127.0.0.1), takes your minutes and coordinates, and prints a Field Card: one short loop, three noticing prompts anchored to your actual latitude and day length, one dare, and instructions for what to do with the phone. Then the screen part is over. There is no feed, no streak, no second screen. The artifact is paper — print it, tape it to your phone case, go.

╭──────────────────────────────────────────────────────────────╮
│ touchgrass                                          No. 0284 │
│ F I E L D   C A R D                                          │
│ Sun 11 Oct 2026 · evening                                  │
╰──────────────────────────────────────────────────────────────╯

  FIELD CARD — this evening's card

  new moon · any ground · ☀ 06:26–18:06

  THE LOOP
     Walk toward the setting sun. Head south until the buildings
     thin. Continue until you reach a patch of bare earth.

  NOTICE — three things
     01  Feel the wind on your face. Note its direction.
     02  Pick up a stone. Examine its weight and texture.
     03  Observe the shadows lengthening. How do they shift?

  THE DARE
     Kick a pebble. Listen to the echo.

  POCKET THE PHONE
     Photograph the color of the sky just after the sun dips
     below the horizon.

  generated by gemma3:4b on 127.0.0.1 (local) · loopback only · no network

Who is it for? Anyone whose screen time needs an off-ramp. Runners, parents, students, and — honestly — hackers on submission day.

Demo

There is no deployed link, and that's the point: this tool works with the radio off. The demo is three commands on your own laptop:

ollama pull gemma3:4b
pip install -e . --break-system-packages
touchgrass doctor --proof   # hero moment: the internet gets refused live
touchgrass demo             # proof + card + journal in ~30 seconds
touchgrass serve            # → http://127.0.0.1:8765, loopback-only web UI

The demo web UI (touchgrass serve, loopback only)

Terminal Field Card

touchgrass doctor --proof

Taking it outside (bonus points, honestly earned):
I printed the card, taped it to my phone case, and walked the local park for 30 minutes at sunset. The route — head south until the buildings thin, find bare earth — worked exactly as written; no map needed. The shadow prompt was the one that landed: I stood and watched the light move instead of walking through it, and the stone prompt stopped me a second time. The dare (kick a pebble, listen for the echo) got a laugh out of me, which is more than most software has managed outdoors. One honest finding: the sky-photo instruction arrived a few minutes before the sky did anything interesting — the next iteration should time the pocket-the-phone moment to sunset itself, which the tool already computes.

Code

Repo: https://github.com/RaviTeja799/touchgrass

MIT licensed. Python 3.9+, zero third-party dependencies — stdlib only, so pip install works on a plane. Layout:

touchgrass/
  cli.py        plan / demo / serve / log / recall / doctor / locate
  serve.py      loopback-only demo web UI (one self-contained page)
  brain.py      Ollama chat + model auto-resolve + fallback planner
  card.py       FieldCard → colour terminal / receipt text / HTML / JSON
  phenology.py  solar declination, day length, sun times, moon phase
  journal.py    SQLite + FTS5 outing log, on your disk
  offline.py    socket-layer network guard + live proof
  geo.py        locate-once-cached-forever (flags > env > cache > default)

The part I'm proudest of is the smallest one — "we don't send your data anywhere" as a demonstration instead of a sentence:

# offline.py — refuses every non-loopback socket in the process
def _check(address, where):
    if not _enabled:
        return
    host = _host_of(address)
    if _is_loopback(host):
        return
    raise NetworkBlocked(
        f"touchgrass blocked an outbound call to {address!r} (via {where})."
    )

$ touchgrass doctor --proof
  leaving the machine:
    ok  1.1.1.1          blocked at the boundary
    ok  8.8.8.8          blocked at the boundary
    ok  93.184.216.34    blocked at the boundary
  staying on the machine:
    ok  127.0.0.1:11434  loopback allowed -- model reachable

How I Built It

Open-source AI: Gemma 3 (gemma3:4b, falling back to any gemma* on disk) running locally through Ollama. No API keys, no per-token billing, no rate limits. The project is built around the model in three layers:

Season math first, model voice second. Before Gemma is even called, phenology.py computes solar declination, day length, longitude-corrected sunrise/sunset, and lunar phase from the calendar and your coordinates — farmer's-almanac arithmetic, no network. On 11 October at +17.7°, +83.3° that's an 11h 40m day, sun about 06:26–18:06. Delete the model entirely and the tool still knows what kind of afternoon it is. Gemma supplies the voice (route, dare, exit line), never the facts. The prompt libraries are latitude-aware too: inside the tropics the tool swaps temperate leaf-fall prompts for heat-and-rain ones, so the card reads true where you actually stand.
A guard, not a promise. offline.py patches the socket layer so anything imported into the process that tries to phone home is refused at the boundary — and doctor --proof shows you the refusal live.
Graceful degradation as a design principle. No model on disk? A hand-written fallback planner (10 archetypes) still gets you outside. Tiny model echoing the schema or parroting the example? Echo/parrot detection repairs those fields from the seed-varied planner, so the card is always fresh and printable. A field guide that stops working without wifi is not a field guide.

The rest is stdlib Python: argparse CLI, http.server demo UI, sqlite3 with FTS5 for the journal (touchgrass recall "what was turning in autumn" searches your own outings on your own disk). Location resolves as flags → env → cached fix → default; touchgrass locate is the single online step, cached for every --offline run after. The HTML card is fully self-contained (no webfonts, no CDN) and sized for 80mm thermal paper.

Why Does Open Innovation Matter?

Three things this project can only do because the model is open and local:

It works with the radio off. A trail tool that needs a data plan is not a trail tool. Closed APIs can't make this claim at all — and "we don't send your data anywhere" in a README is worthless next to a live refusal at the socket boundary.
It costs nothing, forever. No key, no bill, no 6am-Sunday rate limit when you actually want to go outside. Open weights + local inference + zero-dependency Python = a tool a student can run on a 2019 laptop.
I can change its mind. The system prompt bans chirpy chatbot words outright; --model accepts anything Ollama serves. A hosted endpoint kept drifting my prompt toward "embark on a journey of discovery" — with a local model I just rewrote the instructions and regenerated. No lock-in, no roadmap permission slip.

Open innovation is what turns AI from a chat window you rent into a field guide you own.

Prize Categories

Best Use of Gemma 🏔️ — Gemma 3 (gemma3:4b) via Ollama generates every Field Card's voice; the model auto-resolves to whatever Gemma is on disk, and the whole offline-local argument only works because the weights are open.

Repo: https://github.com/RaviTeja799/touchgrass · MIT · Built tonight, used tonight.

Now go outside. The screen part is over.