DEV Community: Dreven

Let your wild ideas ferment: a quiet garden powered by local Gemma

Dreven — Thu, 22 Oct 2026 15:12:20 +0000

Built for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

Some ideas are too odd to schedule and too interesting to delete.

Compost Club is for people who collect fragments of side projects and would rather explore one new connection than turn every note into a task. Add two scraps, ask local Gemma for one possibility, and decide whether it deserves to grow.

My projects already contain ideas worth revisiting. Scriptorium studies how a text is written. Quillgrain carries a writing voice between tools. They solve different problems, but what might grow between them? I built Compost Club to give those unfinished connections another small chance.

Drop a few scraps into a cozy garden. Let local Gemma combine two of them into one new concept. Read where it came from, keep what makes you curious, or compost it again with its roots attached. A friendly worm named Wiggle supervises absolutely nothing.

A kept idea can now grow a small branch, too. Ask Gemma to clarify its mechanism, add a constraint, explore an alternative, or suggest a one-day experiment. Each step waits for your review.

The garden has a deliberately slow rhythm: one welcome pairing, then another slot every fifteen minutes, up to three. Closing the tab earns time credits. Generation happens only when you ask for it. Nothing withers while you are away.

That is my interpretation of Slow and Steady: give a neglected idea a gentle next step without turning it into another daily obligation. There are no streaks, upgrades, payments, or productivity scores.

The lazy payoff

My ten project cards offer 45 possible pairs. I do not have to enumerate them or write a new prompt for each: the garden selects an unused pair, Gemma proposes one connection, and I review it. That is the effort this build aims to remove, rather than the decision about what is worth making.

The example below took about 8.5 seconds of local inference. I kept it as a candidate for further exploration. That is an observed run, not a measured productivity saving or evidence that all 45 pairings would be useful.

Demo

Watch the demo.

The short English demo shows the actual application with ideas taken from my public projects. It opens the two source cards, shows Echo Cartography, keeps it, then follows two earlier discoveries back into the compost pile. The cream paper, small flowers, and hand-drawn garden are part of the invitation to slow down.

The result came from a fresh local Gemma 3 4B run on English summaries of two real repositories: Scriptorium and Quillgrain. The summaries retain source links and describe current limits as well as the ideas behind each project. Gemma's unedited concept was:

Scriptorium's reading observatory is layered with Quillgrain's voice packs, generating a dynamic 'cartography' of a text’s evolution across drafts, highlighting shifts in vocabulary and tone through visualized, context-aware measurements.

I can see a practical possibility: an editor comparing drafts could notice where a revision changes the author's voice. That is why I chose this result for the demo. Echo Cartography is an idea proposed by Gemma, not an implemented editor, a paying customer, or a claim that demand has been validated.

The walkthrough then switches to a separate saved garden containing Lexigraph and ClawPulse, two other genuine local results. Clicking Compost again turns them into two new source scraps: twelve scraps instead of ten, with their parent links intact. No second-generation blend is claimed. The scenes were filmed from validated saved gardens; no fresh inference click or waiting animation was staged for the camera.

Making the demo also improved the product: I folded the composer, paged long piles, and put both source texts side by side. The walkthrough needs no scrolling, while full text remains available. Its English voice, gentle guitar and floral frame are presentation elements; the actions inside are the real application.

The downloadable public sample is a separate experience: seven visibly labelled, unchanged recordings on fictional inputs, playable without a model download, including as a self-contained offline HTML file. Custom scraps need explicit local inference setup. Browser AI remains experimental.

From an interesting idea to a small next step

After keeping Echo Cartography, I chose Tend this idea and asked for a one-day experiment. Local Gemma proposed Draft Timeline Exploration: take a 100-word passage, make three draft versions, and chart vocabulary and tone changes on a whiteboard. I accepted the branch, saved it, and verified that it survived a reload. The proposed whiteboard experiment itself has not been carried out.

