DEV Community: x t

séance: I let a Gemma ghost haunt my shell (and built it an ofrenda for my deleted files)

x t — Wed, 28 Oct 2026 03:06:11 +0000

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

👻 ezequiel › make test again, you foolish mortal? Exit code two; a familiar echo of my own demise.

That line was written by a 4-billion-parameter model running on the CPU of a small Linux VM, about three
and a half seconds after my test suite failed for the second time in a row. No network request left
the machine to produce it. That's the whole project, really: a ghost that lives inside the machine,
in the most literal way I could manage.

What I Built

séance is a haunted terminal. You add one line to your .bashrc (or .zshrc), and from then on
your shell is shared with Ezequiel, a sysadmin who died in 1999 halfway through an fsck and
never left the server room. After each command he whispers, in one or two sentences, what he thinks
of what you just did.

Yes, the "haunted terminal" is the first idea on the challenge's own list. I couldn't resist it, so I
tried to make it mean something:

He remembers. Every session keeps a short memory (redacted, on disk, local). He knows this is your second make test, and he'll bring up the exit code 2 from three commands ago.
He reads omens. Before the model is asked anything, plain Python works out what's actually going on: exit 127 means "command not found", 137 means SIGKILL, this is the 4th failure in a row, this command deletes things, this one is sudo. Gemma gets those facts; it only has to be eerie.
Apparitions. Delete files and a tombstone rises. Kill a process and a calavera (sugar skull) grins at you. git push --force gets a ghost. sudo gets a watching eye.
Possession. The more ominous things get (failure streaks, destructive commands), the more likely the terminal is to glitch, with Zalgo text and block noise, while the ghost "stirs".
seance ofrenda, for Día de los Muertos. An altar of candles and marigolds for everything that died on your machine: files you rm'd, processes you killed or that got SIGKILLed, git branches you deleted, and the almas en pena, branches left untouched for months. Gemma writes a short remembrance for each one. It reads your shell history, the séance graveyard, the freedesktop Trash and the repo's reflog, and it never modifies any of them.

It's a pipx-installable Python package with zero dependencies, it works fully offline, it has no API
keys, and it's MIT-licensed.

Demo

The GIF above is a real recording: real bash, the real hook, and gemma3:4b answering live. The keystrokes
are typed by a small script (scripts/demo.py), so anyone can reproduce the recording. The only
editing is that pauses longer than 1.5 s are shortened. The latency under each whisper is what séance
measured at the time.

Possession: the second failing make test makes the terminal glitch while the ghost stirs.

Omens and apparitions: rm -rf raises a tombstone, and a SIGKILLed training script gets a calavera.

The ofrenda: remembrances for a deleted hotfix branch, a SIGKILLed process, two deleted files,
and an abandoned experiment/rewrite-in-rust branch, 117 days old.

A few lines from that recorded session, verbatim:

👻 ezequiel › gti status. The command is a phantom, like my existence – it simply doesn't exist.

🕯️ experiment/rewrite-in-rust [alma en pena · abandoned branch · 117 days ago]
Poor experiment/rewrite-in-rust. It wrestled with grand ambitions, a tangled promise of rust, then simply vanished into the depths of the repository.

🕯️ ~/crypt/build [archivo · file]
The build folder, a tireless worker, finally rests. May marigold petals guide its code back to Mictlan, a gentle farewell to its frantic efforts.

The typo one got me. I typed gti on purpose for the demo, and I still laughed.

Code: https://github.com/Tx13758627780/seance-sh

ollama pull gemma3:4b
pipx install git+https://github.com/Tx13758627780/seance-sh
echo 'eval "$(seance init bash)"' >> ~/.bashrc

How I Built It

The shape of it

bash/zsh hook ──(command, exit code, start time, cwd)──▶ seance whisper
   omens.py   deterministic facts: exit meanings, streaks, repeats, deaths, which apparition
   memory.py  last N commands this session (JSONL, secrets redacted) + a graveyard of deaths
   ghost.py   persona + memory + omens → POST /api/chat (streaming) → Ollama → Gemma 3
   effects.py "the ghost stirs" glitch while waiting → whisper streams in, word-wrapped

