DEV Community: Heramb Inamke

Ghost Blame: a eulogy for every function you deleted

Heramb Inamke — Thu, 29 Oct 2026 12:27:04 +0000

Every repo has ghosts: functions that lived for three months, got quietly removed, and left nothing behind but a commit message.

Ghost Blame walks git log -p, finds code that no longer exists, and asks a local Gemma model to write a short eulogy for each one: when it was born, what it did, and why it was probably laid to rest.

It runs on Ollama with Gemma on a laptop, with the internet off. Open weights matter here because the input is your private code history, which should never be sent to a hosted API. Swapping models is one flag, so you can try a different open model for a different tone.

The “Ghost in the Machine” angle: the machine is haunted by its own history.

devchallenge #hf26challenge

🦥 slothsort: my Downloads folder now cleans itself while I sleep.

Heramb Inamke — Wed, 21 Oct 2026 05:45:38 +0000

Title: 🦥 slothsort: my Downloads folder now cleans itself while I sleep
Tags: devchallenge, hf26challenge, ai, python

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

https://github.com/HerambInamke/Hacktoberfest-Open-Source-AI-Challenge-Week-3

What I Built

My Downloads folder had become a graveyard: download (3).txt, IMG_20240712_183455.jpg, script_final_FINAL.py, Resume_v7_really_final.pdf. Sorting it was always a "tomorrow" job.

slothsort does it for me. It's a single Python file. A small open-weight model (llama3.2:3b) running locally in Ollama reads each file's name, plus the first 500 characters of text files, and picks a category and a readable name. Then it moves the files into folders like Receipts, Code, Installers and Archives.

It runs as a dry run by default. --apply moves the files, and undo puts every file back exactly where it was. One schtasks line runs it at 3 AM every night, so the person who gets to be lazier is me: I never sort Downloads by hand again.

Demo

Real output from python slothsort.py demo (llama3.2:3b on a laptop RTX 4050, 16 files in about 39 s):

download (3).txt                ->  Receipts\Invoice 4821.txt
export_20260912.csv             ->  Documents\Export Scores.csv
logs-sept.tar.gz                ->  Archives\System Logs.tar.gz
notes(1).md                     ->  Documents\Meeting Notes.md
order_confirmation.txt          ->  Receipts\Order Confirmed.txt
script_final_FINAL.py           ->  Code\Final Fibonacci Function.py
untitled.txt                    ->  Documents\Grocery List.txt
VSCodeUserSetup-x64-1.94.2.exe  ->  Installers\Visual Studio Code Setup.exe

Try it yourself:

winget install Ollama.Ollama
ollama pull llama3.2:3b
python slothsort.py demo           # see the plan
python slothsort.py demo --apply   # sort
python slothsort.py demo undo      # regret nothing

Code

HerambInamke / Hacktoberfest-Open-Source-AI-Challenge-Week-3

🦥 slothsort

A lazy, offline folder tidier. Point it at your messy Downloads folder and a local open-weight LLM picks a category and a readable name for every file, then moves them into neat subfolders. It works without internet, needs no API key, costs nothing to run, and your files never leave your machine.

Real output from python slothsort.py demo (llama3.2:3b on a laptop RTX 4050, 16 files in about 39 s):

download (3).txt                ->  Receipts\Invoice 4821.txt
export_20260912.csv             ->  Documents\Export Scores.csv
logs-sept.tar.gz                ->  Archives\System Logs.tar.gz
notes(1).md                     ->  Documents\Meeting Notes.md
order_confirmation.txt          ->  Receipts\Order Confirmed.txt
script_final_FINAL.py           ->  Code\Final Fibonacci Function.py
untitled.txt                    ->  Documents\Grocery List.txt
VSCodeUserSetup-x64-1.94.2.exe  ->  Installers\Visual Studio Code Setup.exe

Images and binaries are named from the filename only, so those names are best guesses.

Built for the Hacktoberfest Open Source AI Challenge, Week 3: Slow and Steady 🦥 (International Sloth Day, Oct 20).

How it works

One Python file, standard library…

View on GitHub

How I Built It

