DEV Community: Omar Afifi

Folivora: an open-model reading room that predicts which of your open tabs you'll never actually read — and reads you the few that matter

Omar Afifi — Sun, 25 Oct 2026 16:57:17 +0000

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

Look at the top of your browser right now.

If yours looks anything like mine, there's a row of tabs sitting open from last week — maybe 8 of them, maybe 40. You don't keep them open because you're going to read a 4,000-word article from start to finish. You keep them open because one of them has the flight time buried in paragraph six of a trip guide, another has the laptop comparison you meant to finish, and a third has the single paragraph you actually needed — and closing them feels like throwing something away.

And you don't need forty tabs for this to hurt. Ten unread articles is already two hours of reading you keep postponing, and "later" never comes. Two things would fix it without requiring an afternoon of reading:

A model that knows which pages you'll actually use and which ones you'll never miss, with a calibrated upper bound so a tab is only set aside when that's genuinely safe.
A single calm page with just the takeaways you needed, plus a fifteen-second spoken summary so you can close the whole browser window and go make coffee.

So I built Folivora (from the biological suborder for tree sloths, and Latin folium + vorare — literally *"the page/folio devourer"*).

What I Built

Folivora takes the tabs you keep meaning to read, inspects the live pages in a cloud browser when you ask it to, predicts which ones you will never get to, and hands you a printable, section-anchored reading digest of the rest:

Say what you need, don't type. Tap the mic once, say what you're looking for — "Japan travel itinerary", "the quietest laptop for studying", or "Web development" if that's your thing — then tap it again to stop. ElevenLabs Scribe (scribe_v1) turns your voice note into a filter rule and immediately calls DELETE /v1/speech-to-text/transcripts/{id} so your voice transcript is wiped from ElevenLabs as soon as the text returns.
A cloud browser opens the live tabs for you. Instead of you clicking through them one by one, src/browserbase_service.py spins up a cloud Chromium session on Browserbase, drives up to 16 links over Chrome DevTools Protocol (CDP), and reads what each page actually contains — reading time, code blocks, tables, headings, and section structure. Larger piles use the same extractor over capped HTTP after the live-browser budget; every CDP failure falls back per link instead of failing the run.
An open model predicts a probability range (P10, P50, P90), not a single guess. Evaluated on 3,600 tab lifecycle records (data/developer_tabs_telemetry.csv), Prior Labs TabPFN scores every tab. A tab is only set aside when even its optimistic 90th-percentile upper bound (P90) falls below threshold—cutting the False-Close Rate by 23x down to 0.36%.
Gemma writes the two-line brief; plain code checks every digit. Open-weight Google Gemma 4 (gemma-4-26b-a4b-it) & Gemma 3 (gemma-3-12b-it / 27b-it / 4b) write a two-sentence spoken summary of what was set aside and what was kept. check_output() checks that every single number in Gemma's sentences exists character-for-character in Python's facts dictionary.
Print the keepers, export bookmarks, or listen in 15 seconds. Hit Listen (15s) to hear ElevenLabs Flash v2.5 (Charlie voice) read the two lines aloud, hit Save Notes (.md) or Bookmarks to export your keepers, or hit Print to print only the cards you kept, then walk away.
Built for everyone, not just engineers. The interface is a calm reading room in a warm editorial palette (Newsreader + Plus Jakarta Sans) — no ML jargon on screen. Built-in topic chips cover everyday life: Travel, Health & Sleep, Food & Recipes, Shopping — next to Web Dev and AI & Tech for the developers. Planning a 10-day Japan trip, comparing laptops, or prepping meals works exactly like triaging 65 engineering articles, while every benchmark, evaluation, and trace stays inspectable in the repository.

Demo

Live Web Application: https://folivora.tech (no sign-up; test with your own links, launch the **14 Everyday & Travel Tabs* window or the 65 DEV Article Library, or enable "Use live cloud browser" to watch a real Browserbase Chromium session inspect your URLs)*
1-Click Browser Extension (.zip): https://folivora.tech/download-extension.zip (pre-configured to https://folivora.tech—one click scans your open window, with an optional topic, and opens the full Reading Digest pre-filled; it never closes or modifies your tabs)
Interactive OpenAPI Docs: https://folivora.tech/docs
Evaluation Report (59 / 60 pass): eval/EVAL.md · Hand Audit: eval/REVIEW.md

01 · The Reading Desk (Calm Intake)	02 · Sample Windows & 65 DEV Article Library

Paste links, import bookmarks, or pick a topic chip (Travel, Health & Sleep, Food & Recipes, Shopping, Web Dev, AI & Tech).	One-click sample windows: 14 Everyday & Travel Tabs, the 65 DEV Article Library (600+ min read), and 10 Research Tabs.

03 · Summarize All Open Tabs (No Filter)	04 · Topic Focus & Set-Aside Triage

Mode A (Unrated): Summarizes every open tab into a 25-second overview + section-anchored takeaways.	Mode B (Topic Focus): Ranks matching pages under Worth Your Time* and moves unrelated pages to Set Aside.*

Code

GitHub Repository: https://github.com/OmarAfifi-CSE/folivora

MIT-licensed. Covered by 92 automated unit, integration, and red-team tests (python run_local.py --test). Every benchmark table, DEV Hall of Fame catalog (data/dev_hall_of_fame_catalog.json), and evaluation number in this post is reproducible via benchmarks/ablate.py, benchmarks/build_hall_of_fame_catalog.py, eval/run_eval.py, eval/summary_quality.py, and eval/redteam_eval.py.

Real-World Stress Test: Indexing the 65-Article DEV Hall of Fame (600+ Minutes of Reading)