The bash hook uses a DEBUG trap to catch the command and its start time, plus PROMPT_COMMAND to
call seance whisper with the exit code once the command finishes. zsh uses preexec/precmd. The hook
keeps your $? intact, skips tab completion, and doesn't re-whisper the previous command when you just
press Enter. That last bug took me longer than any of the AI parts.

Why Gemma, and which Gemma

I benchmarked both small Gemma 3 models through Ollama with séance's real prompt (persona, memory,
omens), 14 runs each, on the only hardware I had for this: a Linux VM with 8 vCPUs (Intel Xeon),
16 GB of RAM and no GPU. Ollama confirms it's running on CPU.

model	cold start (load + first reply)	first word, warm (median)	full whisper, warm (median)	RAM (`ollama ps`)
gemma3:1b	3.08 s	0.90 s (0.70–1.13)	1.78 s (1.41–2.34)	1.2 GB
gemma3:4b	6.79 s	1.90 s (1.38–2.75)	3.58 s (2.54–5.90)	2.9 GB

The 1B model is twice as fast, but in my testing its whispers were generic. They were spooky in the
abstract, but they often ignored the actual command. The 4B model reliably names the
file, the branch or the exit code, and that's what makes it feel like someone is watching. So
gemma3:4b is the default, and SEANCE_MODEL=gemma3:1b is one environment variable away if your
machine is slower or you want a ghost that talks faster. In the recorded demo session, the 7 whispers
had a median of 1.80 s to the first word and 3.15 s for the full whisper.

The benchmark script is in the repo (scripts/bench.py), so you can measure your own machine instead
of trusting mine.

Hiding latency: make the waiting part of the haunting

Three seconds of nothing after every command would feel broken. So séance streams the response and, until the
first token arrives, plays a glitching ░▒▓ the ghost stirs ▓▒░ line that dissolves into the whisper.
The whisper is then typed out as it streams, word-wrapped with a hanging indent. The roughly
1.9 s wait for the first word stops feeling like lag and starts feeling like the ghost gathering itself.

For when you actually need to work, SEANCE_RATE=0.3 keeps him quiet on calm, successful commands
(failures and destructive commands always get a whisper), and SEANCE_HUSH=1 silences him entirely.

Prompting a small model

Some things I learned, in roughly the order they bit me:

Gemma has no system role. Gemma's chat format only has user and model turns, so I fold the persona into the first user turn myself instead of relying on how a server template treats a system message.
Small models need facts, not puzzles. Asking "what does exit code 137 mean?" invites hallucination. Telling the model "Omens you sense: killed by SIGKILL (137); this is the 2nd failure in a row" gives it something true to be dramatic about. This is the single biggest quality improvement I made.
Few-shot beats adjectives. Four example whispers in the persona did more than any amount of "be eerie, be specific, be concise".
Clean the output defensively. The model sometimes echoes the prompt format back ("make test (exit 2) – …"), adds markdown, or rambles. A small clean() step strips that and caps the whisper at two sentences. An earlier version of that step also stripped the underscores out of notes_from_last_halloween.txt, which was its own small horror.
Variety for the ofrenda. Each remembrance gets a different "angle" (an offering left on the altar, a tiny eulogy from its old friends in the codebase, marigold petals guiding it home…). Otherwise five epitaphs in a row all start with "Rest now".

It isn't perfect. Ezequiel brings up his own death a lot, and sometimes he invents history ("the
last time you checked for disks"). For a ghost, I've decided that's in character.

Privacy, carefully

Shell history is about as private as data gets: hostnames, paths, typo'd passwords. Before anything is
stored, séance redacts *TOKEN*/*SECRET*/*PASSWORD* variables, --password flags, Authorization:
headers, user:pass@ URLs, and GitHub, OpenAI, Hugging Face and AWS-style keys. There are tests for
this. And then it only ever sends that redacted text to 127.0.0.1.