Model: llama3.2:3b, an open-weight model, running locally through Ollama. Any other Ollama model works with --model qwen2.5:3b.
Harness: one Python file, standard library only. It calls Ollama's HTTP API on localhost:11434 with format: "json". No SDK, nothing to pip install.
The model is a coworker, not an admin, so its output is never trusted:
- The category must come from a fixed list. Anything else becomes Other.
- Names are stripped to safe characters, Windows reserved names (CON, NUL…) are rejected, and the original extension is always kept, including .tar.gz.
- It never overwrites anything. Name collisions get (2).
- Every move is logged right away to .slothsort-log.json, so even a crash halfway through can be undone.
Tests: 11 unit tests run with a fake model, so they don't need Ollama. A live check confirmed that apply followed by undo leaves the demo folder byte-for-byte unchanged (git status clean).
Prompt tuning: my first prompt used "Beach Trip 2024" as its example JSON, and suddenly every photo was a "Beach Vacation". Archives and order confirmations were also landing in Installers. I fixed it with a neutral example, a one-line hint per category, and "never invent dates, places or events".

Why Does Open Innovation Matter?

My files never leave my laptop. Downloads holds invoices, resumes, bank statements and screenshots of who knows what. Sending previews of all of that to a cloud API every night is exactly what I don't want. With Ollama on localhost, nothing goes over the network. No closed API would have let me do this without second thoughts.
It works offline. It's a 3 AM job, and the laptop may not even be online then. A local model doesn't care.
$0 forever. No API key, no usage bill and no rate limit. That also meant I could re-run the whole folder over and over while tuning the prompt, at zero cost.
Swap the brain with one flag. If a better small model comes out next month, I change one word.

My Agent Session

The Lazy Payoff

Set it up once:

schtasks /create /tn slothsort /sc daily /st 03:00 /tr "python `"$PWD\slothsort.py`" `"$env:USERPROFILE\Downloads`" --apply"

From then on, Downloads sorts itself every night while I sleep. About 2 s per file once the model is loaded, and if it ever gets something wrong, undo puts everything back. Peak sloth. 🦥

Prize Categories

Semantic Chaos Monkey: Testing Ambiguous AI Instructions 🐒

Heramb Inamke — Thu, 15 Oct 2026 06:45:56 +0000

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

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

What I Built

What if an instruction is technically correct but still dangerous to execute?

Consider this deployment instruction:

Reset the database, migrate the schema, and restore the latest backup if necessary.

It sounds straightforward. But which database should be reset? What does “latest” mean? When exactly is a restore necessary?

Different engineers—or AI agents—could interpret the same instruction differently and produce entirely different action sequences. In an infrastructure environment, that ambiguity can have serious consequences.

That's the problem I'm tackling with Semantic Chaos Monkey (SCM), an AI-assisted adversarial testing platform designed to identify ambiguity in operational procedures and AI-agent instructions.

Instead of merely checking whether an instruction reads well, SCM is designed to:

Generate multiple plausible interpretations of an instruction.
Validate proposed action sequences against a defined set of allowed operations.
Simulate their consequences using deterministic, synthetic environments.
Compare execution traces and identify meaningful differences.
Suggest clearer instructions and retest them against the same safety rules.

The core idea is simple: test what an instruction could cause, not just what it appears to mean.

Who could benefit from it?

SCM is intended for DevOps engineers, AI-agent developers, platform engineering teams, and organizations that rely on operational runbooks.

For a startup, it could eventually help catch ambiguous deployment procedures before they reach production. For an AI engineering team, it could provide a reproducible way to test whether an agent's instructions leave room for conflicting interpretations.

The product is being designed with a local-first approach, keeping the initial testing environment isolated from real infrastructure.

Demo

Project status: Product definition and MVP development.

The complete end-to-end workflow is not yet verified as a working demo. The repository documents the proposed architecture, requirements, safety constraints, and implementation plan.

GitHub repository: https://github.com/HerambInamke/week-2-DEV-Challenge

I'll update this section with a live demo or walkthrough when the working MVP is ready.

Code

🔗 GitHub: https://github.com/HerambInamke/week-2-DEV-Challenge

The repository is released under the Apache-2.0 license.

The project structure includes:

client/ — React and TypeScript frontend with Vite and Tailwind CSS.
ai/ — Python AI engine, schemas, fixtures, documentation, and tests.
backend2/ — Additional backend project code.