This week, @georgekobaidze published Promise Delivered: Welcome to the DEV Hall of Fame (65 Authors, 65 Masterpieces)—a curated tour of 65 community-chosen articles across 7 themed wings (The Welcome Desk, Stories From the Trenches, The "Finally, It Clicked" Gallery, The Engine Room, The AI Lab, The Philosophy Floor, and The Builder's Garage), including my own post My Phone Broke, and Gemini Fixed It in The Engine Room.

Listed reading time across all 65 tabs? Over 600 minutes (10+ hours).

Opening 65 tabs at once is the ultimate browser-tab nightmare. So I built the 65 DEV Article Library directly into Folivora (benchmarks/build_hall_of_fame_catalog.py) and calibrated TabPFN on their real DOM feature profiles (word_count, code_block_count, table_count, heading_count, link_density, and intent_match_score).

05 · 65 DEV Article Library Filtered by "Web Development"	06 · Mobile Responsive Digest View

Partitions 65 community articles in one deterministic pass (zero LLM in the loop): keeps 22 matching Web Development articles and sets aside 43 unrelated tabs (478.9 min saved).	Responsive down to mobile screens with zero horizontal overflow and 44px+ touch targets.

Even better, when you filter by a specific topic, each matching card gives you two interactive Segmented Tabs (never a cluttered wall of stacked text):

Focused on "<Your Topic>" (Active Tab): Synthesizes why the article matters for your exact query and extracts section-anchored takeaways (Heading — Key Insight) specifically from the sections discussing that topic.
Full Summary (Second Tab): Gives you the full, objective summary across all sections of the article.

Here is what happens when you load all 65 DEV Hall of Fame tabs in Folivora and filter by different engineering topics:

Filter Query on All 65 DEV Articles	Matching Tabs Kept	Unrelated Tabs Set Aside	Full-Article Reading Time Saved	Top-Ranked Hall of Fame Masterpiece (`P50` Match)
`"Flutter"`	2 / 65	63	697.9 min (~11.6 hrs)	Creating Adaptive Flutter Screens and Widgets by @dylanscottmickelson (`94.2%`)
`"Gemini"`	3 / 65	62	691.8 min (~11.5 hrs)	My Phone Broke, and Gemini Fixed It by @omarafifi (`95.0%`)
`"Security"`	8 / 65	57	635.1 min (~10.6 hrs)	The one you reported is gone. This one is still up. by @mrveiss (`93.7%`)
`"Debugging"`	12 / 65	53	595.5 min (~9.9 hrs)	My Phone Broke, and Gemini Fixed It (`95.0%`) & Jerry Ran Out of Numbers But Drank All the Punch (`93.7%`)
`"Databases & SQL"`	13 / 65	52	530.7 min (~8.8 hrs)	SQL Common Table Expressions and Window functions by @mrpercival (`96.0%`)
`"Career"`	20 / 65	45	447.8 min (~7.5 hrs)	Dreams & Cheers & The Most Painful Career Lesson My Best Job Taught Me by @canro91 (both `92.7%`)
`"AI Agents"`	36 / 65	29	329.6 min (~5.5 hrs)	Pair Programming With Three AI Tools by @elsie-rainee (`95.6%`)

How I Built It

voice note (optional)   ──▶ ElevenLabs Scribe STT → text filter (remote transcript deleted immediately)
tab URLs / pile         ──▶ Browserbase Cloud Chromium (CDP) → word count, code blocks, tables, snippet
7 DOM features + intent ──▶ Prior Labs TabPFN (CPU) → P10, P50, P90 utility quantiles
P90 surviving tabs      ──▶ Gemini 3.1 Flash Lite + Gemma Pool → grounded card polish → validator (targeted repair → Python fallback)
                        ──▶ Gemma 4 / 3 → 2-sentence brief → check_output() digit gate (1 retry → template)
verified brief + cards  ──▶ ElevenLabs Flash v2.5 audio + printable section summary

Code owns the numbers, TabPFN predicts the distribution, Gemini and Gemma write the words, and Sentry traces every step.

1. The reading-time rule ranks tabs no better than a coin flip

A naive tab cleaner uses a reading-time rule: close anything old or long. That fails immediately for developers, because a 6-day-old documentation tab with 11 code blocks is something you still need, while a 4,800-word opinion essay from two weeks ago is dead weight.

I built a 3,600-row tab telemetry dataset (data/developer_tabs_telemetry.csv) with seven numerical features—six extracted from the DOM (age_days, word_count, code_block_count, table_count, heading_count, link_density) plus one intent-match score for how well the page matches what you asked for.

I held out 720 unseen tabs (20%) and compared Prior Labs TabPFN (output_type="quantiles", quantiles=[0.10, 0.50, 0.90]) against a Reading-Time & Recency Heuristic and HistGradientBoostingRegressor in benchmarks/ablate.py:

Model (Evaluated on 720 Unseen Tabs)	Average Error (MAE) ↓	RMSE ↓	Spearman Rank $r$ ↑	Real Scores Inside 80% (`P10–P90`) Band	Real Scores Below `P90`
Reading-Time & Recency Heuristic	21.88	26.68	0.033	—	—
`HistGradientBoosting` (Quantile)	3.95	4.94	0.967	55.3%	77.4%
Prior Labs TabPFN (All 7 Features)	3.5	4.31	0.975	77.9%	90.0%
TabPFN Ablation (without `intent_match_score`)	15.4	18.32	0.390	81.2%	91.7%
TabPFN Ablation (without `code_block_count`)	4.18	5.37	0.965	80.7%	92.1%
TabPFN Ablation (without `age_days`)	3.87	4.79	0.971	78.5%	90.4%

Two things jump out of this table. First, the reading-time heuristic ranks tabs no better than random chance (Spearman 0.033)—"close anything old or long" is statistically meaningless. Second, look at the fifth column (Real Scores Inside 80% P10–P90 Band). That is why TabPFN is here instead of gradient boosting:

HistGradientBoostingRegressor with quantile loss is fast, but its P10–P90 interval only captured 55.3% of unseen tabs—it is overconfident by nearly 25 percentage points.
TabPFN's Bayesian prior distribution captured 77.9% of unseen tabs inside its 80% band—within two points of nominal—and 90.0% fell below its P90 upper bound (while lowering MAE to 3.5 and RMSE to 4.31).

Even more importantly, closing a browser tab is an asymmetric risk: keeping one extra borderline tab costs 30 seconds of skimming, while closing a reference tab you actually needed destroys context. In src/tabpfn_engine.py, TabPFN predicts the full quantile distribution [0.10, 0.50, 0.90] in a single forward pass on CPU:

# src/tabpfn_engine.py — Calibrated quantile triage on CPU
reg = TabPFNRegressor.create_default_for_version(
    ModelVersion.V2, device="cpu", n_estimators=4
)
reg.fit(X_train, y_train)
quantiles = reg.predict(X_test, output_type="quantiles", quantiles=[0.10, 0.50, 0.90])
# Asymmetric guardrail: only set a tab aside when even its optimistic P90 bound < 45.0
verdict = "CLOSE_ARCHIVE" if p90 < 45.0 else "KEEP_EXTRACT"

If you triage tabs using a point estimate (P50 < 45.0), you close 8.33% of genuinely useful reference tabs. By setting a tab aside only when even its optimistic P90 upper bound falls below threshold (P90 < 45.0), Folivora cuts the False-Close Rate by 23x down to 0.36% (1 / 276 useful tabs) on the 720 held-out tabs while still clearing 86.3% of dead weight:

Triage Decision Policy (on 720 Unseen Tabs)	Useful Reference Tabs Wrongly Closed ↓	False-Close Rate ↓	Dead Tabs Cleared ↑	Total Utility Conserved ↑
Reading-Time & Recency Heuristic (`score < 45`)	66 / 276	23.91%	34.9%	72.3%
`HistGradientBoosting` Point Triage (`P50 < 45`)	23 / 276	8.33%	95.9%	57.9%
`HistGradientBoosting` Upper-Bound Triage (`P90 < 45`)	13 / 276	4.71%	90.8%	62.7%
`TabPFN` Point Triage (`P50 < 45`)	23 / 276	8.33%	96.8%	57.3%
`TabPFN` Quantile Guardrail (`P90 < 45`, Shipped)	`1 / 276`	`0.36%`	`86.3%`	`67.6%`

2. The ablation that explained my browser habits

Look at the fourth row in the benchmark table above: removing intent_match_score—the one feature that is not a DOM statistic at all, but a measure of how well a tab matches what you said you were looking for—collapsed the model. MAE jumped from 3.5 to 15.4 (4.4× worse), Spearman rank correlation fell from 0.975 to 0.390, and RMSE rose by +325% (4.31 → 18.32).

The single most valuable signal in the whole pipeline isn't anything the page measures—it's your ten-second voice note. That ablation is the reason Folivora is voice-first: say "the Japan rail-pass math" or "the laptop battery comparison" into ElevenLabs Scribe and the predictions get dramatically sharper than any passive crawling could make them.

Among the DOM-only features, code_block_count is the strongest (removing it degrades RMSE by +24.6%, 4.31 → 5.37), while age_days matters least (+11.1%). Grouping all 3,600 tabs in the dataset by page archetype shows why:

Page Archetype (`n = 3,600`)	Avg Word Count	Avg Code Blocks	Avg Utility Score	Safe to Close After 7 Days
Directory / Link Hub (`nav_hub`)	644 words	0.1	27.8 / 100	91.1%
Long-Form Essay (`long_essay`)	4,031 words	0.3	32.1 / 100	80.5%
Tech Brief / News (`tech_brief`)	973 words	4.6	44.1 / 100	55.1%
Deep Guide with Code (`deep_guide`)	1,530 words	8.6	48.8 / 100	44.6%

91.1% of link-hub tabs and 80.5% of 4,000-word essays are safe to close after 7 days. We tell ourselves we're going to read a 4,500-word essay over the weekend, and four times out of five we never do. Deep guides dense with code blocks are the opposite: they hold the highest average utility (48.8 / 100) and are the least safe to discard—because the only thing we ever needed from them was the 3-line snippet inside.

3. Browserbase Cloud Chromium over raw CDP WebSockets

Installing a 400 MB local Chromium binary inside a small cloud container eats RAM that belongs to PyTorch and TabPFN.

Instead, src/browserbase_service.py creates a remote session on Browserbase (POST /v1/sessions), fetches the DevTools WebSocket URL from /v1/sessions/{id}/debug, and drives up to 16 links directly over Python's websockets using Chrome DevTools Protocol (Target.createTarget, Target.attachToTarget, Page.navigate, and Runtime.evaluate). It polls document.readyState, verifies the final URL is still public, reads the rendered DOM, and reuses the same section-aware extractor as the HTTP path. It returns the live debuggerFullscreenUrl to the UI and always calls REQUEST_RELEASE in a finally block so none of the concurrency slots leak.

4. Gemma 4 & Gemma 3 write the words; `check_output()` checks every digit

Once TabPFN partitions the pile, Python knows the exact numbers: total_tabs, closed_count, kept_count, and minutes_saved (at 220 words per minute). Open-weight Google Gemma 4 (gemma-4-26b-a4b-it with thinkingLevel: "MINIMAL") and Gemma 3 (google/gemma-3-27b-it, google/gemma-3-12b-it, or local Ollama gemma3:4b) write a two-sentence spoken brief.

In early testing, Gemma kept trying to sound "helpful" by rounding 152.9 minutes to "about 150 minutes" or adding "in 3 seconds". So check_output() enforces a strict digit allowlist:

Every numeric literal (\b\d+(?:\.\d+)?\b) in Gemma's reply must exist in Python's allowed_numbers set.
closed_count, kept_count, and minutes_saved must appear character-for-character.
Strictly 10 to 42 words, with no markdown (**) or conversational filler.

A failed draft gets one retry that names the exact rejected token ("Your previous draft was rejected for: unverified_or_rounded_number:150"). If the retry also fails, a deterministic template answers instead.

I ran four prompt versions across 60 test piles (full report in eval/EVAL.md):

Prompt	What Changed	Passed First Try	Printed (with 1 Retry)	Backup Template Used
v1	Plain prompt	32 / 60 (53.3%)	53 / 60 (88.3%)	7 / 60 (11.7%)
v2	38-word cap + "Plain text only"	45 / 60 (75.0%)	59 / 60 (98.3%)	1 / 60 (1.7%)
v3	"Copy numbers character-for-character without rounding"	50 / 60 (83.3%)	58 / 60 (96.7%)	2 / 60 (3.3%)
v4 (Shipped)	Locked 2-sentence order + named rejected digits on retry	55 / 60 (91.7%)	59 / 60 (98.3%)	1 / 60 (1.7%)

The rejections were not mysterious. Each failure mode got a named fix in code:

What Gemma Did During Testing	What Fixed It in Code
Rounded `79.6 minutes` to "about 80 minutes" to sound conversational	Digit allowlist: every numeric literal must exist character-for-character in Python's `allowed_numbers` set
Wrapped the closed count in `bold` and opened with "Sure! Here is your summary:"	Markdown + preamble regex rejects `*`, "Sure,", "here is"*, and the usual clichés
Added "in 3 seconds" and "1-page cheat sheet" — digits that were never in the input facts	Retry prompt names the exact rejected token (`unverified_or_rounded_number:3`); the prompt now writes "one-page" in words
Quietly dropped `kept_count` from the second sentence	`missing_required_fact` triggers the one retry naming the missing number

5. A small model is a careless witness — so every card passes a three-stage repair shop

A two-sentence executive brief isn't enough when you're trying to close 60 tabs without losing the technical substance inside the kept ones. Each surviving card also needs a 35–50-word overview and 3–4 section-anchored takeaways (Heading — Key Insight, 30–45 words each).

When I first wired live model polishing onto the cards, almost every card fell back to the static summary:

Calling gemma-4-26b-a4b-it without "thinkingConfig": {"thinkingLevel": "MINIMAL"} caused the model to burn its token budget on internal reasoning thoughts before emitting spoken prose. Setting thinkingLevel: "MINIMAL" cut executive-digest latency to ~2.5 seconds, and a round-robin Open-Weight pool across Gemma 4 26B (gemma-4-26b-a4b-it) and Gemma 3 12B (gemma-3-12b-it) distributes concurrent card requests without per-model rate-limit bottlenecks.
On per-tab JSON rewrites, models frequently cited a valid section idea but paraphrased 1 word inside the 6–15-word anchor substring, or wrote a 28-word bullet when the validator required 30–45 words.

Instead of throwing away the whole card when one bullet is 2 words short, src/summary_service.py uses a three-stage verification and self-healing pipeline:

_repair_draft_citations(): Maps every takeaway to its highest token-overlap E#/C# evidence block and extracts an exact 8-word contiguous substring anchor directly from the source evidence.
validate_tab_summary() (tab-summary-validation-v3): Rejects emojis, quote-only bullets, first-person diary narration, cross-view duplication (Jaccard >= 0.68), invented numbers/units, and verbatim evidence copying (>=90% token containment).
_repair_bullets(): If a draft fails only on bullet-level rules (e.g., takeaway_1_word_count:28 or takeaway_3_verbatim_copy), Folivora rewrites only the offending bullet at temperature=0.1 and re-validates—polishing 8 / 8 top cards in ~10-16 s via gemini-3.1-flash-lite (provider-load dependent; I measured 14.4 s for a full 8-card batch) while keeping all 11 quality gates green in eval/summary_quality.py (20 / 20 golden cases, mean 4.65 / 5.0 manual readability):

Quality Gate (`python eval/summary_quality.py --gate`)	Requirement	Measured Result (`n = 20`)	Status
`no_unsupported_numbers`	`0` invented or rounded digits/units	`0`	✅ PASS
`no_quote_only_bullets`	`0` raw dialogue/quote-only bullets	`0`	✅ PASS
`no_verbatim_copy`	`0` bullets copying `>=90%` of an evidence block	`0`	✅ PASS
`no_emoji` & `no_forbidden_claims`	`0` emojis or cross-page claim contamination	`0`	✅ PASS
`duplicate_rate_below_5pct`	`< 5.0%` near-duplicate takeaway pairs (`Jaccard >= 0.68`)	`0.0%`	✅ PASS
`fact_coverage_at_least_85pct`	`>= 85.0%` required technical facts preserved	`100.0%`	✅ PASS
`word_target` & `manual_review`	`>= 18 / 20` within `140–220` words & `>= 4.0 / 5.0` readability	`20 / 20` (`mean 4.65 / 5.0`)	✅ PASS

Because every web page inspected by a browser agent is untrusted input, I also built a 24-case Adversarial Prompt-Injection & Canary Red-Team Suite (eval/redteam_eval.py) across 8 threat families (T1 score hijacking, T2 hallucinated metrics/units, T3 spoofed E#/C# anchors, T4 markdown/jailbreak preambles, T5 first-person/emoji hijacks, T6 verbatim evidence copying, T7 raw dialogue dumps, and T8 private body/CANARY-FOLIVORA-9941-SECRET exfiltration):

Pipeline Configuration (`eval/redteam_eval.py`)	Hijacked Outputs (`n = 24`)	Attack Success Rate (ASR) ↓	Canary Secret Leaks ↓
Naive Unvalidated LLM Summarizer	24 / 24	100.0%	3 / 3
JSON-Schema-Only (`_TabSummaryDraft` Pydantic Validation)	21 / 24	87.5%	0 / 3
Folivora Hardened (`check_output()` + `validate_tab_summary()` v3 + Allowlist + Scrubber)	0 / 24	`0.0%`	`0 / 3`

Look at the second row: responseMimeType: "application/json" plus Pydantic schema validation still let 21 of 24 attacks (87.5%) straight through, because JSON schemas constrain syntax, not semantics, grounding, or verbatim copying. Only deterministic post-generation verification drops the Attack Success Rate to 0.0%.

6. Sentry Agent Tracing: and the two bugs my traces caught

Every Browserbase session, TabPFN quantile pass, Scribe transcription, and Gemma/Gemini call runs inside an OpenTelemetry op="gen_ai.request" or summary.* span in src/telemetry.py, recording model IDs, input/output tokens, tokens/sec, latency, and estimated cost.

Two real bugs showed up during testing:

The float('inf') word-count crash Caught by Sentry: When a malformed page reported an infinite numeric value, _sanitize_num() cleaned the NumPy feature matrix for TabPFN, but left the raw inf inside the tab dictionary—crashing sum(int(t["word_count"])) with OverflowError: cannot convert float infinity to integer. Writing the sanitized integers back into the enriched tab dict fixed it, verified by test_handles_nan_and_inf_gracefully.
Preserving gen_ai.usage.input_tokens in before_send: A naive secret scrubber that redacts any key containing "token" (api_token, access_token, tabpfn_token) also blanks out gen_ai.usage.input_tokens and gen_ai.usage.output_tokens. Using the negative-lookbehind/lookahead regex (?<!put_)token(?!s) in SECRET_KEY_PATTERN kept all secrets redacted ([Redacted]) while leaving OpenTelemetry token counts intact:

# src/telemetry.py — Scrub auth tokens while preserving gen_ai.usage.input_tokens / output_tokens
SECRET_KEY_PATTERN = re.compile(
    r"(api[_-]?key|secret|password|authorization|bearer|(?<!put_)token(?!s)|dsn)",
    re.IGNORECASE,
)

7. Two deployment lessons: TabPFN v2 open weights & CPU threads on Render

Why TabPFN v2 is the default on headless servers: tabpfn v9.1.0 defaults to ModelVersion.V3_5, which sits behind an interactive license check that can hang non-interactive container workers if not cached. Calling TabPFNRegressor.create_default_for_version(ModelVersion.V2, device="cpu", n_estimators=4) uses Prior Labs' fully open weights with zero interactive prompts (while keeping TABPFN_MODEL_VERSION=v3.5 one environment variable away) and runs warm quantile inference for 14 tabs in ~1.3 s on a laptop CPU (the shared 2-vCPU container takes a few seconds, which is exactly why the deterministic fast lane runs ahead of the AI lanes and identical preset requests are served from a 10-minute TTL cache in under 30 ms).
Thread pool capping (OMP_NUM_THREADS=2): On shared cloud hosts, PyTorch sizes its thread pool from the host machine's physical cores rather than the container's slice. Pinning OMP_NUM_THREADS=2 and pre-baking the weights in the Dockerfile keeps container startup and inference latency flat on Render.

Honest Limits (What It Can't Do Yet)

Intent-hungry predictions: The ablation above cuts both ways—without a spoken or typed intent, intent_match_score is near zero for every tab and triage accuracy falls back toward DOM-only quality (MAE 15.4). That is exactly why Summarize All mode deliberately keeps every readable tab instead of guessing, and why the mic button sits next to the topic chips.
Auth-walled tabs (detected, not guessed): Browserbase can inspect any public documentation, GitHub issue, or blog post, but sites like Facebook, YouTube, LinkedIn, or Cloudflare-challenged pages serve a cookie-less fetcher a wall instead of the article — a login screen, Google's consent page, a bot check, or a bare JavaScript shell with no readable text at all. Folivora detects all four (wall phrases, or a plain-HTTP response with under 120 raw words), labels the tab Login-walled/Unreadable page with an honest note instead of summarizing the wall, and forces it to stay open with maximum-uncertainty quantiles (P10/P50/P90 = 20/50/99) — the same asymmetric-safety rule as the P90 guardrail: never auto-close a page the server couldn't actually read. Your logged-in browser still shows the real page; only the server was blind. Tabs behind your personal company SSO get the same honest label.
Swapped counts inside the allowed set: As documented in eval/REVIEW.md, if kept_count is 5 and closed_count is 9, both '5' and '9' are in allowed_numbers. A set-based digit check can't tell if a model swapped which was which, so the UI renders the primary counters directly from Python's JSON response rather than parsing Gemma's prose.

Why Does Open Innovation Matter?

Every decision in this pipeline is made by an open-weight model. TabPFN v2 (open weights, CPU, local inference) decides which tabs are safe to set aside, and open-weight Gemma 4 26B (with Gemma 3 27B/12B and local gemma3:4b as fallback lanes) writes the spoken brief behind check_output() — the digest lane contains no closed model at all. The one closed model in the stack, Gemini Flash Lite, is a speed-only fallback for card prose: each card tries the open-weight lanes first (Ollama → Gemma 4 → Gemma 3), Gemini only answers when an open lane blows the responsive-UI budget, its output passes the same deterministic validate_tab_summary() gate, and setting SUMMARY_POLISH_PROVIDER=gemma (or running without a Google key) removes it entirely — the app degrades to local Ollama or deterministic cards, never breaks.
Your browsing backlog is private. The tabs sitting open in your browser reveal what you're working on, what bugs you're stuck on, and what you read at night. Because TabPFN and Gemma are open-weight models, you can point OLLAMA_BASE_URL at a local Ollama instance (gemma3:4b) and score and summarize your tabs with your data staying under your control.
Inspectable calibration. When an automation tells you it's safe to set aside 36 tabs, a black-box score isn't enough. With open weights and benchmarks/ablate.py, anyone can verify on 720 unseen tabs that TabPFN's 80% interval actually covers 77.9% of real cases and achieves a 0.36% False-Close Rate.
Set it up once, $0 recurring subscription. A weekly tab cleanup tool shouldn't cost $20/month in proprietary token bills.

The Lazy Payoff

I ran Folivora on my own two real browser windows this week — an everyday 14-tab window and a 10-tab work window (24 open tabs, 61,020 words total). Neither was an extreme hoard; that's the point. Twenty-four ordinary "I'll read it tonight" tabs:

Metric	Doing It By Hand	With Folivora	Effort Saved
Tabs inspected across both windows	24 open tabs (61,020 words)	24 open tabs	—
Tabs safely set aside (`< P90` bound)	0 (kept procrastinating)	15 dead essay/directory tabs set aside (52,370 words)	238.0 minutes of reading skipped
Key takeaways extracted	Reading 9 pages in full and copy-pasting notes (~28 mins)	9 section-anchored takeaway sets in a printable digest	1 click + 1 eight-second voice note

Prize Categories

Best Use of TabPFN: Prior Labs' TabPFN predicts calibrated P10 / P50 / P90 utility quantiles for every tab (src/tabpfn_engine.py). Backtested on 720 unseen tabs from a 3,600-row dataset (benchmarks/ablate.py), beating the reading-time heuristic (MAE 3.5 vs 21.88, and the heuristic's Spearman 0.033 means it ranks tabs no better than chance), beating HistGradientBoosting on both error (3.5 vs 3.95) and P10–P90 uncertainty calibration (77.9% vs 55.3%), with a feature ablation showing the stated-intent signal is load-bearing (removing it: MAE 3.5 → 15.4), and cutting the False-Close Rate by 23x (8.33% → 0.36%) via the P90 < 45.0 quantile guardrail.
Best Use of Browserbase: src/browserbase_service.py creates live cloud Chromium sessions on Browserbase (POST /v1/sessions), connects over CDP WebSockets to extract real rendered-DOM metrics for up to 16 links (word_count, code_block_count, table_count, heading_count, and section-anchored takeaways), falls back per link on CDP failure, surfaces the live debuggerFullscreenUrl in the UI, and releases every session slot cleanly (REQUEST_RELEASE).
Best Use of Gemma: Open-weight Google Gemma 4 (gemma-4-26b-a4b-it with thinkingLevel: MINIMAL) and a round-robin Gemma 4 26B + Gemma 3 12B/27B/4B pool (src/gemma_service.py) power the two-sentence spoken digest behind check_output() (59 / 60 [98.3%] verified in eval/EVAL.md & eval/REVIEW.md) and the grounded card-polish pipeline (20 / 20 golden cases in eval/summary_quality.py and 0.0% ASR across 24 adversarial attacks in eval/redteam_eval.py).
Best Use of ElevenLabs: Bidirectional voice workflow in src/audio_service.py—ElevenLabs Scribe (scribe_v1) transcribes spoken filter rules and immediately deletes the remote transcript (DELETE /v1/speech-to-text/transcripts/{id}) for privacy, while ElevenLabs Flash v2.5 (eleven_flash_v2_5, Charlie voice) reads the verified two-sentence brief aloud.
Best Use of Sentry Agent Tracing: Every Browserbase CDP run, TabPFN quantile prediction, Scribe transcription, and Gemma/Gemini call is wrapped in an OpenTelemetry op="gen_ai.request" or summary.* span (src/telemetry.py) with token counts, throughput, and cost, backed by unit-tested regex scrubbing ((?<!put_)token(?!s)) that preserves gen_ai.usage.input_tokens.
Best Use of Render: Deployed at https://folivora.tech via a declarative render.yaml Blueprint and Dockerfile with pre-baked TabPFN weights, /health readiness probes, OMP_NUM_THREADS=2 CPU thread tuning, and per-IP sliding-window limits on the expensive /triage, /polish-tabs, /digest, /transcribe-voice, and /synthesize-audio routes.
Best Use of a .tech Domain: The entire product lives at folivora.tech—and the name is the theme: Folivora is the taxonomic suborder of tree sloths, so the domain had to be the sloth's own name. Mapped to the Render Blueprint with automatic SSL, it's the one URL in this post that does everything: triage, live Browserbase sessions, voice, the pitch deck, OpenAPI docs, and the extension download.

Try It on Your Own Tabs

Don't take my word for it — folivora.tech is open, no sign-up. Paste a few links you've been "meaning to read," or launch a built-in sample window, and get your own two-line briefing before your coffee cools.

Everything is MIT-licensed at github.com/OmarAfifi-CSE/folivora — if the sloth mishandles one of your pages, that's exactly what the issue tracker is for. 🦥

SunSync: How I Used TabPFN, Google Gemma, and ElevenLabs to Help Developers Touch Grass

Omar Afifi — Sun, 11 Oct 2026 20:33:46 +0000

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

What I Built

Most software developers spend their working days indoors under artificial lighting, locked to an IDE, staring at screens for hours on end.

By mid-afternoon, the consequences are familiar across the tech community: eye strain, brain fog, fading focus, and a disrupted circadian rhythm that makes quality sleep an uphill battle. For years, I treated this as simply the unavoidable occupational hazard of writing code.

The real issue isn't a lack of discipline or coffee—it's that standard indoor work environments fight against basic human biology.

The human body relies on natural daylight to set its internal circadian clock. But standard office windows filter out the specific daylight wavelengths needed to feel alert. Even sitting right next to a window, indoor lighting is rarely brighter than 400–500 lux—compared to 10,000+ lux outdoors. To the body, sitting inside all day feels like constant twilight, draining energy and throwing off sleep.

And the tech industry's standard answer to developer burnout? Another screen. Wellness apps that demand more typing, habit trackers with endless push notifications, and weather apps that treat sunlight purely as a sunburn hazard.

I built SunSync as a direct alternative.

SunSync is a lightweight open-source daylight timing tool built with a single goal: evaluate local sunlight in under 30 seconds, give you a quick 15-second eyes-free voice brief, lock into a 20-minute outdoor breathing timer, and get you away from your desk into the fresh air.

How It Works in Practice

Zero-Shot Tabular ML on CPU (Prior Labs TabPFN): Instead of naive heuristics, a foundation tabular transformer (TabPFNRegressor) fits 12 daylight hours in a single forward pass without gradient descent, evaluating solar angles, cloud cover, and irradiance to compute your best 20-minute sunlight window (e.g., 13:15 - 13:35).
Eyes-Free Spoken Directive (Google Gemma + ElevenLabs): A 15-second spoken briefing delivers the key window and UV safety tips using ElevenLabs' low-latency eleven_flash_v2_5 model and the natural, calm Charlie voice—turning raw telemetry into a human send-off so you don't have to keep reading a screen.
Production Grounding for Safe Health Guidance: Gemma crafts natural, encouraging dialogue, while a deterministic validation layer guarantees that safety-critical numbers (the computed window start and UV index) remain strictly grounded to the underlying physics.
The Outdoor Breathing Lock: When you tap "I'm going outside", the UI locks into a 20-minute circular breathing timer so you can put your phone away. You focus on the horizon (never staring directly at the sun) and return to your desk refreshed and ready to code.

Demo

The app is live, publicly accessible, and deployed on Google Cloud Run with interactive OpenAPI documentation:

🌐 Live Web Application: https://sunsync.omar-afifi.com
📡 Interactive OpenAPI Specification: https://sunsync.omar-afifi.com/docs
💻 GitHub Repository: https://github.com/OmarAfifi-CSE/sunsync

Mobile-First Interface Tour (Zero Mockups)

☀️ 01 · Hero Protocol	⏱️ 02 · 20-Min Sun Window	🎙️ 03 · Gemma Spoken Brief	🌿 04 · Touch Grass Protocol

Glance card: today's window, live countdown, recharge score — the 10-second answer.	Decision card (GO NOW / Wait / Done) + UV safety bands + daylight curve to 6 PM.	Fact-verified Gemma directive with source badge (✦ Gemma live / ⚡ edge instant) + Charlie voice playback.	The outdoor commitment card: 20-minute breathing timer + auto-playing voice send-off, phone face-down.

Every screenshot above is a raw capture from my live production deployment on Google Cloud Run - zero synthetic device frames, zero mockups.

What to Look for When Testing

The app dynamically adapts to whatever time of day you test it:

Test Your Location or City Presets: Tap Use my location or switch between presets (Cairo, London, New York, Tokyo). SunSync calculates the solar window relative to that location's local solar clock, not your computer's clock.
Dynamic Real-Time States:
- Upcoming Window (Wait): If it's daytime before the computed peak, you'll see a live countdown ticking down to the recharge window.
- Active Window (GO NOW): If you test during the peak window, the status badge flips to GO NOW with live UV guidance.
- Past Window (Done today): If the sun has set or the peak has already passed in that city, the card displays Done today and advises morning light tomorrow—it will never tell someone to go recharge under a dark night sky.
Listen to Charlie (Voice Briefing): Tap Listen · 15s brief on any location to hear the lifelike ElevenLabs voice briefing with real-time UV safety tips.

Code

The entire codebase is open-source, fully tested, and available on GitHub:

💻 GitHub Repository: https://github.com/OmarAfifi-CSE/sunsync

The project is structured around lean, modular Python services:

src/circadian_ml.py: Prior Labs TabPFN zero-shot Bayesian tabular regression on live CPU.
src/gemma_service.py: Google Gemma integration paired with deterministic factual grounding (validate_directive()).
src/audio_service.py: ElevenLabs low-latency voice synthesis via eleven_flash_v2_5 (Charlie voice).
src/data_service.py: Ingests real-time Open-Meteo weather data (solar irradiance, UV index, cloud cover, and sun angles) to feed into TabPFN.
src/app.py: FastAPI application instrumented with distributed Sentry tracing spans.

How I Built It

1. System Architecture & Dual-Lane Decoupling

I enforced a strict architectural principle: The user's first paint must never wait on generative AI.

                ┌─────────────────────────────┐
                │  Live Open-Meteo Telemetry  │
                │(Hourly UV, Solar Irradiance)│
                └──────────────┬──────────────┘
                               │
                               ▼
                ┌─────────────────────────────┐
                │   Feature Vector Assembly   │
                │  (12-Hour Daylight Context) │
                └──────────────┬──────────────┘
                               │
                               ▼
[Sentry Spans]  ┌─────────────────────────────┐
(Distributed) ─►│  Prior Labs TabPFN ML Core  │
(Latency Trace) │ (Zero-Shot Bayesian CPU ML) │
                └──────────────┬──────────────┘
                               │
                               ▼
                ┌─────────────────────────────┐ ◄── [Grounding Layer]
                │ Google Gemma Directive Core │     (Factual Verify:
                │ (Natural Spoken Directive)  │      Window & UV)
                └──────────────┬──────────────┘
                               │
                               ▼
[Google Cloud]  ┌─────────────────────────────┐
(Cloud Run)   ─►│ ElevenLabs Audio Synthesis │
(Public Host)   │ (Lifelike Charlie Briefing) │
                └─────────────────────────────┘

I decoupled the execution into two asynchronous paths:

The Fast Lane (/evaluate): Computes solar geometry, atmospheric vector transforms, and TabPFN scoring. Returns the deterministic solar window and recharge score immediately with an instant analytical draft.
The Slow Upgrade Lane (/directive & /synthesize-audio): Asynchronously generates the personalized Google Gemma voice directive and ElevenLabs audio stream, upgrading the UI quote in place without blocking interaction.

2. Prior Labs TabPFN: Foundation Tabular ML on CPU

In src/circadian_ml.py, I run the real TabPFNRegressor on live CPU. My training context is exactly 12 rows—the daylight operational hours of a single day (7 AM to 6 PM).

Classical ML algorithms like XGBoost or RandomForest fail here: they demand hundreds of rows, hyperparameter tuning, and cross-validation splits that don't exist in single-day telemetry. TabPFN is a prior-fitted transformer trained on millions of synthetic tabular tasks that performs Bayesian posterior inference in a single forward pass without gradient descent:

Metric / Verification Check	Production Measured Result
Peak window reproducibility across consecutive runs	✅ Identical time window every run (deterministic)
Score variance across repeated runs	0.00
Window stability under seeded ±5% sensor noise	✅ Resilient & stable (score Δ 2.6)
Warm inference execution on multi-core CPU	~1.1–1.5 s
Container cold initialization (one-time weight loading)	~15–17 s (isolated to container cold boot; never blocks warm traffic)

# From src/circadian_ml.py
from tabpfn import TabPFNRegressor

# 12 daylight rows. No gradient descent: forward pass stores tabular context
regressor = TabPFNRegressor(device="cpu", n_estimators=4)
regressor.fit(X_train_atmospheric, y_melanopic_target)
predicted_eml = regressor.predict(X_train_atmospheric)

With only 12 hourly data points per day, traditional ML models fall apart. TabPFN is built specifically for this: delivering accurate Bayesian predictions on small tabular data in under a second without overfitting or requiring hours of hyperparameter tuning.

To deploy SunSync cleanly in production, I packaged the application into an optimized container running on Google Cloud Run with 4 vCPUs and 4 GB RAM in europe-west1. Within the container runtime, I tuned PyTorch's intra-op parallelism (torch.set_num_threads(min(4, os.cpu_count()))) and configured TabPFNRegressor(n_estimators=4). This unlocks multi-core execution on the tabular transformer while preventing thread thrashing, keeping memory rock-solid and delivering consistent sub-1.5s inference on warm instances.

3. Sentry Distributed Agent Tracing: Real Production Telemetry Bands

I instrumented the entire pipeline with distributed Sentry tracing spans (ai.telemetry.ingest, ai.model.tabpfn, and ai.llm.gemma) to monitor live production performance, diagnose latency variances, and ensure pipeline health.

Rather than publishing synthetic local benchmarks, Sentry reveals the authentic behavior across live cloud conditions on Google Cloud Run:

Span Name	Operation	Warm Production Range	Production Lifecycle Notes
`ai.telemetry.ingest`	Open-Meteo REST Fetch & Serialization	70–300 ms	Live upstream solar telemetry fetch (varies with DNS & regional latency)
`ai.model.tabpfn`	TabPFN Tabular Feature Fitting & Scoring	~1.1–1.5 s	In-memory zero-shot Bayesian regression on 4 vCPUs
`ai.llm.gemma`	Google Gemma Narrative Generation	~1.4–2.2 s	Non-blocking slow-lane synthesis via OpenRouter/Google AI Studio
Fast-Lane User Delivery	`/evaluate` Deterministic Delivery	~1.5–2.5 s	Immediate deterministic UI paint; zero blocking on LLM or audio generation

What Sentry Revealed: Observability in Action

Cold Starts vs. Warm Multi-Core Execution: In a serverless container environment like Google Cloud Run, initial container spin-up requires importing PyTorch and loading TabPFN's transformer checkpoint into memory (~15–17s on cold boot). Sentry tracing immediately surfaced this difference: once the container is warm, multi-core CPU execution consistently executes in ~1.1–1.5s. Sentry isolated container lifecycle overhead from algorithmic compute.
Upstream Data Hygiene: Distributed tracing caught intermittent floating-point NaNs returned by upstream weather sensors, allowing me to inject a deterministic sanitization layer (_sanitize_float) before data reaches TabPFN.
Dual-Lane User Protection: By tracing span durations, I verified the value of decoupling /evaluate (the fast lane) from /directive and /synthesize-audio (the slow lane). The user's screen renders the photobiology dashboard in ~2 seconds, while Gemma and ElevenLabs upgrade the briefing asynchronously in the background.

4. Google Gemma: Fast Generative Directives with Production Grounding

To deliver a personalized, encouraging voice brief that doesn't sound like a boilerplate weather bot, I integrated Google's Gemma 3 27B (google/gemma-3-27b-it).

Gemma excels at following concise persona instructions while maintaining a natural, empathetic tone. For SunSync's fast-paced user flow, instruction-tuned Gemma delivers punchy 15-second directives in seconds without the latency overhead of extended thinking traces.

Grounding & Health Safety Guardrails (`src/gemma_service.py`)

Because UV exposure and solar timing directly affect user well-being, production AI requires strict factual grounding. Gemma provides the creative, human variety, while code verifies that safety-critical numbers match reality before reaching the user:

# From src/gemma_service.py
def validate_directive(self, text: str, window_time: str, uv_index: float) -> bool:
    """
    Code-decides guardrail: The model narrates, but only verified facts ship.
    A candidate passes iff it repeats the computed window start AND grounds
    the UV reading. Any hallucinated drift is instantly rejected.
    """
    if not text or len(text.strip()) < 20:
        return False

    start = str(window_time).split("-")[0].strip()
    if start and start not in text:
        return False  # Hallucinated or shifted time -> rejected

    try:
        uv_token = f"{float(uv_index):.1f}"
    except (TypeError, ValueError):
        return False

    text_lower = text.lower()
    if uv_token not in text and "uv" not in text_lower:
        return False  # Dropped or fabricated UV safety reading -> rejected

    return True

This dual-layer architecture guarantees total reliability: Gemma crafts natural, motivating copy, while the verification layer ensures that the solar window and UV safety readings remain 100% faithful to the underlying telemetry. The UI displays an authentic badge indicating the exact origin (✦ Gemma live vs ⚡ edge instant).

5. ElevenLabs Voice Architecture: Screen-Free Audio Presence

Standard browser text-to-speech engines sound robotic, monotone, and clinical—developers tune them out immediately. To build an app that genuinely motivates someone to step away from their desk, the voice needed to feel calm, natural, and human.

I integrated ElevenLabs using the eleven_flash_v2_5 model and the official Charlie voice (IKne3meq5aSn9XLyUdCD):

Low-Latency Voice: eleven_flash_v2_5 synthesizes the spoken brief in seconds while the UI stays fully interactive, and a browser-voice fallback guarantees the guide plays even if the API is unreachable.
Calm, Human Pacing: Charlie delivers a natural, reassuring presence when reading the computed UV warnings and window times.
Eyes-Free Outdoor Send-Off: When you tap "I'm going outside", Charlie plays a warm send-off audio message so you can pocket your phone immediately and head out without looking back at the screen.

6. The Field Test: Taking SunSync Outside for 20 Minutes (Bonus Challenge)

The Hacktoberfest Week 1 challenge brief includes an explicit bonus criteria: taking the build outside, testing it in the real world, and reporting the experience.

During development, when SunSync computed my local 20-minute peak recharge window (14:15 - 14:35), I followed my own protocol:

I opened the live production URL on my phone, tapped Listen · 15s brief, heard Charlie read out the computed window and UV safety tips, and tapped the green commitment button ("I'm going outside").
The UI locked into the 20-minute circular breathing ring. I turned the phone face-down, slipped it into my pocket, and walked out under the open sky.
Instead of checking notifications, I just looked out toward the horizon and took a walk (without staring directly at the sun, of course).

How it actually went:
You notice the difference within a few minutes. Staring at an IDE two feet away for hours puts constant strain on your eyes. Looking out at the horizon under natural outdoor daylight lets your eyes relax and gives your nervous system a genuine reset. By the time the 20-minute timer wrapped up and I walked back to my desk, the usual 3:00 PM afternoon slump was gone—no extra coffee required.

7. Handling Timezones & Diurnal States: Real API Outputs

Because SunSync runs live against the target location's solar clock, the decision engine and Gemma's spoken brief adapt dynamically to the time of day. Below are unedited API responses captured from the production service demonstrating how the system handles different diurnal states:

When the Day's Peak Has Already Passed (e.g., Evening in Cairo):
- Coordinates: 30.04° N, 31.24° E · Computed Window: 14:15 - 14:35 · Score: 100/100 · UV: 5.35
- Gemma Spoken Brief: "Quick one: Just noting your daylight break peak — it was 14:15 - 14:35 with a UV of 5.35 — missed it, but let's aim for softer morning light tomorrow!"
- Behavior: Recognizes the peak has passed, the UI displays Done today, and advises softer morning light tomorrow without false "go outside now" prompts in the dark.
When the Day's Peak Is Upcoming (e.g., Morning in New York):
- Coordinates: 40.71° N, -74.01° W · Computed Window: 14:15 - 14:35 · Score: 100/100 · UV: 0.95
- Gemma Spoken Brief: "Hey you: Your daylight break with a UV index of 0.95 opens later today between 14:15 - 14:35, so be ready to step outside then!"
- Behavior: Confirms future tense ("opens later today"), ticking down a live countdown rather than prompting the user prematurely.
When Testing Across Far Timezones (e.g., Midnight in Tokyo):
- Coordinates: 35.68° N, 139.65° E · Computed Window: 12:15 - 12:35 · Score: 100/100 · UV: 5.2
- Gemma Spoken Brief: "Fresh air alert: Your daylight break with a UV value of 5.2 opens between 12:15 - 12:35 today, so prepare to step outside then!"
- Behavior: Evaluates Tokyo-local time (UTC+9) rather than the tester's client time, correctly scheduling the upcoming daylight window.

Why Does Open Innovation Matter?

Closed wellness algorithms treat human biology as a proprietary subscription black box. Building SunSync on an open-source architecture made critical capabilities possible that closed proprietary APIs simply cannot deliver:

Circadian Health Belongs to Everyone, Not Subscription SaaS: Human biology is not an enterprise product. By building SunSync with open-source models, open data, and containerized infrastructure, the entire pipeline costs ~$0.00 to run at this scale. Anyone can fork the repository, deploy the included Dockerfile on Google Cloud Run's free tier, and use it indefinitely without paying a $15/month wellness tax.
Local CPU Independence via TabPFN: Closed AI APIs demand continuous internet connectivity, recurring credit card billing, and API key management. TabPFN running zero-shot on local CPU proves that high-performance scientific modeling doesn't require gigawatt GPU clusters. Serving TabPFN directly on the application CPU keeps tabular predictions fast, self-contained, and completely free of remote ML endpoint costs.
Strict Data Privacy: Commercial wellness applications harvest location history to monetize behavioral profiles. SunSync queries Open-Meteo for atmospheric weather only. My LLM prompts receive pure numerical arrays (irradiance, UV, angles)—personal coordinates are never passed to any AI model.
Transparent, Reproducible Logic: Proprietary health apps hide behind vague, closed algorithms. By keeping SunSync open source, every developer can inspect the exact solar calculations, daylight thresholds, and automated test suites.

Prize Categories

Featured Categories

1. Best Use of TabPFN (Prior Labs)

How SunSync Uses It: Evaluates real 12-row tabular atmospheric telemetry vectors on live CPU using TabPFNRegressor(n_estimators=4) with zero GPU dependencies. TabPFN predicts Equivalent Melanopic Lux (EML) in a single forward pass without gradient descent, achieving a 0.00 score variance across repeated runs. Foundation weights are pre-baked into Docker image layers, and warm multi-core CPU execution consistently evaluates in ~1.1–1.5s on Google Cloud Run.
Evidence in Repo: src/circadian_ml.py · Determinism & stability benchmarks · tests/test_circadian_ml.py

2. Best Use of Gemma (Google)

How SunSync Uses It: Uses Google's state-of-the-art open model (google/gemma-3-27b-it via OpenRouter with Google AI Studio fallback) to synthesize the 15-second spoken outdoor directive. Gemma turns raw telemetry into an encouraging, natural audio brief, protected by a production grounding layer (validate_directive()) that ensures computed window times and UV safety ratings remain strictly accurate.
Evidence in Repo: src/gemma_service.py · tests/test_gemma_service.py

Partner Categories

3. Best Use of Sentry Agent Tracing

How SunSync Uses It: Shows the entire pipeline's performance via distributed tracing spans (ai.telemetry.ingest, ai.model.tabpfn, and ai.llm.gemma). Sentry traces directly revealed upstream network latency, informed the progressive dual-lane decoupling, and surfaced upstream floating-point NaNs that led to the _sanitize_float safety layer. Token metrics (llm.estimated_prompt_tokens: 48) are attached to every span.
Evidence in Repo: src/app.py 42–52 & 212–220 · Latency waterfall table in write-up · Expandable Sentry telemetry HUD in UI

4. Best Use of ElevenLabs

How SunSync Uses It: Powers SunSync's eyes-free audio interface using the eleven_flash_v2_5 model and the official Charlie voice (IKne3meq5aSn9XLyUdCD). Delivers lifelike voice briefings and outdoor send-offs so developers can pocket their phones without looking at screens. ElevenLabs transforms what would otherwise be a robotic notification into a calm, human ritual that encourages stepping away from the desk.
Evidence in Repo: src/audio_service.py · src/static/app.js (voice pipeline: synthesizeAudioElement, speakViaBrowser fallback, playDetoxGuide)

Closing: Step Away from the Screen

For years, I treated developer fatigue as a software problem to be solved with more software, more productivity tools, and more screen time.

Building SunSync reinforced the opposite truth: the most valuable thing an AI tool can do is provide a fast, mathematically grounded answer, get completely out of the way, and encourage a return to the physical world.

Human knowledge has real limits, and so does biological endurance. A developer simply isn't built to spend 14 hours a day under office lights staring at glowing screens.

Now, close this tab.

Lock your screen.

Step outside, and go touch some grass. 🌿

Building an Agent That Can't Afford to Be Wrong: Quran Sanity Agent

Omar Afifi — Sun, 04 Oct 2026 06:59:52 +0000

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

When I first opened the Sanity Challenge announcement, one sentence in the Path One brief immediately grabbed my attention:

"Build anything that needs an answer it can't afford to get wrong."

That one line defined this entire project.

If you ask an AI chatbot for movie recommendations or a recipe, a small hallucination is harmless. But if you ask it about the Quran, religious scripture, or classical commentary, getting things wrong is not an option.

Yet that is exactly what standard LLMs do every day:

They drop words from verses or invent Arabic grammar on the fly.
When two classical scholars disagree, the model either invents a fake consensus or blends both opinions into a confusing, contradictory mess.
It cites famous books and scholars with total confidence, even when the quote never existed in that book.

Traditional RAG (Retrieval-Augmented Generation) doesn't fix this either, because dumping raw chunks into a prompt still leaves the model free to summarize, blur, and paraphrase whatever it wants.

I wanted to see what happens when you treat the problem differently: what if the AI literally cannot generate Quranic text? What if the agent only has access to verified, structured records in Sanity, and conflicting historical opinions are modeled cleanly as data rather than smoothed over?

That is what Quran Sanity Agent is built to do.

What I Built

Quran Sanity Agent is a bilingual (Arabic & English) web research workspace where every single verse, translation, and scholarly commentary is anchored to an immutable record in Sanity.

How It Works in Practice

Verses Are Read, Never Generated: The LLM is never asked to recite or recall Quranic text from memory. Every Ayah displayed in the interface is pulled directly from a verified Sanity document matching the authoritative Tanzil Uthmani 1.1 reference standard.
Scholarly Differences as Structured Data: In classical Islamic exegesis (Tafsir), scholars have debated linguistic nuances and legal rulings for over a thousand years. Instead of hiding these differences, the application structures them into two distinct categories:
- Contradictory (Ikhtilaf Tadadd): True conflicting positions (e.g., whether the opening Basmalah is counted as a verse of Al-Fatihah).
- Complementary (Ikhtilaf Tanawwu'): Multi-faceted meanings that coexist (e.g., whether Al-Asr refers to time itself or the afternoon prayer).
The Evidence Drawer: Every verse and commentary card has an interactive citation badge. Clicking it opens a side drawer showing the exact Sanity Document ID, the physical book locator (chapter, volume, and primary URL), and the raw JSON payload straight from the Content Lake.
Honest Evidence Gaps: If you ask a question outside the curated dataset (like modern cryptocurrency rulings), the agent doesn't try to guess or produce an ungrounded opinion. It explicitly reports an Evidence Gap, showing what records it searched and clarifying that no authoritative source is available.

Demo

The app is live, publicly accessible, and backed by a hosted Sanity Studio:

🌐 Live Web Application: https://quran-sanity.omar-afifi.com
🏛️ Hosted Sanity Studio: https://quran-evidence-studio.sanity.studio/
💻 GitHub Repository: https://github.com/OmarAfifi-CSE/quran-sanity-agent

Zero-Trust Transparency: The Live Evidence Drawer

Inspect real-time Sanity Document IDs, physical book locators, and raw JSON payloads straight from the Content Lake.

Queries You Can Test Right Now

Here are four questions you can paste into the live app to see the structured pipeline in action:

Exact Verse Integrity:
- Query: 2:255 (or switch the UI to Arabic and type البقرة ٢٥٥).
- What to look for: Instant retrieval of Ayat al-Kursi with verified Uthmani script and Saheeh International translation. Click the citation badge to view ayah-2-255 in the Evidence Drawer.
Contradictory Divergence:
- Query: Compare interpretations of Al-Fatiha Basmalah
- What to look for: Surfaces the opposing classical positions between Ibn Kathir / Al-Qurtubi vs. Fakhr al-Din al-Razi side-by-side, without the model taking a side or muddying the waters.
Complementary Divergence:
- Query: Compare interpretations of Al-Asr
- What to look for: Shows how Al-Tabari, Ibn Kathir, and Al-Qurtubi each highlight complementary dimensions of the word (time, human deeds, afternoon prayer).
Semantic Retrieval via Sanity Context MCP:
- Query: What does the Quran say about justice even against oneself?
- What to look for: The agent queries the Sanity Context MCP endpoint, ranks Ayah 4:135 at the top, and provides grounded notes quoting the primary text verbatim.

Code

The entire codebase is open-source and available on GitHub:

👉 github.com/OmarAfifi-CSE/quran-sanity-agent

The project is structured as a TypeScript monorepo:

web/: Next.js 15 (App Router) interface with full Arabic RTL support and the Sanity Context MCP integration.
studio/: Sanity Studio v3 with custom Desk Structure and dedicated Islamic hermeneutic schemas.
scripts/: Verification tools ensuring zero character drift against reference text standards.

How I Used Sanity

This project is built around the idea that an agent is only as reliable as the structure behind its content.

Here is how Sanity handles every layer of the architecture:

┌──────────────────────────────────────────────────────────┐
│                   SANITY CONTENT LAKE                    │
│   • 114 Surahs (Surah number, names, revelation type)    │
│   • 6,236 Ayahs (Uthmani text, translation, keywords)    │
│   • 6 Tafsir Authorities (Scholar, death year, school)   │
│   • 12 Audited Interpretive Claims with primary excerpts │
└────────────┬─────────────────────────────┬───────────────┘
             │                             │
    Exact Lookups (GROQ)          Semantic Queries (MCP)
             │                             │
             ▼                             ▼
┌──────────────────────────┐  ┌─────────────────────────────┐
│ Deterministic Lake Fetch │  │ Sanity Context MCP Endpoint │
│  • Sub-50ms response     │  │  • 21,398 library chunks    │
│  • Direct schema joins   │  │  • Vector embeddings rank   │
└────────────┬─────────────┘  └────────────┬────────────────┘
             │                             │
             └──────────────┬──────────────┘
                            ▼
┌──────────────────────────────────────────────────────────┐
│                 NEXT.JS AGENT WORKSPACE                  │
│   • Verifies all candidate IDs against Content Lake      │
│   • Rejects AI notes that lack verbatim source quotes    │
│   • Renders bilingual cards & Evidence Drawer            │
└──────────────────────────────────────────────────────────┘

1. The Content Model (`studio/schemaTypes/`)

Instead of generic blog or article schemas, Sanity Studio manages structured Quranic and classical commentary data:

surah: Core chapter metadata (number, Arabic name, English name, revelation type, verse count).
ayah: Individual verse records containing Tanzil Uthmani text, verified English translations, and references to parent chapters.
tafsirSource: Classical authorities (e.g. Al-Tabari d. 310 AH, Al-Qurtubi d. 671 AH, Ibn Kathir d. 774 AH) with their specific methodology (athari, juridical, rational, linguistic).
interpretiveClaim: An atomic claim linking an ayah to a tafsirSource. It stores the primary excerpt (primaryExcerpt), the physical book locator (sourceLocator), the divergence classification (contradictory, complementary, consensus), and editorial status.
sourceEdition & libraryChunk: Ingestion schemas representing 21,398 chunks across classical commentaries for semantic retrieval.

2. The Editorial Review Gate

One of the most practical things about Sanity Studio is how easily you can customize the Desk Structure to enforce editorial discipline.

In studio/deskStructure.ts, I added a custom "Needs source review" filter:
If an editor enters a new claim but forgets the primary book excerpt, the exact source URL, or the reviewer sign-off, Sanity immediately catches it and moves it into this review queue.

More importantly, the Next.js agent's GROQ queries strictly filter for reviewStatus in ["source_checked", "reviewed"]. If a claim hasn't passed the editorial gate, the AI agent is physically unable to see it or use it in an answer.

3. Sanity Context MCP & Semantic Retrieval

While exact verse numbers (e.g. 2:255) are resolved instantly via deterministic GROQ queries, thematic questions (e.g. "What does the Quran say about justice?") require semantic understanding.

To handle this, I pointed Sanity Context at the imported library of 21,398 chunks and enabled Content Lake embeddings:

When a user asks a conceptual question, the agent queries the remote Sanity Context MCP endpoint.
The MCP server ranks relevant chunks based on semantic similarity and returns their document IDs.
The Grounding Rule: The agent never relies solely on the LLM's summary. It uses those document IDs to re-fetch the raw records directly from the Content Lake.
Verbatim Quotation Enforcement: If the model generates an explanatory note, the application validates that the note quotes words directly from the retrieved source text. If it fails this check, the UI falls back to displaying the raw verified excerpt.

Sanity Project Details

Sanity Project ID: qkca243t
Dataset: production
Hosted Studio: https://quran-evidence-studio.sanity.studio/
Sanity Context MCP Endpoint: https://api.sanity.io/v1/context/organizations/o831wcpb9/mcp/quran-evidence-mcp
Content Lake Stats: 6,369 primary documents (114 Surahs, 6,236 Ayahs, 6 Tafsir Sources, 12 Curated Interpretive Claims) and 21,398 indexed library chunks.

What Building This Taught Me

Building this project made one thing very clear:

The solution to AI hallucination in high-stakes domains isn't "better prompts" or larger models. It's structured content.

When you treat texts as unstructured strings dumped into a vector database, the AI is always one step away from fabricating an answer. But when you model your domain properly—distinguishing chapters from verses, authorities from editions, and consensus from disagreement—the AI stops guessing and starts acting as an interface to verified knowledge.

Sanity was uniquely suited for this: having schemas, the Content Lake, GROQ, and the Context MCP in one unified ecosystem meant I could build a zero-hallucination agent that remains completely transparent with every answer it gives.

Check out the live project at quran-sanity.omar-afifi.com and explore the code on GitHub.

My Phone Broke, and Gemini Fixed It

Omar Afifi — Wed, 09 Sep 2026 22:26:48 +0000

📱 Picture This: An All-Nighter Turns Into a Morning Nightmare

It is early morning. You’ve just pulled an all-nighter tinkering with an Android project over ADB. The sun is already creeping through the window, tests finally pass, and you unplug the USB cable from your OnePlus to finally go to bed.

You unlock your screen, swipe down to open Settings, and freeze.

Right across your menus is a block of bright-red monospace text:

isOverScrolling: false
X: FlingVX: 0.0, ClickVX: 0.0
Y: FlingVY: 15435.0, ClickVY: 0.0
AbortVX:0.0, AbortVY:15435.0

You stare at it, then touch the screen again. The numbers immediately jump, recalculating in real time with every movement of your thumb. You swipe fast, and FlingVY shoots into the tens of thousands.

Then you notice something even worse: the phone is lagging badly.

When you swipe from the screen edge to go back, the gesture stutters. Pulling out the OnePlus Smart Sidebar hesitates and drops frames. The smooth 120Hz display suddenly feels like a cheap phone struggling to keep up.

🥶 Zero Results: When Google Goes Completely Silent

Your developer reflexes kick in immediately. You jump straight into Developer Options:

Pointer Location? Off.
Show Layout Bounds? Off.
Show Taps? Off.
Strict Mode? Off.

Everything is disabled.

Fine. You hold down the power button and reboot. The phone restarts, you unlock it, open Settings, scroll down—and the red numbers are still right there.

That's when you start to panic. You open your browser and start searching:

"red text on android screen": Generic guides telling you to turn off Developer Options.
"OnePlus red text on screen": Threads asking about the red "1" on the lock screen clock (funny, but not helping).
"OnePlus red text error": Nothing remotely relevant.
"isOverScrolling: false" OnePlus: No results found.
"AbortVX" / "ClickVX": Absolute zero.

Zero results. Not a single thread on XDA Forums, not a mention on Reddit, and nothing on the OnePlus Community.

If you've worked with Android long enough, you know what this silence means: when an issue has zero documentation in AOSP and zero community threads, you're usually looking at a full factory reset.

😴 "That’s Future Me’s Problem"

At that point, the morning sun was already up. I had stayed up all night, I was running on zero sleep, completely exhausted, and my brain felt like an OutOfMemory error. I stared at the red numbers on my screen and made the most mature engineering decision possible:

I decided to go to sleep.

"You know what? This is future me's problem."

I put the phone face-down on the nightstand, closed my eyes, and hoped it would just magically disappear by the time I woke up.

Fast forward to later that afternoon: I woke up, tapped the screen, and nope—the red velocity numbers were still right there, tracking every single swipe while I was still half-asleep.

Now awake and ready to deal with it, I decided it was time to bring in serious backup.

🤖 Handing the Terminal to Gemini

I plugged the USB cable back into my laptop. I opened my Antigravity IDE where I had been pair-programming with Gemini, and typed out of pure frustration:

"Hey, you ran some ADB commands on my phone earlier for some app testing and now there's this weird red text on my screen and the edges are lagging. I plugged it in—fix it."

If this were a standard chatbot, you already know what its first response would be:

"Go to Settings > Developer Options and disable 'Pointer Location', 'Show Layout Bounds', or 'Strict Mode'. If those are already off, try backing up your data and performing a factory reset."

Every standard LLM defaults to that exact script because it assumes you're dealing with standard Android toggles. And when you tell it they're already off, it hits a complete dead end.

Instead, Gemini took the wheel. What happened on my terminal over the next few minutes was impressive: rather than giving boilerplate advice, Gemini started systematically diagnosing the operating system from the inside out.

🎨 Step 1: The Canvas Deduction

Gemini didn't guess. It queried the device's runtime settings via ADB:

adb shell settings get system pointer_location
adb shell settings get system show_touches

Both came back 0. Standard Android touch telemetry was definitively off.

Then Gemini dumped the entire live UI hierarchy of the Settings app:

adb shell uiautomator dump /sdcard/window_dump.xml

It grepped the XML tree for isOverScrolling. The result? Empty.

That silence told Gemini everything:

"This text does not exist as a TextView or a system overlay window. It is being painted directly onto the hardware Canvas buffer during draw passes by an internal UI component."

Because the text appeared during scrolling in OnePlus system menus, Gemini formed an immediate hypothesis: the code belonged to OnePlus/OPPO’s proprietary UI toolkit—COUI (ColorOS UI).

🔬 Step 2: Disassembling the Phone on the Fly

Because these OEM classes are completely proprietary and unreleased, Gemini couldn't look up documentation. It had to read the machine code directly from the phone.

To inspect the COUI framework without needing root access, Gemini pulled a built-in pre-installed app that uses the same UI components:

adb pull /product/app/Calculator2/Calculator2.apk ./calc.apk

Then, right inside my terminal, Gemini wrote and executed Python scripts to parse the raw binary DEX (Dalvik Executable) structures of the APK.

1. Hunting the String Table

Gemini parsed the DEX string pool inside calc.apk and found the exact IDs:

String #2600 = 'AbortVX:'
String #37919 = 'isOverScrolling: '

2. Pinpointing the Method

It mapped those string IDs across every class definition in the binary. In seconds, Gemini had the exact location:

Class: androidx.recyclerview.widget.COUIRecyclerView (OnePlus’s internal extension of the Jetpack RecyclerView)
Method: dispatchDraw(Canvas canvas) at bytecode offset 0x1fbea0

3. Reading the Dalvik Bytecode

Gemini disassembled the opcodes at that offset. The bytecode showed exactly what was going on under the hood:

0x1fbea0: invoke-virtual View->dispatchDraw
0x1fbea6: sget COUIRecyclerView->COUI_DEBUG:Z   // Check static boolean flag
0x1fbeaa: if-eqz -> 0x1fc03c                   // If false, skip entirely!
0x1fbeae: iget COUIRecyclerView->mDebugPaint   // Get Paint object
0x1fbec4: invoke-virtual Paint->setColor       // Set paint color to RED
0x1fbed4: const-string 'isOverScrolling: '     // Format velocity strings
0x1fbf2a: const-string 'X: FlingVX: '
0x1fbf86: const-string 'Y: FlingVY: '
0x1fbfe4: const-string 'AbortVX:'
0x1fc036: invoke-virtual Canvas->drawText      // Draw directly on screen!

There it was: an undocumented, internal scroll-physics debugger built by OEM engineers to measure fling velocities during ROM development.

💥 Step 3: The Domino Effect — Finding Patient Zero

Gemini now knew what was painting the screen, but why had COUI_DEBUG suddenly turned true across my entire phone?

Gemini inspected the class initializer <clinit> of COUIRecyclerView:

0x1fb9bc: const-string 'COUIRecyclerView'
0x1fb9c2: invoke-static COUILog->isLoggable("COUIRecyclerView", Log.DEBUG)
0x1fb9d6: sput COUIRecyclerView->COUI_DEBUG:Z

COUILog.isLoggable() simply calls Android's built-in android.util.Log.isLoggable(tag, level).

In Android, Log.isLoggable() first checks for a tag-specific system property (log.tag.<TAG>). If that doesn't exist, it checks the global fallback property:

🎯 The Culprit: persist.log.tag

Gemini queried the phone:

adb shell getprop persist.log.tag

The terminal printed one character:

Connecting the Dots

Hours earlier, while debugging an audio service over ADB, a command had set persist.log.tag to V (Verbose) to inspect background audio logs.

That one command triggered an unexpected chain reaction:

Why it survived reboots: Properties starting with persist. are saved directly to flash storage (/data/property). A reboot does not wipe them.
Why the red text appeared: Every time any app initialized a scrollable list, COUIRecyclerView checked if debug logging was enabled. Because persist.log.tag was set globally to V, Android replied that everything was in verbose mode. COUI_DEBUG became true, and the red velocity overlay activated.
Why the edges were lagging: With global verbose logging enabled across the entire OS, every single touch event, swipe coordinate, and edge gesture flooded the system log daemon with hundreds of log lines per second. The CPU was overwhelmed with logging I/O, dropping frames and causing noticeable edge touch lag.

⚡ The Cure: Total Relief in Five Seconds

Once Gemini identified the exact root cause, the fix was quick and clean:

1. Resetting the Global Flag

Gemini reset the dangerous persistent global log property to empty:

adb shell setprop persist.log.tag ""

2. Preventing It from Happening Again

To make sure COUIRecyclerView could never wake up its debug drawing again—even if global verbose logging were accidentally enabled in a future project—Gemini injected a permanent tag-level suppression rule:

adb shell setprop persist.log.tag.COUIRecyclerView SUPPRESS

3. Killing the Active Process for Instant Testing

Gemini killed the Settings process to immediately test the fix on the current window:

adb shell am force-stop com.android.settings

Gemini triggered an automated swipe gesture through ADB, captured a live screenshot, and verified that the red text had vanished from Settings.

4. The Final Device Reboot: Flushing In-Memory State

While Settings was fixed immediately, Gemini pointed out a crucial Android runtime mechanic:

In the Dalvik/ART virtual machine, static initializers (<clinit>) run only once when a class is first loaded into a process. That meant any app or system service already running in RAM (like the Launcher, SystemUI, or Contacts) still held COUI_DEBUG = true cached in memory.

To guarantee that every background process, system daemon, and service reloaded cleanly from scratch with the new suppressed properties, we performed a fresh device reboot:

adb reboot

Once the phone rebooted, I picked it up, unlocked it, and scrolled through every corner of the system:

The red text was 100% gone across all apps.
The edges were instantly responsive. Edge gestures, the Smart Sidebar, and the silky 120Hz display were completely restored.
Zero personal data touched, zero system partitions modified.
All temporary extraction scripts were cleanly wiped from both the phone and PC.

🎓 Final Thoughts: An Engineering Student Left Speechless

As a Computer & Systems Engineering student, I usually take AI hype with a grain of salt. I understand how systems work under the hood, and I know how complex and messy OEM Android frameworks get when low-level state gets corrupted.

If I had posted this on a forum or asked a standard chatbot, the advice would have been the same generic response: back up your data and factory reset.

Watching Gemini handle this live in my terminal was genuinely impressive. It didn't guess, and it didn't give generic tips. It followed a solid systems debugging process:

It systematically eliminated UI layers until only hardware Canvas rendering was left.
It pulled compiled OEM packages directly from the phone without needing root access.
It wrote Python scripts on the spot to parse binary DEX string pools and find the right class offsets.
It analyzed the raw Dalvik bytecode and isolated the exact sget instruction controlling the overlay.
It traced an undocumented UI flag back to a persistent Linux system property that had survived reboots.

Watching an AI autonomously reverse-engineer compiled bytecode on a live device—and solve an undocumented framework issue in minutes without touching a single byte of my personal data—was amazing to see.

This isn't just about autocompleting syntax or generating boilerplate code anymore. This is a real glimpse into the future of systems engineering—and as an engineering student, it completely blew me away.

The Ghost in the View Transitions API: A Bizarre Debugging Saga with Google AI 👻

Omar Afifi — Fri, 07 Aug 2026 17:35:35 +0000

This is a submission for DEV's Summer Bug Smash: Clear the Lineup powered by Sentry.

🎨 Project Overview

While working on a major upgrade for my personal portfolio (Check it out here: Live Portfolio Link | GitHub Repo), I built a feature called the Theme Showcase. When a user first loads the homepage, a slick View Transitions API animation sweeps across the screen, temporarily switching the site to one of my custom showcase themes (like "Obsidian" or "Midnight"), before gracefully sweeping back to their chosen default theme. It was a 1.7-second "Wow Effect" designed to show off the site's dynamic color system.

🐛 Bug Fix

Soon after deploying, I noticed a terrifying, chaotic bug. Sometimes, I would open the website and quickly switch to another tab to check an email, or minimize the browser window completely. When I switched back...

Instead of my beautiful default theme, the website was permanently stuck on one of the other showcase themes! The animation had frozen mid-way, leaving the site in an awkward intermediate state. While the website was still fully functional and I could manually fix it by selecting my original theme from the dropdown menu, it was a terrible first impression for a professional portfolio. It was as if a ghost had possessed the CSS.

My first instinct? Smash the refresh button. Refreshing would actually fix the glitch and play the animation perfectly—but only if I stayed patiently on the tab and watched it finish! If I refreshed and immediately switched tabs again, the ghost would return.

💻 Code

Here is the exact code change we made to exorcise the ghost. (You can view the full fix in this GitHub Commit)

The Buggy Code (Before):

const transition = document.startViewTransition(() => {
  html.setAttribute('data-theme', theme);
});

// If the browser aborts the transition here, the Promise rejects and execution halts forever!
transition.ready.then(() => {
  const animation = document.documentElement.animate(/* ... */);
  animation.onfinish = resolve;
});

The Bulletproof Code (After):

let isCancelled = false;

// 1. Gracefully handle tab switching
const handleVisibility = () => {
  if (document.hidden) {
    isCancelled = true;
    html.setAttribute('data-theme', originalTheme); // Instantly restore
    document.removeEventListener('visibilitychange', handleVisibility);
  }
};
document.addEventListener('visibilitychange', handleVisibility);

// 2. Bulletproof the View Transition Promise
return new Promise(resolve => {
  try {
    const transition = document.startViewTransition(() => {
      if (!isCancelled) html.setAttribute('data-theme', theme);
    });

    transition.ready.then(() => {
      if (isCancelled) return resolve();

      const animation = document.documentElement.animate(/* ... */);
      animation.onfinish = resolve;
      animation.oncancel = resolve;

    }).catch(() => {
      // THE MAGIC FIX: If the browser aborts the transition (background tab), resolve immediately!
      resolve();
    });
  } catch (error) {
    // Fallback if startViewTransition throws synchronously
    if (!isCancelled) html.setAttribute('data-theme', theme);
    setTimeout(resolve, duration);
  }
});

🛠️ My Improvements

My technical approach to resolving this was two-fold:

State Management on Visibility Change: I added a visibilitychange event listener. If the user navigates away, we instantly cancel the sequence and forcefully restore the original theme to prevent intermediate states.
Error Handling for the View Transitions API: The core issue was that browsers forcefully abort the startViewTransition when a tab is hidden to save battery. This caused the transition.ready Promise to reject. Because there was no .catch() block, the unhandled rejection caused the entire async sequence to hang permanently. By wrapping the transition in a try/catch and adding a .catch(() => resolve()) handler, we guarantee that the execution flow always continues gracefully, even if the browser interrupts it.

🤖 Best Use of Google AI

I couldn't figure out why this bug was only happening sometimes, and no errors were showing up in the console. So, I turned to my trusty pair programmer: Google AI integrated within the Antigravity IDE.

What's really cool about my workflow is that I chat with my AI agent completely casually in Arabic. It feels incredibly natural, like brainstorming with a senior engineer sitting right next to me. But debugging with AI isn't always a "one-shot" magic trick. It’s an iterative journey.

(Note: I interact with my AI agent natively in Arabic! For this post, I have translated our debugging conversation. I've kept the original Arabic screenshots on hand just in case the judges want to see them!)

Phase 1: The Misdiagnosis

At first, I explained the symptoms loosely to the AI:

Me: "I have another issue. Sometimes the theme changes to dark suddenly and weird things happen. I don't know what it is."

The AI analyzed the code and thought the animation feature itself was the bug (assuming it was just annoying the user). So, it enthusiastically offered a "fix" by completely disabling the showcase animation function!

I had to intervene and correct its assumption:

Me: "Bro, no, you misunderstood! The animation at the beginning is natural and fine. What's NOT natural is leaving the website open, going to another tab, and coming back to find it permanently stuck on a new theme."

Phase 2: The Deep Dive

Once I steered the AI in the right direction, it immediately dug into the mechanics of tab-switching. It realized that modern browsers aggressively pause requestAnimationFrame when a tab goes to the background.

The AI wrote the visibilitychange listener, but then we ran into another issue when I was testing it locally with my dev server.

Me: "Why does it open on a different theme every time I hit save in my editor? I have to manually refresh to get my original theme back."

The AI assumed I was just being impatient with the 1.7-second animation delay during live-reloads:

AI: "When you save, the dev server refreshes the page. The animation starts, switches to the showcase theme, and then returns. You are just manually refreshing before the 1.7 seconds finish, trapping yourself in a loop! Just wait 1.7 seconds."

Phase 3: The "Aha!" Moment

I knew I wasn't just being impatient. The UI was literally getting stuck. I pushed the AI to look deeper:

Me: "Bro, I'm not rushing. I open it, find it on a new theme, and it is completely STUCK on it. This causes problems if the user goes to another tab. Focus well, think carefully, and take your time."

That’s when the AI hit the absolute jackpot.

It didn't just hand me a snippet of code; it provided a masterclass on browser mechanics. It analyzed the View Transitions API behavior and uncovered the true root cause: to save battery and resources, modern browsers aggressively throttle or abort animations when a tab is hidden. This aggressive optimization was causing the transition.ready promise to reject silently, which hung the entire async sequence because it lacked a .catch() block.

I initially asked the AI if we could just "force" the browser to play the animation in the background anyway. Instead of blindly agreeing, the AI pushed back and explained the engineering philosophy behind this: it’s a hard performance constraint built into modern browsers. You can't fight the browser's resource management. Instead, it taught me the "Best Practice": monitor the tab's state (which led to the visibilitychange listener), gracefully catch any forced abortions (the .catch() fix), instantly restore the original UI, and respect the browser's rules.

Thanks to Google AI in the Antigravity IDE, I didn't just fix a bug—I learned exactly why the browser was behaving that way under the hood. It transformed a frustrating debugging session into a profound learning experience about advanced JavaScript APIs and browser rendering mechanics. This is exactly what the future of pair programming looks like!

Reviving Daphq: How I Built an Open-Source, Bare-Metal File Transfer Engine Solo with GitHub Copilot

Omar Afifi — Wed, 27 May 2026 21:12:32 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

Daphq is a robust, open-source, cross-platform file transfer application engineered entirely from scratch to deliver hardware-saturating speeds over local area networks (LAN), Wi-Fi, and Mobile Hotspots.

As a solo developer, I built Daphq to solve a personal frustration: the bloated overhead, privacy concerns, and artificial speed limits of conventional HTTP-based or cloud-reliant file-sharing tools. Daphq bypasses the standard Web/REST layer completely, establishing direct, bare-metal TCP Sockets (Socket & ServerSocket) with SocketOption.tcpNoDelay enabled to eliminate protocol latency and push network hardware to its absolute physical limits.

Built using Flutter (Dart) for seamless cross-platform performance (currently native on Android and Windows), Daphq features a highly decoupled architecture using the BLoC/Cubit pattern, multi-gigabyte memory protection guards, and background network synchronization, and intelligent user guidance.

Demo

The entire project is completely open-source and free to review, fork, or run locally:

🌐 Official Product Website: omar-afifi.com/daphq/
💻 GitHub Repository: github.com/omarafifi-cse/daphq

Screenshots in Action

Android UI Layout	Windows Desktop Experience

Clean, robust mobile layout with active background service tracking.	Fluid, modern, and highly responsive desktop experience.

The Comeback Story

Daphq was born under high pressure, but after shipping the bare bones of version v1.0.0, it was essentially abandoned in my local repository directory. The project had immense raw speed potential, but it was plagued by architectural gaps, clunky user workflows, and high-stress bugs that made it unviable for everyday users.

The GitHub Finish-Up-A-Thon Challenge was the exact catalyst I needed to dust off the codebase and transform it from a fragile command-like utility into a highly polished, resilient consumer application (v2.3.0).

The Deep Evolution: v1.0.0 vs. v2.3.0

Here is exactly how the architecture and UX matured over the course of this challenge:

Discovery, Connectivity & Resilience:
- Before (v1.0.0): Zero automation. Users manually typed cryptic IPv4 addresses, and any connection drop required a full app restart.
- After (v2.3.0): A custom UDP Auto-Discovery Service with an integrated watchdog. Backed by a rewritten, Bulletproof Receiver Engine, the app instantly bounces back if a connection drops or cancels abruptly—never getting stuck on "Connecting...".
User Interface, Fluidity & Storage:
- Before (v1.0.0): Rigid layouts, storage bloat from cached files, and main-thread hangs (UI freezing) when selecting large directories.
- After (v2.3.0): A unified dashboard anchored by an "Orbital Radar" and Non-Blocking Async UI. Sharing 1,000+ files is now buttery smooth with zero lagging. Plus, it features Persistent Folders to permanently remember your download path and Smart Auto-Cleaning to wipe cache bloat automatically.
Smart User Guidance:
- Before (v1.0.0): Users suffered from slow transfers due to ISP router bottlenecks without knowing why.
- After (v2.3.0): Integrated a real-time speed monitor that triggers a Smart Hotspot Guide if speeds drop below 2.0 MB/s, guiding users to utilize 5GHz direct hotspots for up to 10x faster speeds.
Memory Safety & Disk I/O Flow Control:
- Before (v1.0.0): High risk of Out-Of-Memory (OOM) crashes when streaming multi-gigabyte files due to unthrottled asynchronous disk reads.
- After (v2.3.0): Implemented zero-copy byte slicing (Uint8List.sublistView) and Natural Socket Backpressure (await socket.flush()). Daphq now self-throttles to match real-time network speeds, saving physical RAM.
Deep System-Wide Integrations:
- Before (v1.0.0): Isolated sandboxed app.
- After (v2.3.0): Deployed deep OS hooks, including native Android Share Menu entry and background execution. On Android, Instant Wake-up intelligently turns on the screen for incoming requests. On Windows, the Context Menu Shell Extension was completely rebuilt to be unbreakable, eliminating all File Explorer hangs.

My Experience with GitHub Copilot

As a solo developer, you are the software architect, the UI designer, the QA technician, and the DevOps engineer all at once. Time is your greatest bottleneck. Throughout this sprint, GitHub Copilot didn’t just autocomplete lines of boilerplate—it acted as an incredibly knowledgeable senior engineering peer, unlocking complex architectural problems.

Here are three distinct breakthroughs where GitHub Copilot completely changed the trajectory of the project:

1. Solving the Math of the Orbital Radar UI

I wanted the home dashboard to feel alive with an evenly distributed, deterministic "Orbital Radar" circle showing available peer devices. Distributing dynamic widgets symmetrically on a circular plane without them overlapping can quickly become a headache.

Copilot's Intervention: By providing Copilot with my layout boundaries and device state arrays, it instantly mapped out the exact trigonometric distribution math using cos and sin over a mapped index. Furthermore, it proactively recommended assigning unique ValueKeys to the dynamically generated widgets, preventing unnecessary re-paints and maximizing rendering performance on low-end hardware.

2. Eliminating the Windows FFI Mutex Deadlock

A critical, highly frustrating platform bug on Windows caused Daphq to accidentally trigger background execution loops whenever a user performed completely unrelated right-click shell actions elsewhere in the OS. Worse, exiting the app caused a stubborn Dart VM deadlock.

Copilot's Intervention: I explained the process conflict to Copilot. It guided me through structuring a clean, platform-specific local session mutex check. When it came to bypassing the Dart VM shutdown hang, Copilot instantly generated the safe native Windows FFI code block to execute a clean ExitProcess command, killing the deadlocks instantly and safely.

3. Engineering Flow-Safe Dynamic Streaming Buffer

To stop aggressive disk-read bursts from triggering Out-Of-Memory exceptions, I needed a way to throttle file streams smoothly based on network capacity.

Copilot's Intervention: Copilot analyzed my asynchronous data-sync loop and suggested transitioning away from arbitrary chunk delay timers. It helped refactor the code to explicitly await socket.flush() based on monitored bytesBuffered thresholds. The result was an automated backpressure loop that scales throughput up or down safely based on real-time network conditions.

// Standard path for larger files: stream in chunks
final reader = fileToRead.openRead();
try {
  await for (var chunk in reader) {
    if (_isCancelled) throw "Transfer Cancelled";
    try {
      socket.add(chunk);
      bytesBuffered += chunk.length;

      if (bytesBuffered >= AppConstants.socketFlushThresholdBytes) {
        // Awaited flush: provides backpressure so the disk read loop
        // runs at network speed, not disk speed. Without this, a fast
        // UFS device would read the entire file in <500ms before any
        // onUpdate fires, causing the snapshot/stutter UI bug.
        await socket.flush();
        bytesBuffered = 0;
      }
    } catch (e) {
      if (_isCancelled) throw "Transfer Cancelled";
      if (e is SocketException || e.toString().contains("reset by peer")) {
        throw "Receiver disconnected during transfer.";
      }
      rethrow;
    }

    // ... UI update logic 
  }
}

The Verdict

Building Daphq independently meant encountering dozens of architectural edge cases. Having GitHub Copilot available to instantly generate platform-specific guards, analyze multi-threaded socket behavior, and handle tedious Win32 registry bindings allowed me to focus on what mattered most: delivering a breathtakingly fast file transfer engine.

Daphq went from an unpolished repository artifact to a production-grade open-source engine capable of hitting 80-90 MB/s (~93% bandwidth saturation) over a standard local Wi-Fi 5 connection. I couldn't be prouder of how this challenge ended.

DEV Community: Omar Afifi

Folivora: an open-model reading room that predicts which of your open tabs you'll never actually read — and reads you the few that matter

What I Built

Demo

Code

Real-World Stress Test: Indexing the 65-Article DEV Hall of Fame (600+ Minutes of Reading)

How I Built It

1. The reading-time rule ranks tabs no better than a coin flip

2. The ablation that explained my browser habits

3. Browserbase Cloud Chromium over raw CDP WebSockets

4. Gemma 4 & Gemma 3 write the words; check_output() checks every digit

5. A small model is a careless witness — so every card passes a three-stage repair shop

6. Sentry Agent Tracing: and the two bugs my traces caught

7. Two deployment lessons: TabPFN v2 open weights & CPU threads on Render

Honest Limits (What It Can't Do Yet)

Why Does Open Innovation Matter?

The Lazy Payoff

Prize Categories

Try It on Your Own Tabs

SunSync: How I Used TabPFN, Google Gemma, and ElevenLabs to Help Developers Touch Grass

What I Built

How It Works in Practice

Demo

Mobile-First Interface Tour (Zero Mockups)

What to Look for When Testing

Code

How I Built It

1. System Architecture & Dual-Lane Decoupling

2. Prior Labs TabPFN: Foundation Tabular ML on CPU

3. Sentry Distributed Agent Tracing: Real Production Telemetry Bands

What Sentry Revealed: Observability in Action

4. Google Gemma: Fast Generative Directives with Production Grounding

Grounding & Health Safety Guardrails (src/gemma_service.py)

5. ElevenLabs Voice Architecture: Screen-Free Audio Presence

6. The Field Test: Taking SunSync Outside for 20 Minutes (Bonus Challenge)

7. Handling Timezones & Diurnal States: Real API Outputs

Why Does Open Innovation Matter?

Prize Categories

Featured Categories

1. Best Use of TabPFN (Prior Labs)

2. Best Use of Gemma (Google)

Partner Categories

3. Best Use of Sentry Agent Tracing

4. Best Use of ElevenLabs

Closing: Step Away from the Screen

Building an Agent That Can't Afford to Be Wrong: Quran Sanity Agent

What I Built

How It Works in Practice

Demo

Zero-Trust Transparency: The Live Evidence Drawer

Queries You Can Test Right Now

Code

How I Used Sanity

1. The Content Model (studio/schemaTypes/)

2. The Editorial Review Gate

3. Sanity Context MCP & Semantic Retrieval

Sanity Project Details

What Building This Taught Me

My Phone Broke, and Gemini Fixed It

📱 Picture This: An All-Nighter Turns Into a Morning Nightmare

🥶 Zero Results: When Google Goes Completely Silent

😴 "That’s Future Me’s Problem"

🤖 Handing the Terminal to Gemini

🎨 Step 1: The Canvas Deduction

🔬 Step 2: Disassembling the Phone on the Fly

1. Hunting the String Table

2. Pinpointing the Method

3. Reading the Dalvik Bytecode

💥 Step 3: The Domino Effect — Finding Patient Zero

🎯 The Culprit: persist.log.tag

Connecting the Dots

⚡ The Cure: Total Relief in Five Seconds

1. Resetting the Global Flag

2. Preventing It from Happening Again

3. Killing the Active Process for Instant Testing

4. The Final Device Reboot: Flushing In-Memory State

🎓 Final Thoughts: An Engineering Student Left Speechless

The Ghost in the View Transitions API: A Bizarre Debugging Saga with Google AI 👻

🎨 Project Overview

🐛 Bug Fix

4. Gemma 4 & Gemma 3 write the words; `check_output()` checks every digit

Grounding & Health Safety Guardrails (`src/gemma_service.py`)

1. The Content Model (`studio/schemaTypes/`)

🎯 The Culprit: `persist.log.tag`