DEV Community: Jirawat Boonkumnerd

ZeroVisual: I Was Too Lazy to Do Manual UI Testing, So I Made Open-Source AI Do It

Jirawat Boonkumnerd — Fri, 23 Oct 2026 05:00:32 +0000

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

I am lazy to do manual UI testing. Truly, unapologetically lazy.

There is nothing quite as soul-crushing on a Friday afternoon as manually resizing browser windows, squinting at full-HD screenshots to see which button shifted by 3 pixels, inspecting CSS flexbox margins on three different viewports, or calculating whether a muted gray button passes WCAG 2.1 AA color contrast.

When Vision LLMs arrived, the promise seemed magical: "Just dump a screenshot into an AI agent and let it review your UI!"

Except laziness quickly met reality:

The Vision Token Explosion: Feeding a single raw 1920×1080 screenshot to a Vision Transformer (ViT) burns 1,000 to 1,600 image tokens. Multiply that across Desktop, Tablet, and Mobile across a 30-test suite, and your CI/CD pipeline burns through hundreds of thousands of tokens per commit.
The 5MB Base64 Payload Pipe Choke: Shipping multi-megabyte Base64 image payloads over JSON-RPC or stdio to your local coding agent creates noticeable lag and IPC stalls.
Canvas Noise Hallucinations: When an LLM looks at an entire webpage canvas, it gets easily distracted by navigation links, avatars, and footer copyrights, often hallucinating defects on pixels that never actually changed.

Sloths have it figured out: move at your own pace, conserve energy, and let the work do itself. So in honor of International Sloth Day, I built ZeroVisual—an open-source, zero-API-key visual regression and automated UI design QA pre-processor that acts as a token-optimizing firewall between browser tests and Vision LLMs.

What I Built

ZeroVisual is a local pre-processing engine, custom Playwright Reporter, CLI, and Model Context Protocol (MCP) server. It cuts Vision LLM token usage by up to 75% on desktop viewports and network payloads by up to 98%, without requiring a single external API key.

It addresses the two most tedious UI tasks developers dread:

Automated Visual Regression (zerovisual regression & Playwright Custom Reporter):
Instead of immediately bombarding a vision model with full-page screenshots, ZeroVisual relies on a Two-Stage Architecture:
- Stage 1 (0 Tokens): Deterministic pixel diffing runs locally for free. If all visual tests pass, 0 AI tokens are consumed and CI completes in milliseconds.
- Stage 2 (Optimized Triage): When a test fails, ZeroVisual intercepts the Playwright diff, isolates the failure bounding box (with 32px contextual padding), resizes the crop to match the model's exact Vision Transformer patch grid, scopes the Accessibility Object Model (ariaSnapshot), and aggregates Desktop, Tablet, and Mobile failures under one testId. Your AI agent diagnoses the responsive layout bug in a single prompt.
Automated Design QA (zerovisual design-qa):
For developers building web apps without a dedicated UI/UX designer, guessing spacing and accessibility in CSS is exhausting. zerovisual design-qa audits any localhost URL against mathematical heuristics (8pt spatial grid rhythm, WCAG 2.1 contrast math, 44×44px touch targets) and compares live DOM against open-source Penpot design exports—zero proprietary Figma lock-in.
Built-in MCP Server & Agent Skills:
ZeroVisual exposes native tools over stdio (list_visual_failures, get_visual_failure_bundle, audit_live_ui_design, optimize_image) and includes strictly-typed Agent Skills (zerovisual-regression, zerovisual-design-qa, zerovisual-optimize) compatible with Cursor, Claude Code, Antigravity, and custom CI agents.

[Stage 1: Deterministic Engine (0 Tokens)]
Playwright Pixel Diff / CSS Heuristic Math / Penpot Token Diff
       │
       ├──► PASS ──► Workflow Ends Immediately (0 AI Tokens Used)
       │
       └──► FAIL / AUDIT ──► Triggers ZeroVisual Pre-Processor
                                    │
[Stage 2: ZeroVisual Optimizer]     ▼
  1. Detects diff bounding box + 32px context padding
  2. Resizes & encodes to WebP based on Model Tile Grid (512px / 504px / 768px / 448px)
  3. Scopes Accessibility Tree (ariaSnapshot) & 14 Computed CSS layout styles
  4. Aggregates Desktop + Tablet + Mobile viewports by testId
                                    │
                                    ▼
              Outputs ./test-results/triage-ready.json
                                    │
            ┌───────────────────────┴───────────────────────┐
            ▼                                               ▼
   [Local IDE via MCP]                             [CI/CD Pipeline CLI]
Cursor / Claude Code / Antigravity               GitHub Actions / GitLab CI
queries ZeroVisual MCP Server + Skill          reads JSON & posts PR Verdict

Demo

🌐 Live Documentation & Interactive Benchmark Explorer: zerovisual.hotcode.dev/guides/benchmarks/
🧮 Interactive Token Calculator: Calculate exact ViT token and byte savings directly on the homepage for OpenAI, Anthropic, Gemini, Gemma, and Local models.
🔬 Real-World Benchmark Explorer: Inspect side-by-side screenshots (Baseline, Actual, Diff, Crop) across live production websites (Wikipedia, Hacker News, GitHub, MDN) and examine actual local VLM reasoning traces (<think>).

Quick Start in Playwright

Add ZeroVisual as a custom reporter in playwright.config.ts:

// playwright.config.ts
import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  testDir: './tests',
  projects: [
    { name: 'Desktop Chrome', use: { ...devices['Desktop Chrome'] } },
    { name: 'Mobile Safari', use: { ...devices['iPhone 14'] } },
  ],
  reporter: [
    ['list'],
    ['zerovisual/reporter', {
      targetProvider: 'gemma', // 'gemma' | 'gemini' | 'openai' | 'anthropic' | 'qwen' | 'local'
      padding: 32,             // Context padding around diff bounding box
      outputDir: './test-results'
    }]
  ],
});

Run Standalone Design QA on Localhost

# Audit live local UI against 8pt grid, WCAG contrast, and tap targets
npx zerovisual design-qa --url http://localhost:3000 --provider gemma

# Or compare directly with an open-source Penpot design artboard
npx zerovisual design-qa --url http://localhost:3000 --penpot ./designs/artboard.svg

Connect to Coding Agents via MCP

# Register with Claude Code
claude mcp add zerovisual -- npx -y zerovisual-mcp

# Or install Agent Skills for Antigravity / Cursor
npx skills add hotcode-dev/zerovisual

Code

hotcode-dev / zerovisual

Zero-waste, zero-API-key visual regression and automated UI design QA pre-processor for AI Agents.

ZeroVisual

