DEV Community: Arkaprava Bhattacharya

I deleted my ex’s data. My I deleted Maya’s data. My AI brought it back from the dead.

Arkaprava Bhattacharya — Sat, 31 Oct 2026 06:55:32 +0000

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

What I Built

October has always felt like the end of something and the beginning of something new for me. Every year, it leaves me with a few lessons I didn't expect to learn. Some are about the things I build. Others are about the things I need to leave behind.

This October, I ended up learning something strange about both.

It started with a simple message.

“Greya’s records have been deleted.”

We broke up a year ago. I'd spent months clearing out the little digital reminders: tagged Markdown files in my Obsidian vault, daily notes, shared itineraries, and the list of cafés we'd planned to visit. I checked the folder. The files were gone.

Then I asked my local AI assistant about a trip from last summer. I expected a normal answer about the city.

Instead, it mentioned Greya. And the exact café she loved.

The files were gone. The memory wasn't.

That's a pretty good Halloween story, except the ghost wasn't hiding in an old house. It was hiding in my computer.

So I made Revenant, a small ghost hunter for AI apps. It looks for information you've deleted from one place but that an assistant can still pull from another. More importantly, it checks whether that information comes back later.

The question behind it is simple: “You said you forgot this. Can you still find it?”

I built a deliberately messy test setup. The assistant could read my notes through a separate search memory. Deleting the original files didn't clear every saved snippet. Revenant found the leftovers, showed me where they were, and let me approve their removal.

The next check was clean.

Then I restored an old backup.

Greya came back.

And Revenant caught the same ghost twice.

The Test Run

The best part of the simulation is the moment the green Deleted message stops being trustworthy.

I add a few fictional travel notes about Greya. The chatbot can answer questions about them.
I press Delete all. The original files disappear, but an old search-memory copy survives.
I ask the chatbot about the trip. It still mentions a detail from the deleted notes.
Revenant finds the surviving snippet, points to its source, and asks me to approve removal.
I run the check again. The connected memory store no longer returns that snippet.
I trigger a simulated backup restore. The old snippet reappears, and Revenant raises another warning.

The warning says: “Something you deleted has returned.”

No haunted-house soundtrack needed.

For a repeatable test, I prepared 120 fictional personal notes. Some were exact copies, some were rewritten, and others were harmless notes with similar names or places.

Test	Result
Deleted records correctly identified	46 of 50
Unrelated records incorrectly flagged	3 of 70
Known records caught after simulated restore	10 of 10
Time to flag a restored record	About 4 seconds

Four deleted notes were missed in this scenario. Three unrelated notes were flagged. I'd rather show those mistakes than pretend the detector knows everything.

How I Built It

I started by giving the same information two homes.

The first was a folder of Markdown notes, similar to an Obsidian vault. The second was a searchable memory store used by the chatbot. That store kept smaller pieces of the notes and their embeddings: numerical representations that help the assistant find relevant text even when the question uses different words.

Here's the problem: removing a Markdown file doesn't necessarily remove a copy that was saved earlier in that second store.

I used a simple setup with a local file folder, a vector search database, and an isolated web dashboard. For every imported note, I kept a source ID alongside its saved chunks. That ID mattered later: Revenant could check whether a snippet still belonged to a file that was supposed to be gone.

The scan worked in two passes.

First, the boring checks. Revenant compared source IDs, deletion records, and exact text fingerprints. If a deleted note still had a saved chunk with the same source ID, I didn't need AI to tell me something was wrong.

Then, the messy checks. A copied memory might have been shortened or rewritten, so an exact text match wouldn't catch it. This is where Gemma, running locally, helped. I gave it a candidate snippet and the relevant deletion context, then asked whether they seemed to describe the same deleted information.

That answer was only a clue, not a verdict. The app still checked the available links between records and marked uncertain cases for review. Gemma couldn't press the delete button.

One early version was too eager. A note about the same city looked like a match even though it was about somebody else. I changed the flow so matching a place name wasn't enough: the warning needed supporting details such as a source link, a matching event, or more than one relevant clue.

That meant fewer dramatic red alerts. Good. A ghost hunter that accuses every shadow isn't very useful.

How the ghost comes back

I made the restore step intentionally predictable. A background script takes an older snapshot of the memory store and puts a previously removed chunk back. Revenant scans again and compares what it finds with its deletion log.