An accepted branch can become the parent of another request. Asking again from the same parent creates an alternative. Original responses, human edits, and parent snapshots stay separate. Accepting spends one ready slot; rejection, cancellation, failure, and no_growth keep it. This is the first small branching workflow; it runs when asked, with a person deciding what grows.

The video above shows blending and recomposting. This screenshot shows the newer tending workflow.

Code

Repository and local setup · Model experiments and raw evidence · Known issues and roadmap

To try the labelled sample, use Node 24 and npm 11:

git clone https://github.com/drevendev/CompostClub.git
cd CompostClub
npm ci
npm run dev

Open the printed local URL and choose Try the sample garden. This route needs no model download. For fresh ideas, follow the separate live local Gemma setup.

The application and original SVG illustrations are MIT-licensed. Gemma weights have their own terms and are not bundled with the app.

How I Built It

The UI uses React, TypeScript, and Vite. The garden rules live in a separate domain layer, independent of React and the inference runtime. IndexedDB stores the pile and discoveries; Markdown exports and validated JSON backups provide portable copies.

Gemma handles two bounded requests: blend two scraps into a concept with a source fragment from each, or propose one continuation of a kept idea. It receives no tools, shell, or archive search. The app renders input and output as text.

The model experiments changed the design

My first prompt asked Gemma 3 1B to choose exact quotations from both parents. All 24 predetermined runs failed the final output contract. Paraphrasing a source made sense linguistically, but broke the provenance requirement.

The next version moved that mechanical work into code. The app selects short exact fragments and constrains those fields in the JSON schema; the model concentrates on inventing the concept.

Local experiment	Runs passing the shipped structural validator
Ollama Gemma 3 1B, first prompt	0 / 24
Ollama Gemma 3 1B, revised prompt	23 / 24
Ollama Gemma 3 4B, revised prompt	24 / 24
Browser Gemma 3 270M and 1B, small combined smoke set	0 / 4

The Ollama set contains twelve public source-pair combinations, each run twice. Tuning reused the original holdout combinations, so these numbers describe a small regression experiment, not general performance on unseen ideas. The browser row is a separate, smaller experiment with a different runtime and setup.

The 4B pass needed no repair calls. On the tested Windows machine, Ollama selected CPU inference; its median call latency was about nine seconds. That is a measured result from one machine, not a hardware requirement or a promise about other devices.

For this new demo I also ran ten additional pairings from my public-project cards, after the first Lexigraph result. All ten passed the structural contract without repair. Human review still excluded three: one leaked field-like fragments into its concept, while two assumed evidence the source cards did not contain. Echo Cartography took about 8.5 seconds in its local run. These selected exploratory cases are not a held-out evaluation or proof of general creative quality.

The browser models genuinely loaded and generated with WebGPU. Their four outputs failed the contract, so browser AI stays visibly experimental. Those failures remain in the evidence. A failed call never becomes a successful recording behind the scenes.

Even 24/24 valid responses does not mean 24 useful ideas. Some concepts were weak, and some Russian requests returned English. Human usefulness review and a fresh unseen evaluation set are still open. The seven sample recordings are a selected subset; the remaining results are retained.

A garden also has to remember

The application preserves raw source revisions and the original model responses. Editing a scrap does not rewrite the parents of an older discovery. Saving a sprout, consuming its pair, and spending its slot happen atomically. Errors, cancellation, and a model's no_blend response keep the slot.

Recovery matters here because the scraps are the user's contribution. Backup validation, competing-tab checks, restore conflict detection, and cascade previews for deletion all protect that contribution. The current checks cover 97 unit tests, three HTTP/Sentry regressions, and 32 Chromium journeys, including growth review and privacy exports. Those application checks are separate from model-quality evidence.

GitHub Actions takes repetitive release checks off my hands. The Repository checks workflow installs pinned dependencies, runs verification, builds the app and standalone sample, and exercises recovery, pairing workflows and the Pages subpath in Chromium. The successful post-merge run includes the tending workflow and optional Sentry adapter.

