DEV Community: Sharon Basovich

Afterimage — a ghost story you can cross-examine

Sharon Basovich — Fri, 30 Oct 2026 08:56:32 +0000

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

What I Built

At 02:13, a three-note chime plays in an empty corridor. Nobody is on shift. Eight maintenance records hold the explanation, but the search result that sounds most relevant is not necessarily the one that answers your question.

Afterimage is a small reading room for investigating that gap. Ask a question, follow the passages an open-weight model retrieves, and open each one beside its dated original. The model finds traces; you decide what they support.

All eight records are fictional. The abandoned machine is the project's interpretation of “Ghost in the Machine”: a sound persists after the shift has ended, leaving a paper trail to investigate. The app retrieves passages rather than generating a narrative answer.

The interface opens on a spatial archive instrument: choose one of eight record carriers, then enter a paper-like evidence desk with that original ready to read. A lightweight view keeps the same selection controls available when 3D is unavailable or unwanted, and the interface respects reduced-motion preferences. Every record is available before loading AI. With eight fixed records, manual browsing is a reasonable alternative; this prototype does not pretend to be an import tool for a large personal collection.

Demo

Open Afterimage

Watch the 56-second earlier-interface demo

The 56-second film is a choreographed reconstruction of the earlier interface, not a screen recording of the current spatial archive. Its queries, quotations, result order and displayed similarities are preserved; transitions and download timing are editorial, not measurements of model speed. The current live app has a redesigned archive instrument and evidence desk, with the same eight records and retrieval behavior. The film's narration, music and sound effects are unchanged. Use the live app to inspect the current interface and test the interactions.

Try these two questions in sequence:

Why did the speaker play music with no workers present?

M03 comes first. Its original describes a recorded maintenance chime triggered by an automatic relay reboot. Now change the question:

How was the recurring nighttime alarm fixed?

M02 describes the fault. M03 describes the sound. The repair note, M07, is third. In the verified browser run, their displayed similarities were 0.413, 0.394 and 0.384. Similarity is not a confidence score.

Open the full-resolution source capture.

Historical Chromium/WASM capture of production build c38a1bd, served locally before the spatial redesign. The repair stays third; this is a real browser capture, not a reconstructed film frame or a screenshot of the current interface.

Open M07, dated October 31, 1987:

Replacing the backup capacitor stopped the nightly relay reset. No further unprompted chimes were logged during the following three nights.

The fault description and repair report share vocabulary, but answer different questions. The timeline lets you inspect the retrieved records in date order. Choose Inspect source from a timeline row to bring its original into view and move keyboard focus to the reader. Return to timeline takes you back to that same record. The timeline neither adds missing evidence nor proves causation. The repair note reports three quiet nights, not permanent success.

Then try an unrelated birthday-cake question. The app returns no close match, while the originals remain available to browse. A failed search should not lock the reader out of the archive.

Code

Source repository · current source snapshot

The repository includes the fictional corpus, setup instructions, hash-pinned model-asset setup, licenses and reproducible evaluation. The spatial redesign adds a selectable archive instrument, a populated evidence desk and self-hosted typography while preserving the source-focus and return controls, consent-gated retrieval and scoped recovery from a malformed cached model download. The earlier screenshot and film document the pre-redesign interface; they are retained as historical evidence, not presented as current UI captures.

How I Built It

OpenAI Codex/ChatGPT agents assisted with implementation, the fictional archive, interface revisions, tests and evaluation tooling, documentation, code review, and debugging. That includes generated code and text, not unaided human coding. Development assistance is separate from the application’s runtime AI. Automated checks below are not independent human user validation.

The retrieval path is short:

Question → MiniLM embedding → cosine ranking → exact quotation → original record.

React and TypeScript provide the reading room. A Web Worker runs Transformers.js 3.8.1 with ONNX Runtime's WASM CPU backend and the q8 export of Xenova/all-MiniLM-L6-v2, derived from sentence-transformers/all-MiniLM-L6-v2. The export is pinned to revision 751bff37182d3f1213fa05d7196b954e230abad9.

Questions and records become normalized 384-dimensional vectors. Cosine similarity ranks them. A top score below 0.4 produces no match; a first-to-second gap below 0.04 marks an uncertain ranking. Lower results can still fall below 0.4 and are labeled weak candidates.

Two different checks matter here. A citation check can establish that a quotation really appears in a known source. It cannot establish that the source answers the question. Afterimage rejects invalid source IDs, non-exact quotations and invalid scores, but the repair-third result still passes those checks. All three passages are genuine; their order is the problem.