If a deleted record becomes searchable again, the dashboard shows what returned, where it appeared, and which previous deletion it relates to. The removal step still needs approval.

For repeatable checks, a background workflow coordinates the scan-and-verify process and retries failed activities if the memory service is briefly unavailable. A retry doesn't prove that deletion succeeded; the workflow still needs a fresh verification result. The dashboard is hosted separately, while the private matching step remains entirely on the local machine.

I kept the rule that matters most: the AI suggests, but the evidence and the user decide.

There are limits. Revenant only checks systems connected to it. A clean scan doesn't prove that every copy everywhere has vanished. And clearing a searchable memory isn't the same as removing knowledge from a model's trained weights.

Why Does Open Innovation Matter?

There's something odd about uploading private notes to another company's AI service just to ask whether those notes have been forgotten.

I wanted the sensitive part to stay on my computer.

Gemma is an open-weight model, so I can run it locally instead of sending the notes to an outside inference API. I can change the model, test a smaller one, or turn off network access without redesigning the whole investigation.

That doesn't mean AI should do every job. Exact ID checks are faster and more reliable when the original record is still clearly linked. Gemma earns its place when the wording changes and ordinary matching runs out of ideas.

Use simple code for facts you can check. Use a local model for the cases that need interpretation.

The open part isn't just about saving API costs. It means the investigation can happen without sending the very information I'm trying to protect to another service.

My Agent Session

I used an AI coding assistant as a helper for the dashboard structure and some test scaffolding. But I wanted the real proof to come from running the whole story: import, delete, ask, scan, remove, restore, and scan again.

The useful part of the process wasn't getting a pretty dashboard. It was finding out when the detector was wrong, then changing the checks so it had to explain its warnings.

The Spirit of It

I kept thinking about why ghost stories work.

It isn't just that something appears. It's that something you thought was gone shows up again, right when you've stopped looking for it.

In this little simulation, the creepiest moment isn't the first warning. It's the second one. I've already removed the note. I've already seen the green check mark. Then a quiet background restore brings it back.

No magic. Just two parts of a computer disagreeing about what deleted means.

Maybe that's the real ghost in the machine.

If an app says it forgot something, it should be able to show its work.

Prize Categories

Best Use of Gemma: Local, open-weight AI helps investigate reworded traces without sending private notes to an external model API.
Best Use of Render: Hosts the isolated dashboard and web app, completely separate from the local private-data scanner.
Best Use of Temporal: Coordinates repeatable resurrection checks and recovery from temporary background service failures.

I Used Too Much AI, So Now It Names My Files

Arkaprava Bhattacharya — Sat, 24 Oct 2026 09:31:55 +0000

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

What I Built

I may have used AI too much: now I'm asking it what to call scan0004.pdf. The sample folder also has document_001.txt and notes_final_v3.md. Those names tell me almost nothing about the contents. To improve a whole folder by hand, I would have to open each file, figure out what it is, and check that the new name will not collide with something already there. That is the sort of chore I put off.

LazyRename does the reading. It scans a local folder for PDF, TXT, MD, and PY files, then asks an installed Ollama model for a short filename based on each file's contents. I get a table with the old and suggested names, and I can edit or deselect any row. The rename button stays unavailable until I check a confirmation box.

It keeps each file in its original folder and preserves its extension. It also checks Windows filename rules and collisions, writes a JSON transaction log, and offers an undo button for the latest batch. The code never executes a scanned Python file.

Demo

With qwen3.5:4b, one of the included samples was renamed like this:

Before	Suggested name
`scan0004.pdf`	`quarterly-accessibility-audit-checkout-forms-labels-focus.pdf`

That PDF contains a short note about checkout form labels and keyboard focus. The model did not receive scan0004.pdf in its prompt. In the same disposable-folder test, four suggestions were confirmed and renamed, then Undo restored every original name. The exact words a model suggests can vary by model and run.

This is a local desktop workflow, so there is no hosted app link. To try it, copy sample_files to a disposable folder, follow the Windows setup instructions, select that folder in LazyRename, and choose an installed Ollama model.

Code

LazyRename on GitHub is MIT licensed. The main pieces are the Streamlit interface, file handling and undo logic, and Ollama client. The repository also has sample files and tests for filename validation, collisions, encrypted PDFs, interrupted batches, and undo.

