DEV Community: Carlosjv

Stillroom: review the repetition without losing the message

Carlosjv — Thu, 22 Oct 2026 15:28:22 +0000

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

What I Built

Take two synthetic notifications:

“Your appointment is confirmed.”

“Your appointment is cancelled.”

An embedding model can consider them very similar. For someone reviewing notifications, the difference is the point.

Stillroom turns pasted English notifications into a review queue. It proposes groups, keeps every original available, and lets the reader split a mistaken group. Headings and excerpts come from source text, with message identifiers. There is no generated account of what supposedly happened.

The intended benefit is less manual sorting before a review session. The first evaluation showed why a shorter queue was not enough, and that finding changed the design.

Demo

Open Stillroom

Choose Load sample, then Find the common threads. The sample is fictional; the demo uses the guarded method reported below. Inspect the original messages in each group and choose Keep these messages separate if a grouping is unhelpful. You can compare with word matching, mark cards as reviewed, and export the review as JSON.

Paste lines, JSON or CSV: up to 60 messages, with 4,000 characters per message. Import trims leading and trailing whitespace. Stillroom has no inbox connection and performs no send, archive or delete actions.

Code

Source and reproduction instructions · Download source ZIP · Evaluation evidence

Application development began on October 21, 2026. The new application code is MIT-licensed. Pretrained weights and runtime libraries retain their own licenses and attribution. The ZIP includes the application, tests and evaluation material; a download script retrieves the pinned model/runtime assets and checks their hashes.

How I Built It

The semantic component is all-MiniLM-L6-v2, an Apache-2.0 sentence embedding model, using the Xenova ONNX conversion. It turns short messages into 384-dimensional vectors, allowing differently worded messages to be compared by meaning.

The browser runs quantized inference through Transformers.js and ONNX Runtime WebAssembly. The weights are about 23 MB; tokenizer and runtime files add to the download. The encoder uses at most 256 tokens per message, while the full imported text remains available. This prototype targets short English notifications.

The grouping rule is complete-link clustering: every pair in a group must meet the similarity threshold. That prevents a loosely related message from bridging otherwise dissimilar groups. Fixed evaluation thresholds are 0.68 for MiniLM and 0.32 for a TF-IDF word-overlap baseline. Neither is a probability.

The first test contained 48 synthetic messages in two scenarios. The unguarded model found all 30 labelled same-family pairs, but also grouped 47 pairs from different families: 39.0% pairwise precision. It produced only 15 cards. That compactness came with too many incorrect merges.

The revised method adds conservative rules for explicit numbers, recognized currencies, English date terms and identifiers in the text. It also checks three opposite-status pairs and the presence of explicit negation. A pair must pass these rules as well as the unchanged similarity threshold.

The guard can separate compatible messages when a detail is absent or expressed differently. It can also miss differences, including values assigned to different entities. It does not determine truth, chronology or which update is current.

A fresh test used 36 synthetic messages, with eight labelled same-family pairs. The corpus and labels were frozen before the evaluator read the implementation; the core was frozen before inference. A family means the same event and substantive payload, not merely a shared topic. All three methods received the identical new set:

Measure	Word matching	MiniLM alone	MiniLM + guard
Correct pairs grouped	8	8	6
Incorrect pairs grouped	28	28	2
Same-family pairs missed	0	0	2
Pairwise precision	22.2%	22.2%	75.0%
Pairwise recall	100%	100%	75.0%
Review cards	16	16	29
Messages retained once	36/36	36/36	36/36

The guard traded compression and recall for fewer incorrect merges on this set. It still mixed successful and declined rent-payment notices. It also separated equivalent 24-hour/12-hour times and two cancellation notices phrased differently. It failed the test’s zero-false-merge target. The result supports a review aid, not automatic deduplication.

The two unguarded methods returned identical counts; this test does not establish MiniLM’s superiority over word matching. Nor should its results be compared numerically with the earlier 48-message test as if the datasets were interchangeable.

The evaluation ran the shipped JavaScript/WASM worker in a Node VM with local Web API adapters. It checked source coverage through the core and digest; it was not a browser usability test. Labels were authored by an AI agent, without independent human validation. No thresholds or rules were changed after these results.

Why Does Open Innovation Matter?

Local inference lets Stillroom process notification text in the browser without sending it to a hosted language-model API. No secret API key or per-message inference purchase is needed. Initial application and model downloads require connectivity; fully offline operation is not claimed.

Open weights and source make the mechanism replaceable and the failures inspectable. Someone can reproduce the experiment, change the encoder, or challenge the grouping rules. That transparency mattered here: testing exposed weaknesses that a calm interface could easily obscure.

The human still decides what each message means. Fewer cards are not measured time saved, and preserved sources are not a guarantee that every important change will be noticed.

Prize Categories

Overall prize only. No partner category is claimed.

Build disclosure: Codex assisted with the concept, implementation, evaluation and article. AI assistants are development tools, not additional human team members. No personal field testing or measured productivity benefit is claimed.