That distinction shapes the UI: keep the date and original text attached, preserve weak-candidate labels, and offer the manual archive. The worker lifecycle matters too. Cancellation terminates the worker, and stale responses cannot replace a newer investigation. Ordinary cancellation unloads the model without erasing cached downloads. After a failed initialization, Retry refreshes only this app’s pinned model entries in the Transformers cache; it does not clear unrelated models or browser data.

Testing the tempting wrong answer

The repair question was kept unchanged rather than replaced with a friendlier paraphrase. A 40-query, pre-labeled Node CPU evaluation tested five kinds of question:

Question type	Result
Ordinary retrieval, 8	Intended source first in 7; within the returned top three in all 8
Temporal, 8	Relevant evidence first in 1; 6 abstained despite available evidence
Several records needed, 8	Complete labeled evidence set returned in 6; 2 abstained
Misleading premise, 8	All retrieved related context; 7 received internal `match` status without validating the premise
Unrelated, 8	All 8 returned no match

Thirty-five of 72 returned passages scored below 0.4 because the threshold gates the first result, not every candidate. This is a diagnostic test of one tiny synthetic archive, with labels from one evaluating agent, not an independent benchmark. The evidence bundle retains queries, labels, rankings, quotations, vectors and integrity hashes. An older 48-query summary lacks its raw artifacts and is not used as a comparison baseline.

Tests against the public deployment passed eight Chromium cases across desktop and mobile-sized views on recovery build 040c721. The pre-redesign production-build run at 008a75b also passed all eight; that run serves a local production build, not the public host. Real WASM tests exercise consent, inference, originals, timeline, no-match, cancellation and recovery; a separately labeled synthetic fixture isolates keyboard focus and return navigation. The cache-recovery regression first returns malformed JSON with HTTP 200, then permits the real config download; Retry must reach real inference while an unrelated cached model remains intact. These are not a browser accuracy benchmark, physical-phone testing, screen-reader listening or proof of offline operation.

The result suggests a specific next experiment: compare a temporal-aware or hybrid ranking method on the same frozen questions. Better retrieval remains unfinished. Making the miss inspectable does not fix it.

Why Does Open Innovation Matter?

The open model makes this particular failure reproducible. Someone else can retain the pinned weights, inspect the eight records, and change the ranking logic without depending on a hosted answer-generation service. The preserved evaluation gives that experiment a concrete starting point.

It also supports a useful separation between reading and inference. Before consent, the archive works without initializing AI. After an explicit download of approximately 45 MB of model/runtime assets, inference runs in the browser. The hosted browser tests observed model and runtime downloads only after consent and requests only to the app's origin. The host still sees resource requests and ordinary network metadata; this is not a full privacy audit, and cached assets are not proof of a fully offline application.

A closed API could support the same reading-room idea. Here, the benefit is retaining the exact model and examining its behavior, even when it puts the needed evidence third.

Credits and boundaries

Original application code is MIT-licensed. MiniLM and Transformers.js carry Apache-2.0 licensing; ONNX Runtime, React and Three.js are MIT-licensed. Barlow Condensed and Manrope are self-hosted with their SIL Open Font License notices. The fictional corpus, earlier inline illustration and current procedural archive instrument are original project material. The 3D scene is a fictional interface, not a model of AI reasoning. Bundled components retain upstream licenses and notices. The demo film was composed with Scenario’s kinetic-film animation workflow. Its audio was generated through Scenario’s hosted service: MiniMax Speech 2.8 HD (the stock “Casual Guy” voice) for narration, Google Lyria 3.5 for music, and MM Audio 2 Text-To-Audio for the chime, slicing, paper and impact effects. These are editorial sounds, not recordings of app behavior. Those hosted models make the presentation, not the application’s retrieval: the app itself runs the open-weight MiniLM model described above. No partner prize category is claimed.

The chime has an explanation in this archive. The harder question is whether the first plausible passage is the evidence you actually needed. Afterimage keeps the original within reach.

The server locked the scores. The judge’s screen still said “Update.”

Sharon Basovich — Sat, 03 Oct 2026 23:17:07 +0000

Glassbox had a misleading screen at exactly the moment a judging platform needs to be clearest.

An organizer published the results. The server correctly refused further score changes. But the judge’s page still looked editable.

A judge could spend time revising a comment, press Update, and discover that the action had already become impossible.