Why Open Innovation Matters

Because the ghost reads your shell history. I would never pipe every command I type, with its
paths, hostnames and the odd password pasted in the wrong window, to someone else's API to get a joke
back. With an open-weight model it never has to leave the box. séance talks only to
http://127.0.0.1:11434. You can unplug the network cable and the haunting carries on. I measured
every number in this post on a machine with no GPU.

Because it costs nothing to be haunted. An always-on shell companion makes a model call after
every command. With a hosted API, that's a meter running all day. Locally it's 2.9 GB of RAM and a few
seconds of CPU per whisper (about 3.6 s median for gemma3:4b, 1.8 s for gemma3:1b on my 8-vCPU VM).
There's no key to leak and no bill.

Because the model is swappable. The 1B-vs-4B trade-off above was a decision I got to make,
with my own benchmarks, on my own hardware. Next year it'll be a different model, and switching is one
environment variable: SEANCE_MODEL=<anything Ollama can run>. No vendor decides that a fun but
pointless app is no longer worth serving.

Because things you depend on should outlive the company that made them. That one fits the theme a
little too well. An ofrenda is about remembering what's gone. I didn't want to build one that would join
it the day an API was deprecated. Gemma's weights are on my disk. As long as Ollama, or llama.cpp, or
whatever comes after them can load a GGUF, Ezequiel stays.

Where it was worse than a closed frontier model: latency and polish. A big hosted model would
whisper faster and repeat itself less. But a faster ghost that phones home with your shell history
isn't the ghost I wanted.

Prize Categories

Best Use of Gemma: Gemma 3 (gemma3:4b by default, gemma3:1b optional) run locally through Ollama
is the ghost. It writes every whisper and every ofrenda remembrance, grounded by deterministic omens
and benchmarked on CPU-only hardware.

Thanks for reading. If you install it, run seance ofrenda on Nov 1 or 2. The altar notices the date. 🕯️🌼

— xt

séance: I let a Gemma ghost haunt my shell (and built it an ofrenda for my deleted files)

x t — Tue, 27 Oct 2026 02:59:33 +0000

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

👻 ezequiel › make test again, you foolish mortal? Exit code two; a familiar echo of my own demise.

What I Built

Yes, the "haunted terminal" is the first idea on the challenge's own list. I couldn't resist it, so I
tried to make it mean something:

He remembers. Every session keeps a short memory (redacted, on disk, local). He knows this is your second make test, and he'll bring up the exit code 2 from three commands ago.
He reads omens. Before the model is asked anything, plain Python works out what's actually going on: exit 127 means "command not found", 137 means SIGKILL, this is the 4th failure in a row, this command deletes things, this one is sudo. Gemma gets those facts; it only has to be eerie.
Apparitions. Delete files and a tombstone rises. Kill a process and a calavera (sugar skull) grins at you. git push --force gets a ghost. sudo gets a watching eye.
Possession. The more ominous things get (failure streaks, destructive commands), the more likely the terminal is to glitch, with Zalgo text and block noise, while the ghost "stirs".
seance ofrenda, for Día de los Muertos. An altar of candles and marigolds for everything that died on your machine: files you rm'd, processes you killed or that got SIGKILLed, git branches you deleted, and the almas en pena, branches left untouched for months. Gemma writes a short remembrance for each one. It reads your shell history, the séance graveyard, the freedesktop Trash and the repo's reflog, and it never modifies any of them.

It's a pipx-installable Python package with zero dependencies, it works fully offline, it has no API
keys, and it's MIT-licensed.

Demo

Possession: the second failing make test makes the terminal glitch while the ghost stirs.

Omens and apparitions: rm -rf raises a tombstone, and a SIGKILLed training script gets a calavera.

The ofrenda: remembrances for a deleted hotfix branch, a SIGKILLed process, two deleted files,
and an abandoned experiment/rewrite-in-rust branch, 117 days old.

A few lines from that recorded session, verbatim:

👻 ezequiel › gti status. The command is a phantom, like my existence – it simply doesn't exist.