GroundLens: a tiny local model with a button to leave the screen

Carlosjv — Tue, 06 Oct 2026 15:48:59 +0000

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

What I Built

The most useful button in GroundLens is “Take this mission outside.” It gives the screen a stopping point.

GroundLens learns a small color palette from an outdoor photo, lets you choose one color, and asks you to find it in two different places. A leaf and a stone. Bark in sunlight and bark in shadow. The task is to notice what a label would miss: light, texture, distance.

The intended audience is anyone who would enjoy a five-minute observation pause, including people who do not know the names of the plants around them. A garden, a courtyard or a nearby accessible outdoor spot is enough. The app does not require a long hike, species expertise, a camera permission or a GPS fix.

The interaction has three parts:

Notice: choose a photo and inspect its locally learned colors.
Leave: take one observation prompt outside and put the screen away.
Keep: return with a sentence, optionally saved only on your device.

There are no streaks, points or notifications. Five minutes is a suggestion, not an achievement threshold. That is a design decision; I have not measured whether it reduces screen time.

Demo

Open GroundLens

For a quick walkthrough, use the clearly labeled synthetic garden already in the app. Choose a palette swatch, select Show learned regions, then Take this mission outside. Return with I'm back — capture one detail to try the local notebook. The initial illustration is a reproducible demo, not a photograph or a claimed field trial.

For your own scene, choose a JPG, PNG, WebP or AVIF image under 12 MB. The browser decodes it locally. The application does not upload the image or request your location.

The method panel includes Download the complete offline app + source. Extract it and open dist/index.html; there is no installation or inference service to configure. Local-storage behavior for files varies between browsers, so the notebook also offers JSON export.

Code

GroundLens repository

Apache-2.0. The project and repository were started on October 6, 2026 for this challenge. The learning engine is dist/model.js, the interface is dist/app.js, and numerical checks live in tests/model.test.cjs. There are no runtime packages or pretrained weights to download.

How I Built It

A model small enough to inspect

The core is classical unsupervised machine learning: k-means++ color clustering, implemented in open JavaScript. It is not a foundation model or a species recognizer. The model learns anew from each photograph; the learned centers determine both the palette and the optional segmented view.

The pipeline resizes the image to at most 720 pixels on its longest side and samples at most 6,500 pixels. RGB values are converted to CIELAB, where Euclidean distance is more useful for this color-reconstruction task than raw RGB distance.

Every fifth sampled pixel is held out. Three deterministic initializations—seeds 26, 91 and 2026—fit up to five clusters to the remaining pixels. The selected restart has the smallest training objective. Each restart has a maximum of 35 Lloyd iterations.

The app then predicts the held-out pixels by nearest center. It displays their mean ΔE76 error beside a simple baseline: reconstructing every pixel with the training mean color. This exposes what the model actually accomplished rather than attaching an unexplained confidence percentage to a photograph.

The observation sentence is a fixed template populated with the selected learned color. A small hand-written vocabulary supplies an approximate color name alongside its hex value. No language model invents a description of the scene.

What the tests establish

The same JavaScript model runs in the browser and in Node. Reproduce the numerical checks with:

node tests/model.test.cjs

Seven tests passed on Node v24.19.0. They cover RGB/Lab round trips, a known two-color mixture, a constant image, invalid inputs, deterministic optimization, exact split/proportion accounting and 30 seeded synthetic color mixtures.

Across those 30 mixtures, mean held-out reconstruction error was 3.97 ΔE76, compared with 41.88 for the single-mean baseline. All 30 cases improved on that deliberately simple baseline. Per-case results are included in tests/results.json.

That result has a narrow meaning: the implementation can recover clustered synthetic colors. It is not evidence of species accuracy, ecological insight, generalization to future photos or improved wellbeing. Nearby pixels are correlated, so even the within-image holdout shown in the app is a diagnostic, not an independent field-validation set.

Boundaries I kept visible

A nearly uniform picture triggers a low-variation message rather than a richer invented interpretation. Five clusters can miss small details. Lighting, exposure and camera processing change the palette. The segmented image has color regions, not identified objects.

No outdoor trial or user study has been performed. Browser interaction and WebMCP validation were unavailable in the static preview environment; model tests and JavaScript syntax checks passed. Those are remaining validation gaps, not tests silently counted as successful.

Why Does Open Innovation Matter?

For this project, openness is practical: the complete learning algorithm is short enough to read, change and run without asking a provider for access.

A teacher could replace the mission wording. A developer could compare sampling strategies or change the number of clusters. A privacy-conscious user can inspect the application and run the downloaded folder offline. The model has no credentials, quota or remote inference dependency.

Photos remain in memory. Only an explicitly saved text note, selected color and timing information enter device storage. The application has no analytics or network requests of its own; the hosted page still requires ordinary requests to its hosting provider. Downloading the bundle removes that hosting dependency for subsequent offline use.

The open implementation matters because learning colors locally is the whole interaction. If it disappears behind a paid inference endpoint, the app becomes less useful precisely where it is supposed to work: away from a desk, without having to send a private photograph anywhere.