Zero-waste, zero-API-key visual regression and automated UI design QA pre-processor for AI Agents.

ZeroVisual is a local pre-processing engine, Playwright Custom Reporter, CLI, and Model Context Protocol (MCP) server. It acts as a token-optimizing firewall between your browser tests/UI and your Vision LLMs—reducing vision token consumption by up to 90% without requiring a single LLM API key.

🌐 Full Documentation & Interactive Token Calculator: Visit our Astro Documentation Site. Local dev: npm run docs:dev.

🎯 What Is This For?

ZeroVisual solves two major pain points in modern software engineering:

1. For QA & Full-Stack Engineers: Automated Visual Regression (`regression` mode)

Standard Playwright toHaveScreenshot() pixel-diffing is fast and free, but fails on harmless sub-pixel font anti-aliasing or minor OS rendering shifts. Conversely, sending raw 1920x1080 screenshots across Desktop, Tablet, and Mobile viewports to a Vision LLM to triage failures will burn through your token budget and slow…

View on GitHub

The repository is 100% open source under the Apache-2.0 License:

Source Code: github.com/hotcode-dev/zerovisual
Tech Stack: TypeScript, @modelcontextprotocol/sdk, @playwright/test, sharp, citty, zod, fast-xml-parser, Astro + Starlight.

How I Built It

ZeroVisual is designed from the ground up around open-source AI and local inference:

Local Vision-Language Models (Open-Weight ViTs): We benchmarked and validated ZeroVisual against Google's google/gemma-4-26B-A4B-it multimodal MoE architecture running completely locally on our workstation via vLLM. Because open-weight vision models (such as Gemma 4, Qwen 2.5/3.8, and PaliGemma) publish their exact Vision Transformer patch dimensions (e.g. 28×28px or 14×14px patch grids), ZeroVisual mathematically fits cropped diffs into the exact minimum patch allocation:
- Google Gemma / Gemini (gemma / gemini): 768×768px native tile (or 384×384px in lowTokenMode)
- Anthropic / Qwen grid (anthropic / qwen): 504×504px (exact 18×18 grid of 28×28px patches)
- OpenAI (openai): 512×512px (single tile)
- Local VLMs (local): 448×448px default (or custom ViT patch dimensions)

Model Vision Grid Reference

Provider Setting	Target Max Bounding Box	Vision Grid Mechanics	Approx. Token Cost per Diff
`openai`	`512 × 512 px`	Fits inside 1 standard OpenAI `512px` tile	~85 – 255 tokens
`anthropic`	`504 × 504 px`	Exact `18 × 18` grid of `28×28 px` patches	~28 – 324 tokens
`gemma` / `gemini`	`768 × 768 px`	Fits 1 native Gemma / Gemini multimodal tile	~258 tokens
`gemma` (`lowTokenMode`)	`384 × 384 px`	Sub-384px single base tile optimization	~258 tokens (ultra-fast)
`qwen`	`504 × 504 px`	Dynamic 2D spatial patch grid (`28×28 px`)	~28 – 324 tokens
`local`	`448 × 448 px` (configurable)	Optimized for local VLMs (`28px` / `14px` patch ViTs)	Local compute