🕯️ experiment/rewrite-in-rust [alma en pena · abandoned branch · 117 days ago]
Poor experiment/rewrite-in-rust. It wrestled with grand ambitions, a tangled promise of rust, then simply vanished into the depths of the repository.

🕯️ ~/crypt/build [archivo · file]
The build folder, a tireless worker, finally rests. May marigold petals guide its code back to Mictlan, a gentle farewell to its frantic efforts.

The typo one got me. I typed gti on purpose for the demo, and I still laughed.

Code: https://github.com/Tx13758627780/seance-sh

Home page: seance.tianx.tech

ollama pull gemma3:4b
pipx install git+https://github.com/Tx13758627780/seance-sh
echo 'eval "$(seance init bash)"' >> ~/.bashrc

How I Built It

The shape of it

bash/zsh hook ──(command, exit code, start time, cwd)──▶ seance whisper
   omens.py   deterministic facts: exit meanings, streaks, repeats, deaths, which apparition
   memory.py  last N commands this session (JSONL, secrets redacted) + a graveyard of deaths
   ghost.py   persona + memory + omens → POST /api/chat (streaming) → Ollama → Gemma 3
   effects.py "the ghost stirs" glitch while waiting → whisper streams in, word-wrapped

Why Gemma, and which Gemma

model	cold start (load + first reply)	first word, warm (median)	full whisper, warm (median)	RAM (`ollama ps`)
gemma3:1b	3.08 s	0.90 s (0.70–1.13)	1.78 s (1.41–2.34)	1.2 GB
gemma3:4b	6.79 s	1.90 s (1.38–2.75)	3.58 s (2.54–5.90)	2.9 GB

The benchmark script is in the repo (scripts/bench.py), so you can measure your own machine instead
of trusting mine.

Hiding latency: make the waiting part of the haunting

For when you actually need to work, SEANCE_RATE=0.3 keeps him quiet on calm, successful commands
(failures and destructive commands always get a whisper), and SEANCE_HUSH=1 silences him entirely.

Prompting a small model

Some things I learned, in roughly the order they bit me:

Gemma has no system role. Gemma's chat format only has user and model turns, so I fold the persona into the first user turn myself instead of relying on how a server template treats a system message.
Small models need facts, not puzzles. Asking "what does exit code 137 mean?" invites hallucination. Telling the model "Omens you sense: killed by SIGKILL (137); this is the 2nd failure in a row" gives it something true to be dramatic about. This is the single biggest quality improvement I made.
Few-shot beats adjectives. Four example whispers in the persona did more than any amount of "be eerie, be specific, be concise".
Clean the output defensively. The model sometimes echoes the prompt format back ("make test (exit 2) – …"), adds markdown, or rambles. A small clean() step strips that and caps the whisper at two sentences. An earlier version of that step also stripped the underscores out of notes_from_last_halloween.txt, which was its own small horror.
Variety for the ofrenda. Each remembrance gets a different "angle" (an offering left on the altar, a tiny eulogy from its old friends in the codebase, marigold petals guiding it home…). Otherwise five epitaphs in a row all start with "Rest now".

It isn't perfect. Ezequiel brings up his own death a lot, and sometimes he invents history ("the
last time you checked for disks"). For a ghost, I've decided that's in character.

Privacy, carefully

Why Open Innovation Matters

Prize Categories

Best Use of a .tech Domain: séance's home page lives at seance.tianx.tech, on a .tech domain I claimed through Hacktoberfest. It has the live demo, install steps and benchmarks.

Thanks for reading. If you install it, run seance ofrenda on Nov 1 or 2. The altar notices the date. 🕯️🌼

— xt

SlothCommit 🦥: An Open-Weight AI That Writes Your Commit Messages So You Don't Have To

x t — Tue, 20 Oct 2026 03:29:17 +0000

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

What I Built

Every developer knows the moment. The code is done. The tests pass. And then you sit there, staring at an empty commit box, trying to summarize three hours of work in one line.

fix stuff you type. You delete it. update code. Delete. changes. Delete.

