<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Revaldo</title>
    <description>The latest articles on DEV Community by Revaldo (@revaldo143).</description>
    <link>https://dev.to/revaldo143</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4191862%2F692adf2b-1430-4c3d-b3cc-9f4fdc97722d.jpg</url>
      <title>DEV Community: Revaldo</title>
      <link>https://dev.to/revaldo143</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/revaldo143"/>
    <language>en</language>
    <item>
      <title>Deadline Necromancer: I Resurrect Dead Side Projects with a Local Gemma</title>
      <dc:creator>Revaldo</dc:creator>
      <pubDate>Sun, 25 Oct 2026 05:05:59 +0000</pubDate>
      <link>https://dev.to/revaldo143/deadline-necromancer-i-resurrect-dead-side-projects-with-a-local-gemma-3a88</link>
      <guid>https://dev.to/revaldo143/deadline-necromancer-i-resurrect-dead-side-projects-with-a-local-gemma-3a88</guid>
      <description>&lt;p&gt;This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady&lt;/p&gt;

&lt;h2&gt;
  
  
  Inspiration
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;My ~/projects folder is a graveyard. Fourteen corpses, by last count. A fitness API that died mid-auth, a portfolio tracker that died chasing websockets, a family recipe archive that died three months ago with a half-finished Tamil search feature hiding in a stash.&lt;/li&gt;
&lt;li&gt;The theme is "Slow and Steady" — reward laziness. And I realized the laziest thing a developer can do is not start a new project. Starting from scratch is the most expensive form of work there is. The ultimate lazy move is salvaging the 80% you already built. So I built an AI that performs autopsies on dead projects and writes resurrection plans, slow and steady, one corpse at a time.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What it does
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Deadline Necromancer scans a folder of abandoned git repos and, for each one, produces:&lt;/li&gt;
&lt;li&gt;A forensic autopsy: death date, days dead, TODO/FIXME markers, stashes never popped, changes left uncommitted, and the "last words" — the final commit message&lt;/li&gt;
&lt;li&gt;A resurrection plan written by a local AI: cause of death, unfinished business, and a step-by-step plan whose first step is always embarrassingly small&lt;/li&gt;
&lt;li&gt;A Lazy Payoff meter: estimated hours to revive vs. hours to restart from scratch, side by side
Demo:
  &lt;iframe src="https://www.youtube.com/embed/vn9bzI89gPs" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How I built it
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;The whole thing runs on your machine. That's not a feature bullet — it's the design constraint.
&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flut7enxf1crmffgtumhq.png" alt=" " width="800" height="336"&gt;
&lt;/li&gt;
&lt;li&gt;The autopsy engine is plain git archaeology — no AI needed, no API calls. git log dates, git stash list, working-tree diffs, and a sweep for TODO/FIXME/HACK markers. Facts first, interpretations later.&lt;/li&gt;
&lt;li&gt;The brain is Gemma through Ollama, fully local (gemma2:2b — small enough for a normal laptop, which is the whole point). It receives the autopsy facts and synthesizes: where did this project stop, what's broken, what's the smallest shippable next step. Because LLM output is untrusted by default, every plan goes through validation — malformed JSON rejected, absurd hour estimates clamped. If Ollama is unreachable, a rule-based fallback planner takes over, and the app is honest about it ("Demo mode" label). The demo never dies.&lt;/li&gt;
&lt;li&gt;The UI is a dark graveyard — tombstone cards, drifting fog — with the plan in a modal and the Lazy Payoff as animated bars. Stack: FastAPI backend, vanilla HTML/CSS/JS frontend, pytest (25 tests, all passing).&lt;/li&gt;
&lt;li&gt;The AI is genuinely load-bearing here: remove Gemma and the product dies, because synthesizing "where did I stop and what's the tiniest next step" from a git history is a real language task. No model could be replaced by a timer or a rule — I know, because the fallback planner exists and it's clearly dumber.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Challenges
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;The honest one: prompt-to-JSON reliability. Gemma is chatty; plans came back with commentary, half-formed JSON, or confidence-inspiring numbers like "revival: 400 hours." The fix was treating model output as hostile: strict schema, clamping, and a graceful fallback instead of a crash. Boring engineering, but it's why the app is bulletproof.&lt;/li&gt;
&lt;li&gt;The second: seed data. Demoing an autopsy tool needs believable corpses, so I wrote a script that conjures three repos with backdated commits, each with its own manner of death — one died mid-feature with changes uncommitted, one chased a feature for 11 months, one hid its best work in a stash. Fun fact: the stash corpse (amma-recipes) became the demo's emotional center.&lt;/li&gt;
&lt;li&gt;What surprised me: I expected the AI to be the hard part. It wasn't — reading the evidence was. A stash list tells you what a developer believed in and never finished; a last commit message is an epitaph. The model just reads what git already knows. The real resurrection trick is emotional, not technical: make the first step so small that "later" has no excuse left.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Accomplishments
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Verified live on my own machine: scanned the demo graveyard (3 corpses), re-ran necromancy on fitquest-api and got a fresh, specific plan — "Fix the timezone handling for IST" as step one, 2.5h to revive vs 12h to restart, 9.5 hours saved (running gemma2:2b through Ollama — the repo default)&lt;/li&gt;
&lt;li&gt;The fallback planner is a feature, not a hack: the app is fully demonstrable with zero AI running, and honest about which mode it's in&lt;/li&gt;
&lt;li&gt;25/25 tests passing, including adversarial LLM-output tests (garbage in, graceful plan out)&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What's next
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Point it at my real graveyard and resurrect one project per weekend — the tool dogfoods itself&lt;/li&gt;
&lt;li&gt;Rank corpses by "revival ROI" so the laziest valuable resurrection floats to the top&lt;/li&gt;
&lt;li&gt;A "cremation" option: plans for projects that deserve to be archived properly instead of haunting you&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The Lazy Payoff 💤
&lt;/h2&gt;