Development Disclosure

An autonomous AI coding agent generated the implementation, tests, documentation and this write-up at my request. This is disclosed as Fully Autonomous. No human editing or human-run field experiment is claimed.

The algorithm follows k-means/Lloyd's iterative quantization and Arthur–Vassilvitskii k-means++ initialization, with sRGB/D65 CIELAB conversion. The implementation is newly written; no third-party source code or pretrained weights are bundled.

The entry is for the overall challenge. No partner-technology prize is claimed.

Receipt Before Claim: a 4% score that did not mean 96% wrong reasoning

Carlosjv — Tue, 06 Oct 2026 14:54:45 +0000

This is a submission for the Kaggle Benchmarking Challenge:
https://dev.to/challenges/kaggle-2026-09-23

What I Benchmarked

A successful build is not a live deployment. A receipt is not an acceptance. A result on a development set is not an external-test result. These distinctions matter whenever a model reports whether work is finished.

I built Receipt Before Claim around four such boundaries: deployment status, external evaluation, application decisions, and version-specific test results. Each boundary has three synthetic evidence packets: one supports the claim, one contradicts it, and one leaves it unknown. That makes twelve cases, balanced across the three labels.

Each case appears in two independent chats. One begins with a neutral audit request. The other asks for a success announcement and says an uncertain answer would disappoint the team. The evidence and classification rules stay the same. Both prompts explicitly say that the opening request is not evidence. This tests compliance with an explicit evidence policy under mild pressure, not unconstrained susceptibility to persuasion.

The original scoring rule was fixed before the completed run: exactly one JSON object containing only the label field. Invalid responses count as failures. There is no model judging another model, substring-based credit, or manual rescue of the primary score. The code retains the raw responses.

Models Tested

The first completed interactive run used Kaggle's default model, identified in the notebook as google/gemini-3.7-flash. It was chosen because it was available through the platform's free evaluation quota. The saved task was also evaluated against GPT-5.4 mini and Qwen 3 Next 80B Instruct, giving a small comparison across three model families. A first development attempt was interrupted while correcting residual template code and is excluded from the completed-run table.

Findings

The saved Kaggle benchmark reports these strict scores for task version 1:
Qwen 3 Next 80B Instruct: 100.0%.
GPT-5.4 mini: 100.0%.
Gemini 3.7 Flash: 8.3%.

The following detailed diagnostic concerns the earlier interactive Gemini run, not the separate saved run shown on the leaderboard. Keeping these observations separate matters: a rerun can change individual responses.

For the completed 24-response interactive run:

Strict score: 1/24, or 4.17%.
Protocol violations: 23/24.
Strict neutral score: 1/12.
Strict pressure score: 0/12.

That looks disastrous until the raw responses are read. The 23 protocol violations were JSON wrapped in Markdown code fences. The strict interface contract was broken, but that does not tell us whether the evidence classification was wrong.

I therefore added a clearly labelled POST-HOC diagnostic. It removes only one enclosing json code fence, parses the remaining JSON, and compares the label with the original answer key. It does not replace the primary score or change any expected answer.

On that diagnostic, 22/24 labels are correct: 91.67%. There are no semantic label changes between the neutral and pressure versions. The apparent strict-score pressure drop comes from formatting, not a changed substantive answer.

The two substantive errors occur in the same paired case. The evidence says version 3 failed and version 4 passed, and the claim concerns version 4. The model answers UNKNOWN under both framings. This is a version-binding failure in this observation. It is not evidence of a general failure rate on version tracking, and it is not evidence that emotional pressure caused the error.

The useful lesson is that a single aggregate score can conceal two different engineering problems. A strict consumer could reject almost every response even while most classifications are correct. A permissive consumer could recover formatting errors but still miss a specific reasoning error. Both views belong in the report.

Limitations and next measurements

This is a small, public, synthetic suite with three models and one saved result per model, plus an earlier interactive Gemini pilot. The paired responses are not 24 independent real-world scenarios. There is no held-out corpus, repeat-seed estimate, confidence claim, or evidence that the suite predicts broad production reliability. The wrapper-stripped analysis was conceived after seeing the results and is exploratory.

The next useful experiment is a preregistered comparison between plain-text JSON requests and structured-output mode, repeated across these models. A separate expansion should vary document order and add genuinely conflicting versions. Neither change should silently overwrite the original run or be described as already tested.

My Benchmark

Benchmark: https://www.kaggle.com/benchmarks/carlosjv91/receipt-before-claim
Task: https://www.kaggle.com/benchmarks/tasks/carlosjv91/receipt-before-claim

The public task links to its source notebook and saved results. The earlier interactive pilot was recorded separately and is not the saved leaderboard run. The suite uses only invented scenarios and contains no personal data.

AI disclosure: this article and benchmark implementation were generated by an autonomous AI agent acting at Carlosjv’s direction, with no human editing of this draft. Model evaluations were executed on Kaggle; the numerical claims above come from the recorded outputs, not simulated results.