SlothCommit 🦥 removes that moment entirely. Paste your git diff, and it hands you a proper commit message — Conventional Commits, a plain summary, or an emoji-flavored one — plus an optional PR description with What changed / Why / Testing sections.

The laziest part of your workflow, automated. Who gets to be lazier? Anyone who has ever typed wip and pushed.

Demo

Live site: https://commit.tianx.tech — the web UI is live on the .tech domain. Click Try sample diff to see the output format instantly. Full AI generation runs locally (see Run it yourself below) — paste the output of git diff --staged, pick a style, hit Generate.

Video demo:

Code

joemh79 / sloth-commit

🦥 Paste your git diff, get a clean commit message + PR description — powered by open-weight AI

[中文](./README.zh-CN.md) | English

SlothCommit 🦥

Never stare at a commit box again.

Paste your git diff, get a clean Conventional Commit message + PR description — generated by open-weight AI.

Live Demo · DEV Post · Hacktoberfest Week 3: Slow and Steady

Demo

33baf99319051ec48d065b319c9fdf321e22e6ddd20616211c5bf900a3748e78.mp4

What it does

Writing commit messages is the most procrastinated 30 seconds in a developer's day. SlothCommit removes it:

Run git diff --staged in your terminal
Paste the diff into SlothCommit
Get back a proper commit message (Conventional Commits / Simple / Emoji style) + an optional PR description
Copy, paste, done. Back to napping.

How it's built

Frontend: Single zero-build index.html — no framework, no bundler
Backend: Cloudflare Pages Function (functions/api/generate.js)
AI: Llama 3.1 8B Instruct (open weights) via Cloudflare Workers AI — no API keys, no per-token billing
Domain: Deployed on commit.tianx.tech (a .tech domain)

Why open

…

View on GitHub

Zero-build frontend (one index.html), one Cloudflare Pages Function for the API, and an open-weight model doing the thinking. The whole thing is small enough to read over coffee.

How I Built It

Frontend: a single zero-build HTML file — no framework, no bundler, no node_modules folder the size of a small moon.
Backend (local): a tiny Python server (local_server.py, ~100 lines) that forwards prompts to Ollama. No Cloudflare lock-in for the AI path.
AI: Gemma 3 (4B) — open weights from Google — running locally via Ollama. No API key to manage, no per-token bill to dread.
Domain: the web UI is deployed on commit.tianx.tech (Cloudflare Pages, free tier), because a tool this lazy deserves a proper home.

The interesting engineering problem wasn't the generation — it's the guardrails. Left alone, a small model will happily invent file names and add cheerful commentary. The prompt enforces: subject line only per the format, body bullets explain what and why (never how), and output nothing but the message itself.

A note on the architecture: the deployed site serves the UI and a one-click sample. Full AI generation runs against local open-weight models — the same code path, zero data leaves your machine. The deployed Cloudflare Pages Function version is in the repo for anyone who wants to wire it to Workers AI on their own account.

Why Does Open Innovation Matter?

Your diff is your most honest code. It's the half-finished refactor, the internal API you haven't announced, the proprietary logic your company hasn't shipped yet.

Sending that to a closed, per-token API means trusting a third party with your unfinished work — and paying them for the privilege, every single commit, forever.

Open weights change the math:

Privacy by architecture: the model runs on infrastructure you control (or your own machine, if you self-host this). Your uncommitted code isn't training data.
Set up once, pay never: no subscription, no token anxiety. A commit message costs fractions of a cent on Workers AI's free tier — or nothing on a local Ollama install.
It works offline: point the same frontend at a local open-weight model and SlothCommit works on a plane, in a tunnel, during an outage. A closed API can't say that.

The sloth doesn't pay rent on its tree. Your commit messages shouldn't require a subscription either.

The Lazy Payoff

Measured honestly, from my own week:

Before: ~40 seconds of staring + typing + rewriting per commit message, ~15 commits a day.
After: paste, glance, copy — under 10 seconds.
Saved: roughly 7 minutes a day, ~35 minutes a week. Small numbers — which is exactly the point. Sloth-sized savings, every day, forever.