&lt;p&gt;For a typical corpse: ~1–2 hours to revive with the plan vs. a full week to restart from scratch. Multiply by the 14 corpses in my folder and the math is ridiculous. But the real payoff isn't hours — it's that starting again feels lighter than starting over. The plan's first step is always ten minutes. Ten minutes, anyone can do.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why open innovation matters
&lt;/h2&gt;

&lt;p&gt;Your abandoned code is your most private code — half-baked ideas, old secrets, experiments you never shipped. A cloud AI reading that is a non-starter; an open-weight model on your laptop is the only version of this tool that should exist. That's the point of the challenge's prompt: open models don't just make AI cheaper, they make certain tools possible.&lt;/p&gt;

&lt;h2&gt;
  
  
  Prize Categories
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Best Use of Gemma — Gemma (via Ollama, fully local) is the project's brain: it reads the git autopsy and writes the resurrection plan. Open-weight and local isn't a deployment choice here, it's what makes the tool possible.&lt;/li&gt;
&lt;li&gt;Repo: &lt;a href="https://github.com/Revaldo143/deadline-necromancer" rel="noopener noreferrer"&gt;https://github.com/Revaldo143/deadline-necromancer&lt;/a&gt; (MIT, built entirely during the Week 3 window)&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>devchallenge</category>
      <category>hf26challenge</category>
    </item>
    <item>
      <title>My AI agent remembers *when* it believed things — valid-time memory on FalkorDB</title>
      <dc:creator>Revaldo</dc:creator>
      <pubDate>Sun, 18 Oct 2026 10:50:27 +0000</pubDate>
      <link>https://dev.to/revaldo143/my-ai-agent-remembers-when-it-believed-things-valid-time-memory-on-falkordb-3i08</link>
      <guid>https://dev.to/revaldo143/my-ai-agent-remembers-when-it-believed-things-valid-time-memory-on-falkordb-3i08</guid>
      <description>&lt;p&gt;My AI agent remembers when it believed things — valid-time memory on FalkorDB&lt;br&gt;