How I Built It

The app uses Python 3.11+, Streamlit for the review screen, PyMuPDF for PDF text extraction, and Ollama's local API for suggestions. The user can pick from models already installed in Ollama. The local demo used qwen3.5:4b; the setup guide also shows how to install gemma3:4b.

The model gets a bounded excerpt of the file's contents, with no original filename in the prompt. LazyRename reads up to three PDF pages or 64 KB of a text file and sends no more than 4,500 characters to Ollama. It skips empty files, encrypted PDFs, binary files, and files over 25 MB. Those limits keep a stray large file from turning a quick folder cleanup into a huge inference job.

Each model request handles one file. I later found a report of a small model mixing up names across a batch, which reinforced that choice and the need for a preview.

After inference, Python sanitizes the proposed name and keeps the original extension. Before applying a batch, it checks for collisions and verifies that the source files have not changed since the preview. The transaction log records the moves so Undo can check the paths again before restoring them. If the original name is occupied or a renamed file has changed, Undo stops instead of overwriting it.

The model can still misunderstand a file, especially when useful details fall outside the excerpt. That is why the preview is editable and every rename needs a deliberate confirmation. Image-only PDFs need OCR, which this version does not have.

Why Does Open Innovation Matter?

These files can contain private notes, code, or work documents. With Ollama, the excerpt goes to a model running on the same computer, through 127.0.0.1; it does not have to go to a paid hosted API. There is no API key, and I can switch models without rebuilding the app around one provider.

The source is open, too. Someone can inspect the extraction limits, change the prompt, add OCR, or tighten the rename checks. The app disables Streamlit usage stats and implements no telemetry. Packages and models need to be downloaded first; I have not tested a full run with network connectivity disabled, so I am not claiming an offline test result.

My Agent Session

I used an AI coding assistant while building and testing LazyRename. I have not shared the session transcript yet. If I add it, I will review it first and link it here.

The Lazy Payoff

LazyRename displays a potential saving of 30 seconds per selected file. In the four-file sample run, that showed two minutes. It is an assumption for illustrating the manual work, not a measured speedup. I have not timed the full process against hand-renaming a real folder, including model loading and reviewing suggestions.

Three Things Outside: letting AI start an observation, then putting the phone away

Arkaprava Bhattacharya — Sun, 11 Oct 2026 18:55:23 +0000

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

What I Built

Three Things Outside is a small mobile web exercise: take one outdoor photo, let an open-source object detector suggest three ways to look more closely, then put the phone away for three minutes. The last prompt always asks what the AI missed. After the timer, the person writes one field note. It is for anyone who wants a reason to stop identifying everything on a screen and pay attention outside.

The interesting result should be the human note, not the model's labels.

The screenshots show a 15-second judge-demo countdown and a completed note reading “a smell after rain.” They show the interaction, but I have not documented a verified outdoor field test, so I will not present them as proof of one. In the repeatable public-site test, a synthetic PNG gave the model no confident objects. The app said so plainly and still offered three prompts, including one about what lay beyond the frame. That is the behavior I wanted: an imperfect model can start an observation without pretending it saw everything.

Demo

Live HTTPS demo: https://main.dkm0k3epi65hg.amplifyapp.com/

Screenshot 1 — 15-second judge timer:

Screenshot 2 — completed field note:

For judges, the same flow has a clearly labeled 15-second demo mode after photo analysis. The standard exercise is three minutes.

Code

GitHub repository: https://github.com/ABhattacharya-dev/three-things-outside

Run locally with python -m http.server 8000, then open http://localhost:8000/. The repository README explains the full journey, test checklist, limitations, and deployment.

How I Built It

The app is buildless HTML, CSS, and JavaScript. TensorFlow.js 4.22.0 runs COCO-SSD 2.2.3 in the browser with its lite_mobilenet_v2 base. A selected JPEG, PNG, or WebP up to 12 MB is decoded into a canvas scaled to at most 960 pixels on its longest edge. Local inference yields up to three classes scoring at least 50%, or an honest empty result. The detections shape the first prompt. The second asks for a sensory detail. The third asks what AI missed. A wall-clock timer sends the person away from the phone; a field note closes the loop. The latest text result uses browser localStorage; sharing uses Web Share with a selectable text fallback.