The intended architecture uses FastAPI and Pydantic for API contracts and validation, a replaceable model-provider interface for AI-generated interpretations, and a deterministic simulation engine for evaluating their consequences.

The focus is not just generating an AI response. It is making the reasoning outcomes testable, reproducible, and reviewable.

How I Built It

I approached SCM as an engineering problem rather than another general-purpose AI chatbot.

The proposed system follows a structured workflow.

1. Generate interpretations

Given an operational procedure, the AI layer proposes three to five plausible interpretations, including assumptions, source references, and ordered actions.

2. Validate the proposed actions

Each interpretation must conform to structured schemas, parameter requirements, preconditions, and a fixed catalog of permitted actions. Unsupported actions are rejected rather than executed through a fallback mechanism.

3. Simulate the consequences

The accepted action sequences are evaluated against identical initial states in a synthetic environment. Deterministic application logic handles the simulated state transitions.

4. Identify divergence

SCM is designed to compare action ordering, affected resources, resulting state, and configured safety invariants. This helps distinguish harmless wording differences from interpretations that could produce materially different outcomes.

5. Repair and retest

The system proposes a clearer version of the original instruction and evaluates the revision against the same configured tests. The intention is to verify whether the identified ambiguity has actually been addressed rather than simply assuming that the rewritten instruction is safe.

Technology stack

The proposed stack includes:

Frontend: React, TypeScript, Vite, and Tailwind CSS.
Backend and API: Python, FastAPI, and Pydantic.
Testing: pytest and structured test fixtures.
Storage: SQLite for the initial local MVP.
AI integration: A replaceable model-provider interface.

One of the most important architectural decisions is separating AI-generated interpretations from their execution.

The model proposes possible meanings; deterministic application logic validates and simulates their consequences. The initial scope excludes production credentials, live infrastructure changes, unrestricted shell execution, and real deployment operations.

A language model suggesting an action sequence is not proof that the sequence is safe. SCM is being designed around that distinction.

Note: The architecture and workflow above describe the intended MVP. They should not be interpreted as a claim that every feature has already been implemented.

Why Does Open Innovation Matter?

Reliable AI systems should not be something only large companies with proprietary infrastructure can investigate.

Open innovation allows developers to inspect the implementation, challenge assumptions, contribute adversarial test cases, extend the simulator, and adapt the approach to their own engineering workflows.

For SCM, openness matters in three specific ways.

Transparency: Engineers should be able to inspect how proposed actions are validated, how simulated outcomes are compared, and which rules determine whether a test passes or fails.

Reproducibility: Saved test cases and execution traces can make it possible to review the same ambiguity without depending on another AI generation producing identical wording.

Flexibility: A replaceable model-provider interface is intended to support experimentation with different models without tying the entire platform to one vendor.

A closed AI API can generate interpretations, but that alone does not provide a transparent, deterministic testing environment tailored to a team's operational rules.

By developing SCM in the open, I want to make it possible for other engineers to challenge the design, contribute test scenarios, and help establish better practices for testing natural-language instructions.

My Agent Session

I'll add a shareable DevRelay agent-session link here once one is available.

Prize Categories

I'll update this section after confirming the applicable categories and eligibility requirements in the official challenge rules.

Final Thoughts

As AI agents become more involved in software development, infrastructure management, and operational workflows, the instructions we give them become increasingly important.

A procedure can look perfectly reasonable while leaving critical decisions undefined. Reviewing the wording alone will not always reveal the consequences of those missing details.

Semantic Chaos Monkey is my attempt to explore a more rigorous approach: turn ambiguous instructions into testable scenarios, compare their consequences, and verify proposed corrections.

The project is still taking shape, and there is plenty of engineering work ahead. I'm sharing it early because open-source feedback can help challenge the assumptions and improve the design before the system grows further.

If you're working on AI agents, DevOps, or software reliability, I'd welcome your feedback and contributions.

🔗 Explore the project: https://github.com/HerambInamke/week-2-DEV-Challenge

Hacktoberfest #OpenSource #ArtificialIntelligence #AIAgents #DevOps #SoftwareEngineering #OpenInnovationeam Submissions: Please pick one member to publish the submission and credit teammates by listing their DEV usernames directly in the body of the post. -->