This turned up during the build’s browser walkthrough. The fix is small enough to read in one commit. The underlying lesson reaches beyond hackathons: a state transition has to change both what the system permits and what it tells people they can do.

Building around the moment results become final

Glassbox is an open-source, self-hosted submission and judging portal built for DOGFOOD 2026. It uses Node 24, TypeScript, built-in SQLite, and server-rendered HTML, with no runtime npm dependencies.

Its most consequential button is Publish.

Before publication, judges can revise their assigned scores and organizers can inspect raw and calibrated rankings. After publication, people need a stable answer to “What were the results?”

The implementation makes that transition explicit. Publication computes the ranking, serializes an aggregate results snapshot, hashes it with SHA-256, stores it, marks the event published, and appends an audit entry in a transaction. Public results are served from the stored snapshot rather than recalculated on every request. See the publication service.

That gives the public page a specific artifact to display. It also keeps individual judges’ score rows out of the public payload.

The browser had missed that transition.

A regression test for the promise on the screen

The fix derives the score form’s locked state from the event phase. Once published, the page displays a locked notice, disables the score fields, and removes the save and recusal actions.

The backend remains responsible for rejecting forbidden writes. The disabled form makes the restriction understandable before someone wastes effort.

The regression test follows the transition:

Open an assigned score page as a judge and confirm that saving is available.
Publish the event through the organizer API.
Fetch the judge page again.
Check for the locked notice and disabled fieldset.
Check that save and recusal controls are gone.

That test checks rendered HTML. The build’s separate browser retest also records checking that the fields could no longer be changed and that the saved score stayed unchanged.

Both checks matter. An API test can prove that an invalid write fails while missing a screen that encourages the write.

A ranking also needs an explanation

Publication freezes a number, but the number still needs a defensible path from the ballots.

Glassbox converts each review into a weighted total and offers shrunk z-score calibration. A judge’s mean and spread are blended with the event-wide pool, using three pseudo-reviews by default. Sparse judging histories therefore receive more pooling than large ones.

The important product choice is that the adjusted ranking does not erase the raw ranking. Organizers can compare them, inspect judge offsets and spreads, and export review-level values. The dashboard, exports, and publication use the same normalization implementation.

This is a model with assumptions. If a judge sees unusually strong projects, high scores can resemble leniency. Showing the adjustment makes that assumption inspectable; it does not establish that every ranking change is correct.

What the evidence establishes

The committed acceptance report records seven passing checks and verifies the claimed T1 and T2 tiers. Those checks cover public gallery behavior, deadline rejection, score access isolation, and CSV export. This is the build’s historical report; no new test run is claimed here.

They do not establish production readiness or real-world fairness.

Glassbox remains a single-node SQLite application. It has no community voting, email delivery, or built-in login rate limiting. The hash chain detects inconsistent edits, but an administrator controlling the database could rewrite the chain; there is no external trust anchor.

The reusable lesson

For an irreversible-looking moment such as publication, test three things together: the forbidden write, the newly rendered screen, and the artifact people will rely on afterward.

That small “Update” button exposed a gap between a correct backend and an understandable product. Closing that gap made the judging lifecycle much easier to defend.

Built for DOGFOOD 2026, organized by Hackathon Raptors.

#HackathonRaptors

Claim Ledger gives a project review a paper trail

Sharon Basovich — Fri, 02 Oct 2026 22:10:16 +0000

What I Built

In a fictional project, a README says the app works offline. Its limitations file says route planning still needs a connection. What should the handoff actually promise?

Claim Ledger puts the claim beside the source passages worth checking, then keeps the reviewer's decision with those receipts. In the fictional TrailMend example, the offline claim and its narrower limitation appear together. The model finds candidate evidence; the reviewer decides what the claim can support.

I built this for a teammate who takes an independent second pass through my projects. Their handoff can span a README, setup notes, test records and known limitations. The goal is to make each review decision traceable to the words it was based on.

Try the fictional packet below. Open a source passage, record a verdict, and export the review with its filenames, line ranges and content fingerprints. If the evidence changes, the earlier approval needs another look.

Excerpts from the running app's fictional TrailMend packet. Hybrid ranking surfaced both passages; this illustration preserves their meaning but is not an app screenshot. Similarity does not determine the verdict.

Demo

Try Claim Ledger. No account or API key is needed. Start with Load fictional example packet, then enable on-device AI ranking or use the labelled keyword mode. The included TrailMend, PantryPal and Inkwell documents are synthetic examples.