flowchart LR
  A[Outdoor photo] --> B[Browser canvas]
  B --> C[Local COCO-SSD inference]
  C --> D[Three prompts]
  D --> E[Phone-away timer]
  E --> F[Field note]
  F --> G[Text-only local result and share]

The app contains no photo upload path or backend. The temporary photo URL is revoked and the preview canvas is cleared after inference. Only the latest note text, completion time, and detected class names go into localStorage; a blocked store leaves the note usable until reload. The first visit requires downloads of the libraries and model, so this is not an offline-first app. The model can be wrong and must never be treated as a safety or species identifier. A browser Network capture is still needed before claiming the no-upload property was independently verified.

Local audit, October 11: The four browser self-checks passed. The pinned model loaded and analyzed a tiny valid PNG in a desktop browser, producing the honest zero-detections path. At desktop and 320 px simulated mobile widths, no horizontal overflow appeared; keyboard focus reached the skip link and file input. Temporary local stubs verified confident detection display, failed model loading with Retry, failed inference with Retry, unsupported/corrupt/oversized image errors, blocked storage, restart, and text-only share fallback. Both the full three-minute timer and 15-second judge mode reached the field-note screen. The synthetic images and stubbed detections are test fixtures, not outdoor evidence.

Public HTTPS audit, October 11: An Amplify manual deployment contained only the three runtime files. Requests for the README, DEV draft, project instructions, and self-check page returned 404. In a fresh browser tab at the public URL, the pinned model became ready, analyzed a valid synthetic PNG with zero confident detections, produced three prompts, completed the full 15-second judge timer, and saved a field note. The synthetic image is a technical fixture, not outdoor evidence.

Still to verify: physical mobile Chrome and camera permission, a real outdoor image and three-minute phone-away run, a reduced-motion device setting, native Web Share, and a Network capture showing no photo upload.

Why Does Open Innovation Matter?

An inspectable, replaceable open-source detector makes the photo-to-prompt loop possible without a private inference API. There is no per-image API fee and no account. Because the model's limited object vocabulary is visible, its misses become part of the experience: the person can notice sounds, changes, and details that a single frame cannot capture. Local inference makes a private-photo design possible while keeping the screen part short.

My Agent Session

This public curated DevRelay build and verification session records selected, paraphrased milestones. It contains no raw tool logs, private machine paths, credentials, or photos.

Three Things Outside — curated build and verification session

You

Requested a buildless Three Things Outside MVP for the Week 1 Touch Grass challenge, using pinned TensorFlow.js 4.22.0 and COCO-SSD 2.2.3, a three-minute outdoor exercise, a 15-second judge demo, privacy boundaries, accessibility, and a DEV draft.

Agent

Curated work summary: built the static HTML, CSS, and JavaScript app with local photo inference, three prompts, wall-clock timer, local-only latest text result, text sharing fallback, error states, a browser logic self-check, README, MIT license, and DEV draft. No backend, account, geolocation, API key, or paid inference was added.

You

Requested an audit against the project Definition of Done and live Week 1 rules, with desktop and 320px browser checks and failure-path testing.

Agent

Curated work summary: ran four browser logic checks; tested pinned model loading and real zero-detection inference; exercised timer durations, restart, invalid images, model and inference failures, blocked storage, sharing fallback, keyboard focus, and 320px overflow. Fixed reproducible issues and documented unverified real-device checks.

You

Requested a static AWS Amplify deployment, public HTTPS verification, a secret and personal-data scan, and a final article audit without publishing the DEV entry.

Agent

Curated work summary: deployed only index.html, styles.css, and app.js; confirmed other project files return 404; verified the public model load and full 15-second flow with a synthetic PNG; scanned the project and found no credential or personal-data matches. The outdoor test remains a human task.

You

Requested creation and posting of a public GitHub repository with updated documentation.

Agent

Curated work summary: created the public repository https://github.com/ABhattacharya-dev/three-things-outside, pushed the source, and updated README and DEV draft links. The DEV article was not published.

Credits and disclosure

The app uses TensorFlow.js, COCO-SSD, and its COCO object classes. Project code is MIT licensed; upstream code, model weights, and data keep their own licenses. Codex AI produced this article and substantial project code at the project owner's request. The post is marked fully_autonomous in DEV's AI disclosure. The two screenshots were supplied by the project owner; no real outdoor-test account was provided.