Watching a local model without collecting its ideas

I connected Sentry Agent Tracing to the Node bridge as optional technical monitoring. It is off by default, and the connection status shows when the operator enables it. The browser and offline HTML contain no Sentry client. The adapter and removal instructions keep it independent of the garden's data and local inference.

On a fresh tending request with the merged code, Sentry recorded 16.43 seconds, 220 input tokens, and 107 output tokens for local Gemma 3 4B. The child span measured about 0.48 ms of bridge-side structural validation. This is a separate request from the earlier 8.5-second blend and the accepted branch above. These are individual observations on my machine, not a benchmark or a measure of usefulness.

The integration exposed two mistakes. Provider-side enrichment initially added location fields, so I added explicit IP anonymization and recursive server-side scrubbing, then checked the stored result. Review also caught a validation span starting after the check; moving the check inside it made that timing meaningful. The screenshot uses a fresh trace after both fixes. Uploaded events contain technical metadata, with idea text, prompts, outputs and raw errors excluded.

There is no hosted model API charge for those tokens: inference runs locally. Hardware, electricity, and the operator's Sentry plan are separate costs, not measured by this trace. Turning monitoring off and restarting the bridge stops new telemetry; removing the adapter needs no garden migration.

Why Does Open Innovation Matter?

The core interaction can run on a machine the user controls. Ollama generation stays behind a loopback-only bridge. Scraps live in the browser, and the app needs no end-user account or hosted inference API. Optional Sentry monitoring sends technical metadata only when the operator enables it; local generation, saved gardens, and backups work with it off.

Initial dependency and model downloads still need a connection and explicit setup. The optional browser-model download contacts the disclosed model hosting endpoints. The offline sample contains recordings rather than weights or live inference.

Open weights made it possible to compare model sizes locally and keep the failed experiments inspectable. Open application code makes the rest inspectable too: the prompt, validator, pairing rules, storage boundaries, and record of what actually ran. The model licence remains separate from the code licence.

Compost Club is an experimental local application. It offers a small next step: put two unfinished thoughts together, read one possibility, and decide whether to keep it. Then close the tab. The garden can wait.

Prize Categories

Best Use of Gemma — Gemma provides the central idea-blending interaction through genuine local Ollama runs, including Echo Cartography. The separate offline sample replays exact Gemma 3 4B results.
Best Use of GitHub Copilot — entered through the GitHub Actions automation route explicitly listed in the published category criteria. Repository checks automate builds, standalone packaging and Chromium acceptance; the linked workflow and successful run show the actual use.
Best Use of Sentry Agent Tracing — the optional local-model integration records real timings and token counts. The trace screenshot, privacy fixes, validation-timing correction and setup/removal notes above show how it is used.

AI assistance was used in implementation, testing, documentation, and preparing this article and demo. Numerical claims above come from the repository's recorded experiments and verification reports. Creative usefulness remains a human judgment.

Demo audio credits: “Somewhere Sunny (ver 2)” by Kevin MacLeod (incompetech.com), downloaded from Wikimedia Commons, licensed under CC BY 3.0. Edited excerpt with reduced volume, ducking, and fades. Narration: Kokoro-82M, Apache-2.0 model distribution, rendered locally with the MIT-licensed kokoro-onnx runtime.

PatchPitch: local Gemma turns patch notes into devlogs and social posts

Dreven — Sun, 18 Oct 2026 23:42:26 +0000

PatchPitch uses local Gemma to turn release notes into devlogs, community posts and short announcements, with voice presets, optional tags and Markdown export.

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

Demo · Code · How it works · Sentry trace

What I Built

A game update can be finished and still leave three writing jobs: explain it to returning players, introduce it to a community, and fit one useful thought into a short post.

I used the real 0.12 patch for Idle Fantasy Shop, my cozy browser game about gathering resources, crafting practical goods and keeping a small shop in Latchford. Its workshop gained a crafting plan, its gathering grounds gained a pressure system, and its save instructions needed careful wording. There was a story in those changes. It needed different shapes for different readers.