The PR description generator is the bigger win: a structured What/Why/Testing write-up used to take me 3–5 minutes of grudging typing. Now it's one click and a quick review.

Prize Categories

Best Use of a .tech Domain — SlothCommit lives at commit.tianx.tech, deployed on the .tech domain I picked up during Hacktoberfest.

Blog-OS: An Open-Source Blog System with a Local AI Writing Assistant

x t — Sat, 17 Oct 2026 06:05:27 +0000

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

What I Built

Blog-OS is a complete personal blog system with a built-in AI writing assistant. Article management, Markdown editor, site settings, comment moderation — plus an AI helper that suggests excerpts, tags, and titles.

The twist: the AI runs entirely on your own machine via Ollama and Gemma 3 4B (open-weight model from Google). No API keys. No per-token billing. No drafts leaving your laptop.

The Side Hustle

Who would pay: Independent bloggers, newsletter writers, and small content creators who publish regularly in Chinese.

The math is simple. A managed blog with AI features costs:

Ghost Pro + AI add-ons: $15+/month
WordPress hosting + AI plugins: $10+/month + API costs

Blog-OS costs $0/month to run (Cloudflare free tier + local model). The AI assistant saves ~10 minutes per post on the tedious parts — writing excerpts, picking tags, brainstorming titles. For someone publishing 3x/week, that's 2 hours/month saved.

The business: Host it for non-technical bloggers at $5/month. They get a professional blog with AI assistance. I get margin because the AI compute is on their machine, not mine. No GPU bills. No API costs to pass through. The open-weight model is what makes the unit economics work — a closed API would eat the entire $5 in token fees.

Demo

Try it yourself:

Code: https://github.com/joemh79/blog-os (MIT licensed)
Deploy frontend/ to Cloudflare Pages — zero build step, 15 minutes
Admin panel at /admin/ — write in Markdown, click the AI assistant buttons
AI needs Ollama locally: ollama pull gemma3:4b

How I Built It

The open core: Three API endpoints proxy to Ollama's local API (http://localhost:11434):

POST /api/ai/excerpt — Chinese summary from Markdown
POST /api/ai/tags — 3-5 relevant tags
POST /api/ai/title — title suggestions

Prompts tuned for Chinese blog content. If Ollama isn't running, the UI explains how to set it up instead of crashing.

The stack:

Frontend: Pure HTML/CSS/JS, no build. Single config.js for all personal info.
Backend: Single-file Cloudflare Worker + D1. Auth, CRUD, settings, AI proxy — ~600 lines, zero npm dependencies.
63 backend tests passing.

Why Open Innovation Matters for This Build

Three places where "open" isn't a philosophy — it's the reason this works:

The model makes the business possible. If the AI required a paid API, every excerpt/tag/title would cost tokens. At $5/month pricing, API fees would exceed revenue. Gemma's open weights mean the AI runs free, forever, on the user's hardware. Closed AI kills this business model; open AI enables it.
Privacy is the feature. Blog drafts are unfinished thoughts — half-formed opinions, personal stories, unannounced projects. Sending those to a cloud API for a tag suggestion is a privacy leak. Local inference means the AI sees your draft and nothing else does. For writers, that's not a nice-to-have; it's the reason to choose this over a cloud alternative.
No vendor lock-in on the stack. Every line is readable. No minified blobs, no telemetry, no proprietary APIs. If Cloudflare changes pricing, the Worker runs on any compatible runtime. If Gemma gets surpassed, swap in any Ollama-compatible model. The user owns their blog completely.

My Agent Session

Designed and built with Muse (AI assistant) through agent sessions. The 63 backend tests, the AI prompt tuning, and the admin UI were all developed iteratively with AI assistance.

Prize Categories

Hacktoberfest Week 2: Side Hustle (primary)
Best Use of Gemma (Gemma 3 4B via Ollama, local inference)

HI

x t — Fri, 16 Oct 2026 07:24:25 +0000