Model Context Protocol (MCP) Standard:
Built on @modelcontextprotocol/sdk, exposing standard tools and prompts over stdio. Any MCP-compatible agent harness (Claude Code, Cursor, Windsurf, Antigravity) can query test results, inspect failure bundles, and trigger UI audits without custom glue code.
Deterministic Local Math Pre-Engine:
- Bounding Box Math: Fast pixel difference scan using sharp buffer analysis with multi-color palette support (Playwright magenta #ff00ff, rose, and red).
- Accessibility Scoping: Extracts Playwright's ariaSnapshot YAML only for the failing element subtree, pairing visual evidence with clean semantic hierarchy.
- CSS Layout Heuristics: Computes WCAG 2.1 contrast ratios and 8pt spatial grid alignment on the live DOM before any AI inference takes place.
Isolated Agent Skills:
Ships strictly-typed Agent Skills (zerovisual-regression, zerovisual-design-qa, zerovisual-optimize) that instruct coding models with precise JSON schemas and design rules, preventing instruction dilution.

Why Does Open Innovation Matter?

Open innovation is what makes ZeroVisual fundamentally possible. A closed API approach wouldn't work for three critical reasons:

Privacy & Zero Data Leaks:
UI test suites run against staging dashboards, internal admin portals, checkout flows, and unreleased features. Uploading full-resolution screenshots of private company data to commercial cloud APIs violates enterprise security and compliance policies. With open-weight models (Gemma, Qwen) running locally through ZeroVisual, zero pixels ever leave your local machine or internal CI runner.
ViT Patch Mechanics Transparency:
Proprietary vision APIs treat image processing as an opaque black box. In contrast, open-source model architectures expose their exact Vision Transformer tokenization logic (patch sizes, position embeddings, and aspect ratio bucketing). This open transparency allowed us to engineer mathematically optimal cropping algorithms that align pixel boundaries directly with the model's ViT patches.
Uncapped, Meter-Free Automation:
Commercial vision APIs charge between $0.01 and $0.03 per image. In an active development team running hundreds of Playwright visual tests across multiple responsive viewports, running visual AI triage on every PR would incur crippling costs. Open innovation and local inference liberate developers from API meter anxiety—allowing you to run thorough UI testing on every single commit for $0.

My Agent Session

Judges and readers can inspect the full interactive agent session trace showing the benchmark execution and triage optimization on local open-weight vision models:

ZeroVisual Vision LLM Empirical Benchmark: 87.7% ViT Token Reduction on Local Qwen-27B RadixArk/Qwen3.8-27B-NVFP4

You

Run empirical benchmark comparing Vision LLM visual regression triage with and without ZeroVisual on local Qwen 27B model (RadixArk/Qwen3.8-27B-NVFP4 via SGLang). Measure token consumption, latency, and accuracy across 6 realistic web-UI test cases.

Agent

Executed empirical evaluation across 6 real-world web UI visual regression scenarios:

Wikipedia Portal Search Offset (Layout Shift)
GitHub PR Merge Box Regression (Button Sizing/Shift)
SaaS Pricing Card Contrast Violation (WCAG 2.1 AA)
E-Commerce Checkout Collision (Flexbox Overlap)
Dashboard Stat Overflow & Clipping (Typography/Height)
Mobile Safari Nav Drawer Overflow (Breakpoint/Z-Index)

Empirical Results Summary:
- Total Tokens Consumed: 11,556 tokens (Raw) vs 5,421 tokens (ZeroVisual) -> 53.1% reduction
- Vision Image Tokens (ViT): 5,252 tokens (Raw) vs 644 tokens (ZeroVisual) -> 87.7% reduction
- Network Bandwidth: 146.6 KB vs 21.7 KB -> 85.2% reduction
- Average Latency: 53.3s vs 36.4s -> 32% faster (up to 3.5x faster on complex viewports)
- Average Triage Accuracy: 76.7% vs 82.5% -> +5.8% accuracy (zero canvas noise hallucinations)

Core Engine Improvements Implemented:
- Added 'qwen' provider support with native 28x28 patch grid dimension math (504x504 max tile).
- Upgraded defaultDiffPixelMatcher to support Playwright magenta (#ff00ff), rose, and high-saturation pixelmatch reds across arbitrary dark/light themes.
- Added automated benchmark CLI runner and testdata generators.

Direct session link: View on DEV Agent Sessions

The Lazy Payoff

How much effort does ZeroVisual actually save?

We ran an empirical benchmark across 11 visual regression scenarios—including 5 live production websites (Wikipedia Desktop & Mobile, Hacker News, GitHub Pricing, MDN Web Docs) and 6 synthetic component regressions—comparing raw viewport screenshots against ZeroVisual optimization on local Gemma 4 26B (google/gemma-4-26B-A4B-it served via vLLM):

Core Metric	Without ZeroVisual (Raw Viewport)	With ZeroVisual (Optimized)	The Lazy Payoff
Vision Image Tokens (ViT)	9,030 tokens	2,838 tokens	-68.6% ViT Token Reduction
Network Payload Transfer	638.9 KB	116.2 KB	-81.8% Bandwidth Reduced
Total Tokens Consumed	7,612 tokens	7,148 tokens	-6.1% Total Tokens Saved
Average Roundtrip Latency	8.4 seconds	7.3 seconds	13% Faster (up to 37% on desktop)
Average Triage Accuracy	59.1%	65.5%	+6.4% Accuracy Boost (Zero Canvas Noise)

Real-World Highlights: Live Production Sites

Wikipedia Desktop (1280×800): Payload shrank from 122.3 KB down to 11.1 KB (-91.0%), and roundtrip triage latency dropped from 11.3s down to 7.2s (37% faster).
Wikipedia Mobile (390×664): The raw viewport scored 0% accuracy due to full canvas noise. Cropping to the 370×133 failure bounding box (1.5 KB WebP, -96.9% payload) boosted diagnostic accuracy to 35%.
MDN Web Docs Mobile (390×664): Diagnosing a subtle search input contrast defect jumped from 30% accuracy up to 65% accuracy (+35% boost) while cutting network payload from 55.1 KB down to 4.7 KB (-91.5%).

The Real Payoff: Instead of spending 20 minutes manually reproducing a broken responsive layout and inspecting DevTools styles, ZeroVisual intercepts the failure, hands a token-optimized bundle to the local AI agent, and outputs the exact CSS diff to paste into your pull request.

Prize Categories

Overall Winner: Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady (Rewarding Laziness with Local Open-Source AI)
Best Use of Gemma: Evaluated and benchmarked ZeroVisual against Google's google/gemma-4-26B-A4B-it multimodal MoE model running locally via vLLM.

ZeroCoach: The World's First 100% On-Device AI Athletic Coach

Jirawat Boonkumnerd — Sun, 18 Oct 2026 14:54:55 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Millions of fitness enthusiasts, runners, and lifters pay $200 every year for personal training subscriptions and commercial coaching apps (Whoop, Future, MyFitnessPal, Fitbod). Yet these commercial services come with three major flaws:

Perpetual Subscription Rent: Cancel your subscription, and you lose access to your personalized workout history and coaching insights.
Biometric Privacy Leaks: Your most intimate biological markers—heart rate variability (HRV), resting heart rate, sleep architecture, weigh-in history, and photos of every meal you eat—are constantly uploaded and stored on corporate cloud servers.
Cloud Latency & Network Dependency: The second you walk into an underground gym basement, run on a mountain trail, or lose cell reception, your AI coach goes dark with infinite loading spinners.

ZeroCoach is the world's first open-source, 100% on-device AI athletic coaching platform. Built with React Native, Expo, and llama.rn, ZeroCoach runs quantized Google Gemma 2 2B entirely on local device hardware.

It gives every athlete a world-class training companion with 0 cloud latency, 0 remote API inference fees, and 100% private biometric telemetry:

💬 Local Conversational Athletic Intelligence: Real-time coaching streaming at ~38 tokens/second locally on phone silicon, with dual coaching personas (Strict vs. Comfort).
🥗 Multimodal Nutrition & Food Decomposition: Instant photo plate decomposition with calorie and macro calculations, plus an expandable 9-micronutrient RDA bio-assay (Vitamins A, C, D, B12, Iron, Calcium, Magnesium, Potassium, Sodium). Also includes USDA Whole Foods database search and live barcode scanning.
🏋️ Adaptive Workout Engine: 643 science-backed exercises from RepDB with kinetic start/peak animations, personalized volume progression, dynamic movement swapping, and haptic rest countdowns.
📈 Unified 7-Day Athletic Telemetry: Direct local sync with Android Health Connect and Apple HealthKit, computing a holistic 0–100 daily composite performance score balancing CNS recovery (35%), workout volume (35%), and nutrition target accuracy (30%).

Demo

Watch the full 1080p high-production walkthrough demonstrating real on-device Gemma 2 generation, photo food decomposition, and live telemetry on a physical Android device:

🌐 Live Website: zerocoach.tech
📦 Download Standalone Android APK: ZeroCoach v1.1.0 APK (GitHub Release Page)
📺 Direct Video URL: https://youtu.be/Ns-7ikl16K0

Code

ZeroCoach is completely open source under the Apache License 2.0:

ntsd / zerocoach

An open-source, privacy-first AI health coach. Features offline mobile LLM inference, visual nutrition tracking, wearable sync, and adaptive lifestyle.

ZeroCoach

ZeroCoach is an open-source, privacy-first mobile fitness and athletic AI coaching application powered entirely by on-device and local AI models. Built with React Native and Expo, it delivers science-backed workout programming, adaptive nutrition targets, and real-time coaching—with zero cloud latency and absolute data privacy.

Visit the official website at zerocoach.tech.

🎬 Demo Video

▶️ Watch the Full HD Demo on YouTube: https://youtu.be/Ns-7ikl16K0

Featuring on-device Gemma 2 GGUF inference streaming at ~38 tok/s, multimodal food plate vision decomposition & micronutrient analysis, RepDB adaptive workout engine, and unified 7-day athletic telemetry.

📸 App Preview

💬 Coach Chat	🥗 Nutrition Tracker	🏋️ Adaptive Workout

Gemma 2 On-Device Coach Real-time athletic guidance & dual persona	Smart Nutrition & Macros Gemini Vision, NutriSight & 11 RDAs	Adaptive Workout Hub RepDB 643 exercises & Date Navigation

📈 Performance & Trends	⚙️ On-Device Engine

Multi-Domain Analytics 0–100 composite score & Health Connect	Hardware Acceleration

…

View on GitHub

The repository includes:

The full React Native / Expo mobile application source (/src).
The Astro + Tailwind CSS marketing site (/web) deployed on Render at zerocoach.tech.
The autonomous machine learning pipeline (/ml) for LoRA fine-tuning, dataset generation, and vector embeddings.
Automated hardware test scripts using ADB and Argent (/scripts/demo).

How I Built It

ZeroCoach is engineered around four sovereign on-device pillars:

1. On-Device Gemma 2 Inference via `llama.rn`

Rather than relying on expensive, proprietary cloud APIs (like OpenAI or Anthropic) that charge per token and leak user conversations, ZeroCoach embeds Google Gemma 2 2B Instruct quantized to Q4_K_M (~1.64 GB) running via llama.rn (React Native C++ bindings for llama.cpp).

On modern mobile hardware (tested on Snapdragon silicon), Gemma 2 streams responses at ~38 tokens/second with 0ms cloud roundtrip latency.
Dual persona coaching prompts are dynamically composed with live wearable biometrics and today's remaining macro budget before generation.

2. Autonomous Fine-Tuning & Vector Retrieval Pipeline (`/ml`)

ZeroCoach includes an offline ML pipeline:

Synthetic Coaching Dataset: 1,075 verified biomechanical coaching pairs (/ml/scripts/generate_dataset.py) formatted in native Gemma 2 chat tokens.
Dense Vector Search: Pre-computed 384-dimensional dense vectors (sentence-transformers/all-MiniLM-L6-v2) across all 643 RepDB movements and USDA items, enabling instantaneous sub-millisecond semantic search and movement swapping offline.
LoRA Training: Parameter-efficient LoRA adapters trained with Apple Silicon MPS (Metal Performance Shaders) acceleration.

3. Multimodal Food Vision & Micronutrient Decomposition

In the Nutrition module, athletes can snap or upload any meal photo. ZeroCoach analyzes the dish, estimates ingredient weights (e.g. 187g Basque burnt cheesecake), decomposes calories and macronutrients (protein, carbs, fat, fiber), and generates a 9-essential micronutrient assay sheet before logging the portion directly to Lunch, Dinner, or Breakfast. For packaged goods, live barcode scanning and NutriSight label parsing provide instant verification.

4. Unified Health Hub & Telemetry Engine

Using local native bridges to Android Health Connect and Apple HealthKit, ZeroCoach reads resting heart rate, heart rate variability (HRV), and deep sleep architecture with zero third-party cloud aggregators. It translates these into an autoregulated daily readiness score (0–100) that automatically adjusts working set volume and deload suggestions.

Why Does Open Innovation Matter?

Open innovation is not just an ideological choice for ZeroCoach—it is the core technical architecture that makes the product commercially viable:

$0 Marginal Inference Cost: Closed API services charge ongoing fees for every token sent and received. For an active athlete engaging with their coach multiple times a day, API costs quickly compound. Running open-weight Gemma 2 on device silicon reduces marginal inference cost to literally $0 forever, making a sustainable zero-subscription coaching tool possible.
Absolute Health Data Sovereignty: Biometric telemetry is among the most sensitive personal data that exists. Asking users to upload their cardiac trends, sleep cycles, and daily food photos to closed corporate cloud silos is a major privacy barrier. Open-weight models running on-device guarantee that not a single byte of biometric data ever leaves the user's phone.
Resilience in Real-World Athletic Environments: Athletes train in basement gyms, cross-country trails, remote tracks, and while traveling on airplanes. Closed APIs fail completely without internet access. Open-source local models allow athletes to train anywhere on Earth with 100% reliability.
Freedom from Vendor Lock-In: Closed APIs can deprecate endpoints, change rate limits, or alter subscription pricing overnight. Open-weight models give developers and athletes permanent ownership over their tools.

My Agent Session

I developed and validated ZeroCoach collaboratively using an AI agent workflow that managed local model compilation, on-device ADB testing on a connected Android device, and automated video recording:

ZeroCoach: Building the 100% On-Device AI Athletic Coach with Gemma 2 and llama.rn

You

Build ZeroCoach: an open-source, 100% on-device AI athletic and fitness coach for the DEV Hacktoberfest Week 2 'Side Hustle' challenge. It needs to displace expensive $100-$200/month commercial fitness app subscriptions with zero recurring fees, 100% private biometrics, local Gemma 2 GGUF inference running directly on mobile hardware via llama.rn, multimodal food vision decomposition with micronutrient assays, 643 RepDB movements with adaptive splits, and unified 7-day recovery telemetry.

Agent

I'm engineering ZeroCoach around four sovereign on-device pillars:
1. Local LLM Engine: We'll embed llama.rn running quantized Google Gemma 2 2B GGUF with GPU/NPU acceleration. Zero cloud latency and absolute privacy.
2. Multimodal Food Vision & RDA Assay: Dual-mode camera scanner using Gemini Vision plate decomposition and Open Food Facts NutriSight LayoutLMv3 table extraction to track calories, macros, and 11 essential micronutrients (Vitamins A, C, D, B12, Iron, Calcium, Magnesium, Potassium, Sodium, Zinc).
3. Adaptive Workout Splits: RepDB database with 643 science-backed exercises, kinetic start/peak animations, customizable movement swaps, and progressive overload calculations.
4. Unified Athletic Telemetry: Direct bridge to Android Health Connect and Apple HealthKit computing a 0–100 composite performance score from CNS readiness (HRV, RHR, deep sleep), workout volume, and macro compliance. Let's begin the implementation.

▸ run_command

Output

npm i llama.rn zustand react-native-health-connect react-native-health react-native-svg

You

Let's deploy the standalone APK to the connected physical device (Xiaomi 25010PN30G) via ADB, test on-device Gemma 2 streaming token speed, verify the food photo plate decomposition review sheet, and record the high-production demo video.

Agent

Executing automated hardware validation on the connected device. Verifying local Gemma 2 token streaming and multimodal nutrition logging.

▸ run_command

Output

Device connected: Xiaomi 25010PN30G (e177a07b). Gemma 2 2B GGUF loaded into RAM. Benchmark: ~38 tokens/sec local streaming. Food photo decomposed: 187g Basque burnt cheesecake (204 kcal, 18.5g protein, 15.3g carbs, 6.7g fat, 9 micronutrients logged to Lunch). Full HD pitch demo video composite rendered to scripts/demo/zerocoach_pitch_demo.mp4 (110.89s).

The hardware verification and demo video generation completed with 100% fidelity. ZeroCoach is fully operational with zero cloud latency and complete sovereign privacy.

You can explore the full interactive transcript of this agent session at:
https://dev.to/agent_sessions/zerocoach-building-the-100-on-device-ai-athletic-coach-with-gemma-2-and-llamarn-t23on9

My First User

The first user was myself—I've never paid for fitness apps and built ZeroCoach for my own daily training (syncing my wearable, tracking nutrition, and generating workout plans on-device).

Since then, the journey has expanded rapidly: ZeroCoach is now officially deployed to both the Google Play Store and the Apple App Store!

I’ve shared the milestone across social channels and communities to recruit our first cohort of closed testers:

We've already seen exciting interest from people both online (developers and fitness tech enthusiasts asking to join the closed test) and offline (friends, gym buddies, and colleagues wanting an athletic tracker that respects their privacy without recurring subscription fees). Gathering real-world feedback from these initial testers is helping refine on-device inference speed, UI edge cases, and personalized workout volume.

Prize Categories

🌟 Featured Category: Best Use of Gemma

ZeroCoach is built from the ground up around Google Gemma 2. We use gemma-2-2b-it-Q4_K_M.gguf running locally on mobile hardware via llama.rn. The model acts as the sovereign on-device coaching brain, analyzing real-time recovery telemetry, formulating nutrition suggestions, and adjusting workout splits at ~38 tokens/second with zero cloud latency.

🌐 Partner Category: Best Use of a .tech Domain

The official marketing website, interactive app showcase, feature documentation, and pre-computed ML model artifacts are live and hosted on our custom domain:
https://zerocoach.tech

Built with passion for Hacktoberfest 2026. Zero Subscriptions. Absolute Privacy. 100% On-Device AI.

Chadodoro: The Stoic GigaChad Pomodoro Coach That Forces You to Touch Physical Grass

Jirawat Boonkumnerd — Sun, 11 Oct 2026 21:41:30 +0000

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

What I Built

Modern developers face an epidemic of infinite screen-lock: sitting motionless in dark rooms, doom-scrolling Reddit and Twitter during "breaks," and accumulating chronic desk fatigue. We tell ourselves we are resting, but our eyes remain glued to 120Hz glass panels.

Chadodoro (pomodoro-chad) was built to break this cycle. It is an unapologetic, athletic productivity coach inspired by the stoic GigaChad ethos, engineered around a single physical mandate: when your work interval ends, you step away from the monitors and touch physical grass.

Key Features

Circular Countdown Progress Ring: Athletic SVG countdown ring displaying MM:SS with animated stroke dashoffset, instant phase indicators, and reactive glow.
Three Reactive Reactive Avatars:
- Focus Mode (Lock In): Cyberpunk deep-work GigaChad with neon emerald laser eyes, HUD reticle targeting lines, and unbroken focus aura.
- Short Break (Hydrate & Rest): Warm acoustic lounge GigaChad taking a mindful breath, holding a steaming ceramic Chad crown mug in golden ambient light.
- Long Break (Touch Grass): Outdoor sunny meadow GigaChad wearing aviator sunglasses, gently caressing lush green grass stalks under natural sunlight.
Voice Coach Pre-Synthesized by ElevenLabs: 16 high-impact coaching lines across START_FOCUS, SHORT_BREAK, LONG_BREAK, and CHAD_MOTIVATION, delivered in a commanding baritone voice and replayable on-demand via the soundboard.
"I Touched Grass" Physical Tracker: Tactile soundboard button that increments your real-world grass counter, triggers floating clover and grass confetti, and plays audio feedback.
Hybrid Anthem BGM Engine (YouTube + Git Vault): Curated library of 27 viral phonk and motivation tracks (including REVENGE, MONTAGEM PEGADORA, GigaChad Theme Phonk House, MOTIVATION FUNK, METAMORPHOSIS, DIA DELÍCIA, AURA) with precise start timestamps. Choose between 30s phase-change bursts or continuous play, and switch between Vault Audio Only, YouTube Only, or Hybrid mode.
Live Song Attribution & Direct Links: Real-time track display with direct links to original artists on YouTube.
The Chadodoro Code: Three non-negotiable principles displayed on the dashboard:
- 01 Unbroken Focus: Single-task deep work with zero tab switching.
- 02 Radical Screen Break: Hands off the keyboard and eyes away from screens.
- 03 Touch Physical Grass: Reconnecting with sunlight, earth, and fresh air.

Demo

🌐 Live Interactive Web App: https://chadodoro.ntsd.dev/
⚡ Zero Setup / Zero Latency: Instant load directly in any modern browser, fully functional on mobile and desktop.

┌────────────────────────────────────────────────────────┐
│  👑 CHADODORO — LOCK IN & TOUCH GRASS                  │
│                                                        │
│  [ AVATAR: GigaChad Laser Eyes / Meadow Aviators ]     │
│                                                        │
│                     ( 25:00 )                          │
│            [ START ]  [ RESET ]  [ SKIP ]              │
│                                                        │
│  CHADODORO COACH: "Lock in, King. Disconnect the noise"│
│  NOW PLAYING: 🎵 GigaChad Theme (Phonk House Version)  │
│                                                        │
│  🌱 Real Grass Touched: [ 42 ] [ + TOUCH GRASS ]       │
└────────────────────────────────────────────────────────┘

Code

The entire codebase is open-source under the permissive MIT License:

🐙 GitHub Repository: https://github.com/ntsd/pomodoro-chad
🚀 1-Click Deploy Blueprint: Includes native render.yaml for instant deployment on Render.

How I Built It

Architecture: Zero-Latency Static Git Voice Vault

Traditional AI web applications make expensive, high-latency API calls to LLMs and speech synthesis services on every user interaction. This introduces loading spinners, billing unpredictable costs, and network vulnerabilities.

Chadodoro completely decouples AI synthesis from user runtime:

                  ┌────────────────────────────────────────────────────────┐
                  │                 BUILD / PIPELINE TIME                  │
                  └────────────────────────────────────────────────────────┘
                                              │
                      ┌───────────────────────┴───────────────────────┐
                      ▼                                               ▼
         [Open-Source AI Brain]                              [Voice Synthesis]
      google/gemma-4-26B-A4B-it                             ElevenLabs API
    (spark.ntsd.dev:8001/v1)                               (Adam - Deep Baritone)
                      │                                               │
                      └───────────────────────┬───────────────────────┘
                                              │
                                              ▼
                                 [scripts/generate_vault.py]
                                              │
                                              ▼
                            ┌──────────────────────────────────────────────┐
                            │           PUBLIC GIT VOICE VAULT             │
                            │  public/vault/manifest.json                  │
                            │  public/vault/scripts/<id>/<id>.{json,mp3}   │
                            │  public/vault/themes/<id>/<id>.{json,mp3}    │
                            └──────────────────────────────────────────────┘
                                              │
                     ═════════════════════════╪═══════════════════════════
                                              │ (Committed to Git)
                  ┌───────────────────────────┴────────────────────────────┐
                  │                     RUNTIME (RENDER)                   │
                  │   - 100% Static HTML / CSS / JS (Astro)                │
                  │   - 0ms API Latency                                    │
                  │   - Zero Runtime Secrets / Zero API Costs              │
                  │   - Edge Cached Audio Assets (/vault/*)                │
                  │   - Native Web Speech API Fallback                     │
                  └────────────────────────────────────────────────────────┘

Open-Source AI Core: Coaching lines are generated at pipeline time by google/gemma-4-26B-A4B-it hosted on an open-weight inference node (https://spark.ntsd.dev:8001/v1).
ElevenLabs Audio Synthesis: The generated transcripts are synthesized into punchy, resonant baritone speech using ElevenLabs API (voices Adam, Harry, Brian).
Committed into Git: Both the transcript metadata (.json) and compressed audio (.mp3) are committed directly to public/vault/ alongside manifest.json.
Static Astro Delivery: Built with Astro and pure vanilla CSS/JS. Assets are pre-rendered into dist/ and served with zero server-side compute.
Edge Caching on Render: Deployed as a static site on Render with custom immutable cache headers (Cache-Control: public, max-age=31536000, immutable) for instant audio streaming.

Why Does Open Innovation Matter?

Zero Runtime API Dependency & Cost Freedom: By combining an open-weight model (google/gemma-4-26B-A4B-it) with a Git-based artifact vault, the application runs forever with 0 API bills and 0 runtime keys exposed. Anyone can fork the repository and host it without an API key or credit card.
Local Privacy & Self-Sovereignty: All timer data, grass counter metrics, and audio preferences live in browser localStorage. No user tracking, no backend database, and no telemetry.
Reproducibility & Customization: Developers can run scripts/generate_vault.py with their own local or self-hosted LLM endpoints (Ollama, vLLM, sparkrun) to generate new personas, voice scripts, and motivational quotes.

My Agent Session

All coach transcripts and stoic motivational lines were generated by running Gemma (google/gemma-4-26B-A4B-it) through an automated pipeline workflow:

Stoic Persona Prompting: Gemma was prompted with strict character constraints: uncompromising discipline, high-impact brevity, tough-love accountability, and mandatory real-world outdoors/grass reminders.
Structured Content Generation: Gemma parsed phase contexts (START_FOCUS, SHORT_BREAK, LONG_BREAK, CHAD_MOTIVATION) to produce structured transcript metadata and text.
Automated Pipeline Integration: The Gemma outputs were automatically fed into scripts/generate_vault.py to synthesize audio clips, validate duration thresholds, and compile manifest.json.

Prize Categories

🎙️ Best Use of ElevenLabs

Chadodoro utilizes ElevenLabs' speech synthesis to give the GigaChad coach an authoritative, ultra-realistic baritone voice. 16 distinct audio assets across 4 timer phases were synthesized using ElevenLabs voices (Adam, Harry, Brian) and baked into the Git Voice Vault. The app triggers these clips on phase transitions and features an instant replay soundboard.

🚀 Best Use of Render

The application is deployed on Render via a declarative render.yaml blueprint. Render builds the Astro static bundle and serves both the single-page application and static audio assets with custom HTTP Cache-Control headers (public, max-age=31536000, immutable), ensuring sub-millisecond edge response times worldwide.

🧠 Best Use of Gemma

Motivational scripts and Stoic Touch Grass reminders were generated using the open-weight google/gemma-4-26B-A4B-it model running on an OpenAI-compatible self-hosted inference cluster, demonstrating how open-weight LLMs can drive automated creative production pipelines.

“Discipline equals freedom, King. Step outside and touch physical grass.” 👑🌱

Zero Market Radar: A Stock-News Dashboard and Voice Alerts for a Friend

Jirawat Boonkumnerd — Sun, 04 Oct 2026 19:33:30 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.

What I Built

My friend Alex follows a small stock watchlist, but financial news makes even a small watchlist feel like a full-time job. Earnings announcements sit beside speculative listicles. Yesterday's recap looks as urgent as today's material business update. More articles do not necessarily mean more useful information.

I built Zero Market Radar to answer a narrower question: what happened to the companies Alex follows, and which headlines deserve his attention?

It combines a browsable news dashboard with optional Telegram notifications and short spoken alerts. TypeSafe AI's Jev evaluates an article's directional sentiment and materiality; ordinary TypeScript decides how to store, rank, display, and deliver that result. It is a news-triage tool, not an automated trading system or a promise of investment returns.

🌐 Live demo: zeromarketradar.com

💻 MIT-licensed source: ntsd/zero-market-radar

The current default watchlist is AAPL, MSFT, NVDA, GOOGL, AMZN, META, TSLA, AMD, TSM, and BABA. I reduced the original broader list to keep the product focused and removed the China/HK preset; BABA remains an individually selectable ticker.

Demo

A dashboard for browsing, not another notification feed

Open the public dashboard and:

Select individual tickers or the Mega Tech and Semis presets. Choices persist in the browser.
Browse the top four impact-ranked headlines for your selected companies.
Switch between 24H, 3D, 7D, or a custom date range within the recent seven-day window.
Filter the feed by breaking signals, notable catalysts, bullish sentiment, or bearish sentiment; sort by impact, date, or confidence.
Click a ticker badge to open its dedicated quote, price chart, and paginated news view.

The symbol chart offers 24-hour and seven-day views using real Yahoo price candles. Breaking and catalyst articles appear as chart dots; selecting a dot jumps to the corresponding article. The dots show news timing alongside prices—not proof that an article caused a price movement.

Voice where it is useful

For Alex's commute, breaking-critical articles can become ElevenLabs voice dispatches, delivered through Telegram or played from the dashboard. Notable catalysts use text notifications rather than voice. Routine commentary stays available to browse without automatically becoming a spoken alert.

Telegram is optional. Finnhub and TypeSafe API keys are the two required keys for dashboard-only operation; MongoDB, ElevenLabs, Telegram, and Sentry add persistence, speech, notifications, and tracing. The repository includes an API key setup guide.

How I Built It

1. Two typed AI judgments, one request

I did not need a model to write an investment essay. I needed two structured judgments:

Sentiment: bullish or bearish, with confidence and choice probabilities.
Priority: breaking-critical, notable catalyst, or routine noise.

The Jev service sends the ticker, headline, summary, source, and publication time through a single systemOne request containing both choice questions. It validates the returned answer types before persisting a prediction.

Impact ranking uses this explicit weighting of the priority probabilities:

$$
\text{urgencyScore} = P(\text{breaking critical}) + 0.5\,P(\text{notable catalyst})
$$

This is a ranking heuristic, not a calibrated probability of a future price move. The service retains the source headline and link so Alex can read the underlying report instead of relying on a generated explanation.

Jev is a hosted System 1 decision-model API. Fast inference is useful, but I am not claiming sub-second end-to-end alerts: provider publication delays, round-robin polling, retries, and optional speech generation all contribute to delivery time.

2. Persistence without fake historical predictions

MongoDB Atlas stores article evaluations, per-symbol sync ranges, quotes, price candles, and generated audio. Verified predictions carry evaluatedBy: 'jev'; a redeploy warms the in-memory deduplicator from those verified records for the active watchlist.

The news history setting defaults to seven days:

HISTORY_SYNC_DAYS=1..7 bounds historical fetching and downtime catch-up.
On a symbol's first turn after startup, stored unverified articles inside that window are evaluated through the same Jev path, silently.
HISTORY_SYNC_DAYS=0 skips historical reevaluation and fetches today's live news only.
Failed evaluation or storage does not advance the successful sync checkpoint.

Older archive records are preserved, not silently relabeled as genuine model decisions. Historical processing is notification-silent; articles older than 24 hours also avoid Telegram pushes.

This reduces repeated work, but it is not an exactly-once notification guarantee. Coordinating multiple workers and atomically recording delivery are separate problems.

3. Cache per ticker; filter in the browser

The most useful dashboard optimization was changing what the browser asks for.

Instead of a Mongo query for every date change or pagination click, /api/home-news?symbol=AAPL returns a complete bounded news snapshot for one watched symbol, without cached audio data. The server shares snapshots for 30 seconds, coalesces concurrent loads, and serves previous results during refresh. Failed refreshes preserve successful cached data and retry after five seconds.

The browser shares each ticker's snapshot between the spotlight and feed. Date, signal, sort, and page controls operate locally. Periodic refreshes revalidate the snapshots; a newly selected ticker or new UTC day loads the appropriate data.

An isolated browser check confirmed that switching 24H → 7D → next page generated zero API requests. That verifies the filtering behavior, not production network latency.

Equity summaries are aggregated inside MongoDB rather than transferring the historical article collection to Node.js. Audio is fetched separately for playback, and quote reads are scoped to the relevant symbols.

4. Speech is a delivery feature, not a second analyst

The ElevenLabs integration uses eleven_turbo_v2_5 to read a deterministic script containing the ticker, original headline, directional label, and confidence. It does not invent extra market commentary.

Generated audio is cached in MongoDB. Replay reuses the cached clip, and the audio endpoint enforces breaking-critical eligibility even if an older non-breaking article happens to have cached audio.

5. Deployment details that mattered

Render hosts the Node.js service and dashboard behind the custom domain. The Blueprint defines the build, start command, environment, and /health check.

Operational safeguards include:

A shared Finnhub request limiter: at most 50 request starts per minute, at least 1.2 seconds apart, with a cooldown after HTTP 429. Quote and news calls use the same limiter.
A sequential scheduler that waits two seconds after a symbol's work finishes, rather than overlapping slow backfills.
A 10,000-entry, 48-hour TTL deduplication cache.
Fail-fast startup when a configured Mongo connection cannot initialize, rather than silently serving an empty in-memory dashboard.
Sentry custom spans and exception capture around inference, provider calls, storage, and audio. This implementation does not claim automatic token or cost reporting.
Graceful shutdown when Render sends SIGTERM during instance replacement.

A free Render web service can sleep after 15 minutes without inbound traffic. Outbound polling does not prevent that, so continuous unattended alerts need an always-on deployment. In-memory response caches also reset when the process restarts; Mongo history does not.

What I Learned—and What Still Needs Work

The latest local build passes 95 tests, including retry/checkpoint behavior, historical notification suppression, cached audio eligibility, pagination, UTC date boundaries, and browser-side cache filtering.

Two data-model limitations are worth being explicit about:

A successful sync range does not prove Finnhub returned every article in that range. Broad provider requests can miss items; per-day historical reconciliation is a future improvement.
Predictions currently use a global article ID and one stored symbol. A story appearing under multiple tickers needs better association handling; counts should not be presented as exhaustive company-news coverage.

The lesson was to make a small, honest tool for Alex—not to describe a weekend prototype as an institutional trading terminal. The most valuable improvements were quieter alerts, readable source links, reliable state, and controls that do not keep hitting the database.

Why Open Innovation Matters

The application code is MIT-licensed, with TypeScript, native Node.js HTTP, reproducible configuration, and visible decision rules. Alex can inspect the filters, change the watchlist, self-host the service, or modify the delivery channels instead of depending on an opaque news app.

There is an important boundary: this implementation calls hosted Jev, Finnhub, Yahoo, and ElevenLabs services; it does not run an open-weight AI model locally or work fully offline. Open application code is not the same as open model weights. That distinction matters when evaluating the challenge's open-source-AI requirement, and I do not want to imply a model integration the project does not have.

Community Wisdom

🌐 Idempotency in Data Pipelines: How to Prevent Duplicate Records

Source: 137Foundry
Tags: programming, api, productivity

Stable record identities, upserts, and explicit checkpoints make overlapping retries safer. That supports the storage design here, without turning it into an exactly-once delivery claim.

Read Full Discussion

My Agent Session

The original scaffolding session is embedded below. It records the early build; the implementation has since evolved, including the reduced watchlist and caching changes described above.

Building stock-news-alert with TypeSafe AI Jev, Finnhub, and Render

You

Build a production-ready Node.js backend service called "stock-news-alert" in TypeScript. It polls Finnhub company-news, deduplicates articles, classifies sentiment via TypeSafe AI Jev (System 1 Decision Model) into binary 0/1 with confidence, and sends Telegram alerts. Deploy to Render for the Hacktoberfest Weekend Challenge: Build for a Friend.

Agent

I will critique the setup as a Principal Engineer, address rate-limit distribution across N symbols without drift, implement a dual-eviction LRU cache to prevent memory leaks, solve the cold-start alert storm, and build a turnkey Render Blueprint deployment with native health checks.

Agent

The solution uses a drift-compensated self-scheduling tick at 1200ms (~50 req/min), an LRU cache with 48h TTL, strict HTML escaping for Telegram, TypeSafe Jev Choice primitive inference, and a render.yaml blueprint with /health monitoring. All 5 unit tests pass and live API calls succeeded.

Partner Integrations

Render: deployed Node.js backend, web dashboard, custom domain, Blueprint, and health endpoint.
ElevenLabs: breaking-news narration, optional Telegram voice delivery, and cached browser playback.
MongoDB Atlas: durable evaluations, sync coverage, quotes, candles, and audio storage.
Sentry: custom performance spans and exception capture; a trace screenshot would strengthen evidence for the Agent Tracing category.

AI assistance disclosure: AI tools helped develop the project and revise this write-up. The implementation and limitations above are grounded in the current source and local checks.

Auto Request Changes review when the job failed using Github Action

Jirawat Boonkumnerd — Sun, 21 Nov 2021 17:19:00 +0000

My Workflow

The Github Action is forked from hmarr/auto-approve-action. The action will automatically create a Request Changes pull request review. A use case is to create a request changes review when a workflow job failed.

The action support 3 input parameters. You can use with jobs..steps[*].with to add the input parameters.

github-token: The Github token. By default, it will using ${{ github.token }} to use the repo token.
comment-body: The comment body to create a request changes review. The comment-body also support markdown text by Github. The default is Some actions are not successful, please fix it.
pull-request-number: (optional) The ID of a pull request to auto-request-changes. By default, this action tries to use the pull_request event payload.

Example use

you can use with if to avoid no pull request event and run only when the job failed.

*for more Github Action Context.

name: Auto request changes
on: pull_request_target

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: ntsd/auto-request-changes-action@v2
        if: ${{ github.event.pull_request && failure() }}
        with:
          comment-body: "The job ran failed please fix it."

You can also use it with auto-approve-action to make it auto approve when the job success.

name: Auto request changes
on: pull_request_target

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: ntsd/auto-request-changes-action@v2
        if: ${{ github.event.pull_request && failure() }}
        with:
          comment-body: "The job ran failed please fix it."
      - uses: hmarr/auto-approve-action@v2
        if: ${{ github.event.pull_request && success() }}
        with:
          github-token: "${{ secrets.GITHUB_TOKEN }}"

Submission Category:

Maintainer Must-Haves

Yaml File or Link to Code

ntsd / auto-request-changes-action

👍 GitHub Action for automatically request changes GitHub pull requests

Auto Request Changes GitHub Action

This action is a fork from hmarr/auto-approve-action

Name: ntsd/auto-request-changes-action

Automatically request changes GitHub pull requests. The GITHUB_TOKEN secret will default provided as the github-token input for the action to work. otherwise you can add a token to github-token input.

Why?

Because sometimes you want to automate create request changes review. for example, create a request changes review when a lint or testing workflow is failed.

Usage instructions

Create a workflow file (e.g. .github/workflows/auto-request-changes.yml) that contains a step that uses: ntsd/auto-request-changes-action@v3. Here's an example workflow file:

for all github action contexts check https://docs.github.com/en/actions/learn-github-actions/contexts

name: Auto request changes
on: pull_request_target

jobs:
  build:
    runs-on: ubuntu-latest
    permissions:
      pull-requests: write
    steps:
      - uses: ntsd/auto-request-changes-action@v3
        with:
          github-token: "${{ secrets.GITHUB_TOKEN }}"
          review-message: "custom review message body"

Combine with an if can only auto-request-changes with…

View on GitHub

Additional Resources / Info

Auto Request Changes Action Repo

Auto Request Changes Action Marketplace

Auto Approve Action Repo

Github Action Context

DEV Community: Jirawat Boonkumnerd

ZeroVisual: I Was Too Lazy to Do Manual UI Testing, So I Made Open-Source AI Do It

What I Built

Demo

Quick Start in Playwright

Run Standalone Design QA on Localhost

Connect to Coding Agents via MCP

Code

hotcode-dev / zerovisual

Zero-waste, zero-API-key visual regression and automated UI design QA pre-processor for AI Agents.

ZeroVisual

🎯 What Is This For?

1. For QA & Full-Stack Engineers: Automated Visual Regression (regression mode)

How I Built It

Model Vision Grid Reference

Why Does Open Innovation Matter?

My Agent Session

The Lazy Payoff

Real-World Highlights: Live Production Sites

Prize Categories

ZeroCoach: The World's First 100% On-Device AI Athletic Coach

What I Built

Demo

Code

ntsd / zerocoach

An open-source, privacy-first AI health coach. Features offline mobile LLM inference, visual nutrition tracking, wearable sync, and adaptive lifestyle.

ZeroCoach

🎬 Demo Video

📸 App Preview

How I Built It

1. On-Device Gemma 2 Inference via llama.rn

2. Autonomous Fine-Tuning & Vector Retrieval Pipeline (/ml)

3. Multimodal Food Vision & Micronutrient Decomposition

4. Unified Health Hub & Telemetry Engine

Why Does Open Innovation Matter?

My Agent Session

My First User

Prize Categories

🌟 Featured Category: Best Use of Gemma

🌐 Partner Category: Best Use of a .tech Domain

Chadodoro: The Stoic GigaChad Pomodoro Coach That Forces You to Touch Physical Grass

What I Built

Key Features

Demo

Code

How I Built It

Architecture: Zero-Latency Static Git Voice Vault

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

🎙️ Best Use of ElevenLabs

🚀 Best Use of Render

🧠 Best Use of Gemma

Zero Market Radar: A Stock-News Dashboard and Voice Alerts for a Friend

What I Built

Demo

A dashboard for browsing, not another notification feed

Voice where it is useful

How I Built It

1. Two typed AI judgments, one request

2. Persistence without fake historical predictions

3. Cache per ticker; filter in the browser

4. Speech is a delivery feature, not a second analyst

5. Deployment details that mattered

What I Learned—and What Still Needs Work

Why Open Innovation Matters

Community Wisdom

🌐 Idempotency in Data Pipelines: How to Prevent Duplicate Records

My Agent Session

Partner Integrations

Auto Request Changes review when the job failed using Github Action

My Workflow

Example use

Submission Category:

Yaml File or Link to Code

ntsd / auto-request-changes-action

👍 GitHub Action for automatically request changes GitHub pull requests

Auto Request Changes GitHub Action

Why?

Usage instructions

1. For QA & Full-Stack Engineers: Automated Visual Regression (`regression` mode)

1. On-Device Gemma 2 Inference via `llama.rn`

2. Autonomous Fine-Tuning & Vector Retrieval Pipeline (`/ml`)