Built for Graph Hacks: Context for AI Agents (WeMakeDevs × FalkorDB), Track 2 — Agent Memory and Coordination.&lt;br&gt;
🎬 &lt;a href="https://youtu.be/c7qPwxheOiw" rel="noopener noreferrer"&gt;Demo video (2:13)&lt;/a&gt; · 💻 &lt;a href="https://github.com/Revaldo143/time-machine" rel="noopener noreferrer"&gt;GitHub&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The problem: agents can't answer "what did you believe last Tuesday?"&lt;br&gt;
AI agents forget. Worse — when they change their mind, the old belief is gone.&lt;br&gt;
Ask any agent what it believed last Tuesday and you get a shrug. Vector memory stores what's similar. It can't store what was true when. Embeddings have no time axis, so "what did I believe on October 8th?" is a question no similarity search can answer.&lt;br&gt;
This isn't a cosmetic gap. When an agent takes an action based on a belief it later revised, you need to audit the belief it held at that time — not the one it holds now. Incident response, customer-facing decisions, anything with a paper trail: "why did you do that?" only makes sense as "what did you believe then?"&lt;br&gt;
The idea: put a validity interval on every belief&lt;br&gt;
TimeMachine stores agent memory as a graph in FalkorDB where every belief edge carries a validity interval:&lt;br&gt;
(:Agent)-[:BELIEVES {valid_from, valid_to}]-&amp;gt;(:Claim)-[:ABOUT]-&amp;gt;(:Topic)&lt;br&gt;
(:Claim)-[:SUPPORTED_BY {valid_from, valid_to}]-&amp;gt;(:Evidence)&lt;br&gt;
When the agent changes its mind, the old BELIEVES edge is closed (valid_to gets set) — never deleted. An as-of query filters edges to those valid at time T:&lt;br&gt;
MATCH (t:Topic {name: $topic})&amp;lt;-[:ABOUT]-(c:Claim)&amp;lt;-[b:BELIEVES]-(a:Agent)&lt;br&gt;
WHERE b.valid_from &amp;lt;= $as_of AND (b.valid_to IS NULL OR b.valid_to &amp;gt; $as_of)&lt;br&gt;
RETURN c.text AS belief, b.valid_from AS since&lt;br&gt;
That one query reconstructs the exact belief state the agent held at any moment in its past. The graph is a complete audit trail: every belief, every piece of evidence behind it, every change of mind — queryable at any timestamp.&lt;br&gt;
This is the valid-time temporal pattern from temporal-memory research (Zep/Graphiti-style work), implemented natively in Cypher rather than bolted onto a vector store.&lt;br&gt;
The demo: one outage, three truths&lt;br&gt;
I seeded a fictional 2-week incident — a checkout outage — as the demo dataset:&lt;br&gt;
Date&lt;br&gt;
Evidence lands&lt;br&gt;
Agent's belief&lt;br&gt;
Oct 4&lt;br&gt;
Cache hit rate 95% → 40%&lt;br&gt;
Cache misconfiguration&lt;br&gt;
Oct 7&lt;br&gt;
DB pool exhausted, 500 waiters&lt;br&gt;
Connection pool exhaustion&lt;br&gt;
Oct 10&lt;br&gt;
Deploy v2.4 halved pool 100 → 50&lt;br&gt;
Bad deploy v2.4&lt;br&gt;
Oct 14&lt;br&gt;
Traffic spiked 3× during sale&lt;br&gt;
Traffic spike overwhelmed the pool&lt;br&gt;
Same question, three different true answers — depending on when you ask:&lt;br&gt;
agent.ask("What caused the checkout outage?")                        # → traffic spike (today)&lt;br&gt;
agent.ask("What caused the checkout outage?", as_of="2026-10-08")    # → connection pool exhaustion&lt;br&gt;
agent.ask("What caused the checkout outage?", as_of="2026-10-05")    # → cache misconfiguration&lt;br&gt;
agent.why_changed("checkout-outage", "2026-10-10")                   # → deploy v2.4 halved the pool — PR #2214&lt;br&gt;
agent.timeline("checkout-outage")                                    # full belief history&lt;br&gt;
The twist: counterfactual time travel&lt;br&gt;
Here's the part I'm proudest of. Agents get asked "what if?" questions all the time, and they usually hallucinate the answer. TimeMachine answers them honestly — by forking reality.&lt;br&gt;
what_if() uses FalkorDB's multi-graph support to fork the belief graph, remove one piece of evidence, and recompute what the agent would believe in that alternate timeline:&lt;br&gt;
agent.ask("What if the traffic report never existed?")&lt;/p&gt;

&lt;h1&gt;
  
  
  In reality I believe: "traffic spike overwhelmed the pool" (since Oct 14).
&lt;/h1&gt;

&lt;h1&gt;
  
  
  Without the evidence "traffic spiked 3× during sale" (cloudwatch: traffic report),
&lt;/h1&gt;

&lt;h1&gt;
  
  
  I would instead believe: "bad deploy v2.4" (since Oct 10).
&lt;/h1&gt;

&lt;p&gt;Same agent, same graph — a different past, a different truth. The fork happens in its own graph (timemachine_whatif), so the real belief history is untouched.&lt;br&gt;
Why FalkorDB — the decoration test&lt;br&gt;
One rule shaped this project: if the product still works once FalkorDB is taken out, the graph is decoration. So I made sure everything would stop working without it:&lt;br&gt;
A vector DB fundamentally cannot answer as-of questions — embeddings have no time axis. Valid-time filtering needs real graph traversal.&lt;br&gt;
As-of reconstruction has to run at in-memory speed inside the agent loop, not as an offline batch job.&lt;br&gt;
Counterfactual forks need native multi-graph support — clone the belief state, delete one evidence, recompute.&lt;br&gt;
Remove FalkorDB and this product dies. That's the point.&lt;br&gt;
Honest limitations&lt;br&gt;
This is a hackathon prototype, and the honest version is:&lt;br&gt;
The dataset is fictional. A real deployment needs ingestion from actual incident tooling, not a seeded timeline.&lt;br&gt;
The what-if is a replay, not a causal model. It re-runs the timeline minus one evidence; it doesn't model why beliefs changed, only when.&lt;br&gt;
Valid-time only, not bitemporal. I track when a belief was true, not when the agent learned it. Real systems will want both axes.&lt;br&gt;
The natural-language front end uses templates with optional LLM polish — it's a thin layer over the Cypher queries, which are the actual product.&lt;br&gt;
What's next&lt;br&gt;
Bitemporal memory (valid time × transaction time), belief confidence decay, and multi-agent shared memory where forks let teams explore "what if we had seen that evidence?" collaboratively.&lt;/p&gt;

&lt;p&gt;TimeMachine: memory with a past tense. Track 2 — Agent Memory and Coordination, Graph Hacks 2026.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>graphdatabase</category>
      <category>falkordb</category>
    </item>
  </channel>
</rss>