PatchPitch is the small local writing studio I built for that job. Select the facts that shipped, choose a format and voice, generate with local Gemma, then review and export Markdown.

Devlog: room for the selected topics and important details.
Community post: a few useful changes in connected prose.
Short post: a 280-character budget including your call to action and suggested tag.

Each request writes one version. Warm, Clear and Lively presets steer its voice; an optional writing sample adds your own rhythm. Auto tags are optional suggestions from the product and selected facts. Each format keeps its latest draft and edits in the current tab, so you can switch between them, remove a tag and take the text with you.

Who might pay for it?

The buyer I have in mind is a solo developer or small studio that ships regularly and handles its own release communications. Their next update needs a coherent release pack, a careful review and copy they can reuse across channels.

The first paid offer I would test is a reviewed pack per release: a devlog, a community post and a short announcement. That could begin as a small service using this MIT-licensed tool. A subscription would need evidence that people return for the next update. So far I have used it on my own game; I have no independent customer or payment results, and the app has no checkout.

Demo

Watch the demo and read the generated drafts

The recorded demo includes captions and all three complete drafts. Direct 63-second MP4.

The film shows fact selection, three generated formats, style controls, auto tags, draft switching, source inspection and Markdown export. Generation waits are shortened and labelled.

It combines two native browser recordings. There were five real model calls across those sessions; three successful outputs are shown. A rejected Community attempt and an unused Short remain in the evidence. No saved response was replayed into either UI, and the model's prose was not rewritten.

Here is one small detail worth getting right. The technical input distinguishes gathered materials from craftable goods:

New content counts: 3 gathered raw materials plus 7 craftable goods = 10 new items total. Only the seven goods are craftable.

The full generated devlog says:

We have added 10 new items in total, consisting of 3 gathered raw materials and 7 craftable goods.

The short format has a different job. This is its untouched body:

Idle Fantasy Shop now features Crafting Batches in the Workshop. Access requires level 10. Export a backup from Settings before changing devices or clearing browser data.

With my supplied CTA and Gemma's suggested tag, the post was 252 characters. The film removes the tag and exports the remaining text; copy and download match exactly. It keeps Settings and both backup circumstances, while leaving out the full crafting limits. The UI flags unreferenced notes and missing numeric particulars for review.

Code

drevendev / PatchPitch

Turn selected changelog facts into a source-linked announcement draft with local Gemma.

PatchPitch

Your product deserves a great story.

Turn selected changelog facts into an announcement people understand. Describe your product and audience, choose what shipped, generate with local Gemma, inspect the sources, edit and export Markdown. A small writing workflow with a human final edit.

Recorded demo · 63-second video · Build story on DEV

The hosted demo shows real recorded Gemma outputs; generation runs locally using the setup below.

Run locally

Python 3.11+ and Ollama are required. Tested on Windows 11 with Python 3.12.14 and Ollama 0.40.6. The source is MIT licensed.

python -m venv .venv
.\.venv\Scripts\python.exe -m pip install -r requirements.txt
ollama pull gemma4:12b
.\.venv\Scripts\python.exe -m uvicorn patchpitch.app:app --host 127.0.0.1 --port 8000

Start Ollama, then open http://127.0.0.1:8000. On Linux/macOS use .venv/bin/python in place of .venv\Scripts\python.exe.

The upstream is fixed to 127.0.0.1:11434. Set PATCHPITCH_MODEL to an…

View on GitHub

drevendev/PatchPitch — MIT. The verified implementation is 38619a8; its GitHub Actions run passed 121 tests. Automated tests use mocked inference or an offline transport; the recorded model calls are separate evidence.

The README has the setup commands: Python 3.11+, Ollama, the selected Gemma model and the pinned Python requirements. The app runs at 127.0.0.1:8000; Ollama stays on loopback. The 12B default needs enough local memory, and another model needs its own writing-quality check.