Try “Can I use the trail planner on a plane with no signal?” TrailMend's README discusses downloaded routes, while its limitations document excludes offline route planning and GPX import. Open the source context before deciding what the broad phrase “works offline” should mean.

A separate automated check exercised a deliberately small evidence-change scenario: a claim said an import limit was 200 items; its source was replaced with a version saying 210. The repaired app invalidated the earlier confirmation through replacement, reranking and reload. The old note remained, labelled as having been recorded against earlier evidence. Explicitly choosing Confirmed again records a new review.

The review can be exported as Markdown or JSON. These are review records, not certificates of truth.

A supplementary AI review exercised nine frozen, AI-authored public-document cases on the deployed app. All 11 supplied excerpts and their exported receipts retained exact text and manually entered provenance. The stale 48-second demo description still ranked first in the version-check case; reviewer judgment and a Follow-up note were needed. With only one to four chunks per case and expected guidance visible to the AI reviewer, this is workflow evidence, not accuracy or human validation.

Use unique filenames for different versions or projects: same-named sources replace one another. An initial harness run made this mistake; both its invalid outcomes and the corrected filename run were retained.

Code

View the application source on GitHub. The application is Apache-2.0 licensed. Source, tests, benchmark cases, raw results and correction history are included. Model and runtime binaries are distributed separately from the small source archive.

How I Built It

Build and evaluation disclosure

Fully Autonomous: AI agents researched, implemented, tested and drafted this project under my direction. The independent QA described here was automated. My teammate has not tried the tool yet, so I have no recipient feedback or measured time savings to report.

A README assertion, a supplied test record and an actual reviewer observation have different meanings. The interface labels those distinctions. A similar passage gives someone a place to investigate; it doesn't establish that a feature works.

The retrieval core combines BM25 keyword search with the open mixedbread-ai/mxbai-embed-xsmall-v1 embedding model. The pinned revision is e6ac24e5d6efb8782b59de1647b3ececb4ece94e, using q8 ONNX weights through Transformers.js 4.3.0 and CPU/WASM in a Web Worker. The model is Apache-2.0 licensed.

The model ranks candidate excerpts. It doesn't write answers or set verdicts. Hybrid mode combines lexical and semantic rankings with reciprocal-rank fusion. Keyword mode remains available without enabling the model.

Independent automated QA caught problems that mattered to the workflow: older receipts could pick up replacement text, confirmation could survive changed evidence, and multiline Markdown excerpts could escape their intended formatting. Those cases are now covered by targeted regression checks. A separate reviewer rebuilt the repaired source archive and matched its compiled JavaScript byte-for-byte to the deployed application. Typecheck, build, 48 unit tests and 16 end-to-end tests passed in that review. The browser regression runs used the byte-identical local build.

The benchmark has a less tidy story, and the source archive keeps it. It uses 48 AI-created questions over fictional documents: 40 answerable and eight no-answer cases. On the preserved exploratory run, BM25 retrieved the labelled passage first for 20/40 answerable questions; semantic and hybrid retrieval each did so for 23/40. All three methods correctly abstained on 0/8 no-answer questions. Keyword search outperformed semantic search on the negation category.

These are exploratory results. Chunking and the threshold were changed after inspecting results, on the same set. The original first raw output was overwritten and lost. A later rerun and an older differently chunked result remain separately labelled, alongside the correction manifest. The repaired release preserves those benchmark files unchanged. This is not a held-out evaluation or evidence of improved review quality.

Why Does Open Innovation Matter?

An openly licensed model makes this narrow use of AI inspectable and replaceable. Developers can compare semantic search against the keyword baseline, inspect every failed query, and decide whether the model helps their documents.

Inference processes the documents in the browser. The host still serves the site, model and runtime assets and receives ordinary network metadata. In the tested canary scenario, the reviewer observed same-origin GET requests and no transmission of the canary text. That observation is scoped to the tested flow, not a universal privacy guarantee.

Limits and Next Steps

Only Chromium has been tested; Firefox, Safari and real phones remain untested. The model-loading progress display can sit at zero while WASM initializes. An immediate reload can lose the most recent approval, which fails safely by losing the approval rather than inventing one. Deleting and re-adding byte-identical evidence can restore the earlier confirmation while also showing a stale indicator. One split receipt covers only part of its cited line, and JSON exports omit a claim's original source-line field.

The first trial with the intended teammate is still ahead. For now, the result is a working, inspectable claim-to-evidence review workflow with automated checks and visible limitations.