The film was recorded on 78e44f8. Later changes add the example-loading fix, optional Sentry tracing and a curly-apostrophe validation fix; its prompts and generated words are unchanged. A hosted recording is a way to inspect the product; real generation runs locally.

How I Built It

FastAPI, Pydantic and vanilla HTML/CSS/JavaScript handle the flow. Unchecked notes stay out of the model payload. Gemma receives selected factual units, a separate voice brief and a JSON schema for the response. Source IDs connect the result to the notes a person can inspect.

I prepared the example notes from Idle Fantasy Shop's actual 0.11.1 → 0.12 code patch, with commit and file references. PatchPitch receives those notes; automatic Git import is still backlog. The tone brief comes from in-game item descriptions. The original devlog was comparison material only: its prose is absent from the model input.

The recorded model was gemma4:12b through Ollama 0.40.6, using direct generation for all three formats. The selected requests took 74.7s for Devlog, 12.7s for Community and 4.5s for Short on this machine. Those are observations, not a speed promise.

Real attempts exposed useful failures: a draft called all ten items craftable, another dropped backup circumstances, and a wording check rejected queue capacity as if it promised simultaneous work. I clarified the source notes and improved the schema, prompts and targeted checks. In the full devlog, each assigned source ID is emitted before its paragraph to keep topics in their own slots. Failed and rejected attempts are retained.

These checks establish structure, budgets and specific wording constraints. They cannot establish semantic truth. The full draft covers all eight selected topics, but parts are more functional than the original devlog's warmer editorial writing. The result still says Draft — review before publishing. Source inspection and the maker's final edit belong in the workflow.

Seeing where the time goes with Sentry

Optional Sentry instrumentation records the generation, actual Ollama call and validation. A separate real run on the public fictional Pocket Orchard example produced this trace:

The model call took 15.064s; validation took 4.015ms. Ollama reported gemma4:12b, 1,590 input tokens and 302 output tokens. Almost all the recorded time went into the model request. No metered inference API was used; local hardware and electricity still have a cost. Sentry's comparison badge reflects these diagnostic samples, not a controlled benchmark.

A separate CONTROLLED_FAILURE fed a saved draft containing a TODO placeholder into validation. It produced invalid_draft and a linked error event, with no fabricated inference span.

The SDK is off without an explicit DSN. Automatic integrations are disabled, and events plus final transport envelopes use a small metadata allowlist. I inspected the actual HTTP bodies for source notes, output prose and private context. Received-event review also caught Sentry's IP-derived geography enrichment: I enabled IP scrubbing and explicit geo removal, then verified a fresh validation-only event had no User/Geography context. The trace and checks were captured separately after the film.

Why Does Open Innovation Matter?

The open-weight model does the actual writing. Once its weights and the application are installed, the writing flow can run locally without a hosted copywriting API. Upcoming changes and an unpublished tone sample can stay on the developer's machine. Fonts are local too; Sentry is a separate opt-in metadata export.

The prompt, schema and adapter are inspectable. I could change generation settings and investigate failed responses while keeping the writing step local. The model is replaceable, although equal output quality would need testing. Gemma's weights are downloaded separately and are not relicensed by PatchPitch's MIT license.

BeautifulRepo's release-note guide informed the reader-first approach and attention to limitations; attribution is retained. Codex assisted development and the write-up. The film uses local Kokoro narration and original procedural music.

Prize Categories

Best Use of Gemma: real local inference writes all three formats.
Best Use of GitHub Copilot, via GitHub Actions: the category explicitly includes Actions automation. Our test workflow runs unit, API and browser checks on pushes and pull requests. Our manually dispatched Pages workflow publishes the approved demo. Codex was the coding assistant.
Best Use of Sentry Agent Tracing: real model and validation spans, observed latency and tokens, a labelled controlled error, and an inspected privacy finding.

Which part of release writing takes you longest: choosing what to include, checking the facts, or adapting the same update for different channels? I would like to hear how you handle it today.

Your product deserves a great story.