DEV Community: Jason Bann

Your "AI Video Detector" is Snake Oil. I Built a Frame Ripper Instead.

Jason Bann — Wed, 06 May 2026 13:00:02 +0000

Everyone on this site is currently arguing about whether prompt engineering is a real job, while simultaneously ignoring that the actual tooling being built to detect generative slop is fundamentally broken.

If you look at the current market of "AI Video Detectors," 90% of them are just lazy, black-box API wrappers. You upload a video, a loading bar spins, and it spits out a completely opaque metric: "We are 87% confident this is AI." Based on what? What is the model actually looking at?

The problem with standard AI video detection is that it usually tries to analyze the video as a video. It looks at the container and the compressed stream. But standard video compression algorithms (H.264, HEVC) rely heavily on interframe compression—using motion vectors to predict and smooth over data between keyframes.

Do you realize what that means? The compression algorithm is actively doing the generative AI's cover-up work for it. It takes the AI's temporal hallucinations and smooths them out. If your detector is looking at the compressed stream, it's analyzing the codec, not the underlying generational rot.

So, I built a Frame Ripper instead.

The Technical Flex: Stop Guessing, Start Tearing

Generative video models do not possess object permanence. They don't render 3D space; they hallucinate pixel probabilities frame by frame. To catch them, you have to strip away the temporal smoothing and destroy the video container completely.

I built the Vibeaxis Frame Ripper to do exactly this. It doesn't give you a mystical confidence score. It is a brutalist diagnostic tool that physically rips the video timeline apart into its raw, isolated bitmaps.

When you force a piece of media to exist as raw, uncompressed, sequential frames, the AI's logic completely collapses.

Look at Frame 142: The lighting source makes sense.

Look at Frame 143: The geometry of the background architecture has entirely shifted.

Look at Frame 144: A hand has seven fingers melting into a coffee cup.

We don't need another proprietary neural network trained to detect other neural networks in an endless arms race of slop. We just need tools that rip the data down to its rawest, ugliest components so the human eye can see the foundational errors the AI couldn't hide.

Code Should Show Its Work

If your diagnostic tool can't show you the exact pixel-level anomaly that triggered its flag, it’s useless to you as a developer. Stop relying on opaque confidence scores from companies selling you the cure to the disease they created.

Show DEV: I refused to pay $40 for a clunky PC sensor panel, so I built my own with React & Electron.

Jason Bann — Tue, 28 Apr 2026 05:01:25 +0000

If you’ve built a custom PC recently, you’ve probably looked into putting a 5-inch or 8.8-inch ultra-wide "sensor panel" inside your case. It looks incredible, but the software ecosystem running these displays is a nightmare.

Your options are basically:

Pay $40 for AIDA64, which features a UI that hasn't been updated since 2004, and manually drag the window to your secondary display every time you reboot.

Spend a weekend editing .ini text files in Rainmeter just to get a reliable GPU temperature reading.

I got tired of negotiating with friction. I didn't want to write C++, and I didn't want to pay for legacy bloatware. So, over the weekend, I engineered a bypass using React, Electron, and Node.js.

Here is how I built VibeAxis Telemetry, a 1-click, completely borderless hardware monitor.

The Architecture: Solving the "Dual Window" Problem
The biggest UX problem with desktop widgets is configuration. You want the dashboard to be borderless, locked, and un-clickable. But you still need a way to change themes and upload backgrounds.

I needed two separate windows: a locked Dashboard and a standard Control Panel.

Instead of building and compiling two completely separate React applications, I used a URL Hashing trick inside a single Vite/React build. When Electron spawns the windows, it simply appends a hash to the local file path:

TypeScript
// main.ts (Electron Backend)
function createDashboardWindow() {
dashboardWin = new BrowserWindow({ width: 1280, height: 400, frame: false });
dashboardWin.loadFile('index.html', { hash: 'dashboard' });
}

function createSettingsWindow() {
settingsWin = new BrowserWindow({ width: 600, height: 700 });
settingsWin.loadFile('index.html', { hash: 'settings' });
}
On the React side, a single useEffect hook listens to the URL route. If it sees /#dashboard, it renders the SVG dials. If it sees /#settings, it renders the buttons and file upload inputs. One codebase, two completely decoupled UIs.

The IPC Bridge: Talking Across the Void
Because the two windows are separate Chromium processes, they can't share a React state. If a user uploads a new background image in the Settings window, I need to instantly beam that image to the Dashboard.

I built a secure IPC (Inter-Process Communication) bridge using Electron's contextBridge.

When you upload an image in the Settings window, React converts the file into a Base64 string and fires it across the bridge to the Node backend:

JavaScript
// App.jsx (Settings Window)
const handleImageUpload = (e) => {
const reader = new FileReader();
reader.onload = (event) => window.api.sendBg(event.target.result);
reader.readAsDataURL(e.target.files[0]);
}
The Node backend catches it, acts as a relay station, and blasts it directly into the isolated Dashboard window, updating the CSS instantly without a reload.

Reading Hardware Temps without C++
To get kernel-level CPU and GPU data, I bypassed writing native Windows plugins and utilized the systeminformation npm package. By running the Electron backend with administrative privileges, Node can read the motherboard sensors directly.

TypeScript
// Hardware Polling loop
setInterval(async () => {
const graphics = await si.graphics();
// Find the dedicated GPU (safely handle undefined temp sensors)
const gpu = graphics.controllers.find(g => (g.temperatureGpu ?? 0) > 0) || graphics.controllers[0];

dashboardWin.webContents.send('telemetry-update', {
gpuTemp: gpu.temperatureGpu,
gpuLoad: gpu.utilizationGpu
});
}, 2000);
The 1-Click Lock
The final piece of the puzzle was killing the "drag and drop" friction. Using Electron's screen API, the app automatically scans your hardware for a display matching the 1280x400 aspect ratio. When you click "Lock to Mini-Display," it calculates the exact X/Y coordinates of that monitor, teleports the dashboard there, and locks it into full screen.

The Result
I packaged it up with electron-builder into a standalone .exe. It takes up a fraction of the system resources of legacy tools, natively supports CSS variable theming, and most importantly, it's completely free.

Stop paying for clunky software.

Links:

Download the 1-Click Windows Installer at VibeAxis.com

Star the Repo or fork the code on GitHub

Let me know what you think of the architecture, or if you have any ideas on how to optimize the IPC bridge even further!

How TikTok’s Safety Bot Forced Me to Optimize My JS Canvas Engine

Jason Bann — Sun, 19 Apr 2026 03:01:30 +0000

If you’ve ever tried marketing an indie game on short-form video platforms, you already know the golden rule: Make it flashy, make it fast, and make it pop. I’m currently building an in-browser sci-fi defense game called Divine Orbit. You play as an AI defending a planet from cosmic threats using orbital superweapons. Because it’s a web game, I wanted to prove that an HTML5 could produce chaotic, massive, cinematic explosions that rival desktop games.

So, I cranked the visual juice to the absolute max. I wanted every nuke and meteor impact to feel devastating.

The result? My gameplay clips looked awesome.
The problem? TikTok’s algorithm shadowbanned my account to exactly 0 views.

Here is how an automated safety bot forced me to rethink my rendering path, ditch my DOM animations, and build a high-performance, zero-allocation volumetric particle engine.

The Problem: Accidentally Coding a Flashbang
In my pursuit of "flashy," I made a classic visual effects mistake. I was relying heavily on two things to make my explosions look powerful:

CSS/DOM-based Shockwaves: Every time a meteor hit, I was pushing a new object into a React state array (setMeteorExplosions) that rendered a rapidly expanding, stroked HTML

ring over the canvas.

Screen Blending: Inside the actual canvas particle system, I was rendering hundreds of particles using ctx.globalCompositeOperation = 'screen'.

If you know how screen blending works, you already know where this is going. When 50 red and gold particles overlap in the exact same coordinate space, the colors compound. It doesn’t look red anymore; it blows out into pure, blinding #FFFFFF white.

Add in the rapidly expanding CSS rings on a pitch-black space background, and my game wasn’t just flashy—it was a literal strobe light. TikTok’s automated trust and safety bots flagged the high-frequency contrast shifts as an epilepsy hazard, and silently dropped my reach to zero.

The Fix: Volumetric Plasma & Zero-Allocation
I couldn't just turn down the opacity; it made the game look weak. I needed the explosions to feel heavy and cinematic without triggering the strobe filters.

I completely gutted the visual pipeline and made three major architectural changes:

Killing the React DOM Rings
I was making React do layout recalculations in the middle of heavy combat just to render CSS circles. I completely deleted the setMeteorExplosions state and moved 100% of the explosion logic directly into the engine. No more sharp, high-contrast geometric outlines—just soft pixels.
Switching to 'Source-Over' Volumetrics
I stripped out the screen blending. Instead of letting colors compound into pure white light, I locked the context to source-over and hard-coded warm, capped-opacity gradients.
The Zero-Allocation Pool
To handle the increased load of drawing all these soft-body particles on the canvas, I used a pre-allocated object pool. Instead of creating and garbage-collecting hundreds of objects per frame, I recycle them:

JavaScript
// The TikTok-Safe Volumetric Render Loop
ctx.globalCompositeOperation = 'source-over'; // No more blinding screen blends!

const partLen = particlePool.length;
for (let i = 0; i < partLen; i++) {
const p = particlePool[i];
if (!p.active) continue;

p.life -= delta * 5.0; 
if (p.life <= 0) { p.active = false; continue; }

p.size += ((p.maxSize) - p.size) * (delta * 25);
const currentRadius = Math.max(1, p.size);

// THE GLOWING GAS CLOUD (Soft Filled, Capped Opacity)
const cachedSprite = spriteCacheRef.current[p.color];
if (cachedSprite) {
    ctx.globalAlpha = Math.max(0, p.life * 0.7); // Never hits 100%
    ctx.drawImage(cachedSprite, p.x - currentRadius, p.y - currentRadius, currentRadius * 2, currentRadius * 2);
} else {
    ctx.globalAlpha = Math.max(0, p.life * 0.6);
    ctx.fillStyle = p.color;
    ctx.beginPath();
    ctx.arc(p.x, p.y, currentRadius, 0, Math.PI * 2);
    ctx.fill();
}

// THE SEARING CORE (Warm & Muted)
// Removed pure white. Uses a warm orange/yellow that fades out instantly.
ctx.globalAlpha = Math.max(0, (p.life - 0.4) * 0.5); 
ctx.beginPath();
ctx.arc(p.x, p.y, currentRadius * 0.35, 0, Math.PI * 2);
ctx.fillStyle = 'rgba(250, 200, 100, 0.8)'; 
ctx.fill();

}
ctx.globalAlpha = 1.0;
The Result
The irony of this whole nightmare is that the TikTok algorithm was actually right.

By forcing me to remove the cheap strobe effects and screen blending, the game looks objectively better. The explosions now look like heavy, billowing cinematic plasma instead of a neon geometry rave.

More importantly, by migrating everything away from React state updates and strictly into a zero-allocation canvas pool, my frame times stabilized drastically during late-game waves when the screen is covered in orbital strikes.

If you are building browser games, be very careful with screen or lighter composite operations on dark backgrounds. What looks like a cool laser blast to you might look like a liability to a social media algorithm.

If you want to see the new optimized engine in action, you can play the live web build right now on VibeAxis.

And if you hate the idea of Earth being destroyed by giant rocks, consider dropping a Wishlist for Divine Orbit on Steam!

A 90-second drill for release notes (that you’ll actually use)

Jason Bann — Sat, 11 Oct 2025 17:03:45 +0000

Release notes pile up. People skim. Outages happen.

I use a tiny drill:
1) Paste the changelog (or fetch the URL).
2) Pull out breaking changes, new defaults, flags/toggles.
3) Produce a migration/rollback checklist + Markdown buckets.

Tool: https://vibeaxis.com/patch-notes-summarizer/

Buckets: Added / Changed / Fixed / Removed / Deprecated / Known issues / Open questions / Highlights.

Export JSON if you want to feed a docs pipeline.

Bonus: gut-check your prose with Slop Index → https://vibeaxis.com/slop-index/

Shipping Without the Slop: A Receipts-First Workflow for Marketing Copy

Jason Bann — Sun, 05 Oct 2025 19:14:43 +0000

If you’re moving fast, you’re probably shipping a little slop. Not because you’re lazy because the marketing web is booby-trapped with FOMO, fake intimacy, techno-mysticism, and “trust us, bro” vibes that sneak into drafts when you’re sprinting.

Here’s how we’ve been shipping cleaner, faster: a receipts-first workflow that flags manipulation language, rewrites it neutral, and leaves a paper trail you can point to later.

The one-click check: Adblock for Feelings

We built Adblock for Feelings
to lint persuasion tactics the way ESLint lints code.
Paste copy (or run the bookmarklet on any page) and it highlights:

FOMO & scarcity (last chance, ends tonight, waitlist…)
Authority-laundering (experts agree, scientifically proven…)
Fake intimacy (just between us, we noticed you…)
Hype (revolutionize, 10x, world-class…)
Fear bait & flattery

…plus a cleaned version you can ship without sounding like a cartoon villain.

It’s all client-side, no login, and you can export the flags as CSV or download a “receipt” (HTML) with hashes so future-you can prove you did the right thing.

Why receipts? Because arguments on the internet end when the evidence starts. See: How To Run Your Own Receipt Study

The receipts-first loop (15 minutes)

Draft like you mean it. Don’t self-censor in the first pass.

Run a feelings-lint. Paste into Adblock for Feelings → set strictness to Normal or Ruthless.

Neutralize & compare. Skim the Cleaned output; if meaning holds, keep it.

Export flags. Save CSV (for content QA) or the Receipt HTML (for audits).

Re-score the page. If it’s a long form, scan the published URL too.

Log the win. Drop the receipt link into your PR/issue to prevent “who changed the tone?” fights later.

If you’re fighting platform sludge in general, you might like:

AI Slop Index: Text
— grade a page’s “slop density” in ~60 seconds.

Boring On Purpose: Why Our Plugins Don’t Chase Hype
— the philosophy behind all this.

Algorithmic Possession: A DIY Exorcism for Your Recommender
— detox when feeds go feral.

When to turn the dial up (or down)

High-stakes pages (pricing, policy, comparison pages): set strictness to Ruthless and enable FOMO/Fear/Authority.

Community posts: go Gentle, leave Ambiguity on to catch weasel words.

Performance ads: try Neutralize mode (no highlights), compare CTR vs. bounce—then decide which tradeoffs you actually want.

Bookmarklet for field work

Adblock for Feelings has a “Copy Bookmarklet” button so you can run highlights on any page you’re analyzing yours, competitors’, or internal drafts in your CMS. Great for teardown threads or “before/after” screenshots.

Speaking of teardowns:

Digital Dumpster Diving: Reverse-Engineering Deleted TikToks

Rage-Click Olympics: Timing the Web’s Petty War Crimes

Ethics is velocity

The fastest teams codify taste. Linting language isn’t about being nice it’s about being consistent and defensible. If your brand voice is “honest over hype,” your toolchain should enforce it.

Start here: Adblock for Feelings
.
Ship copy you don’t have to apologize for later.

PS: More experiments you might like

Friendly vs. Honest: Which AI Voice Actually Builds Trust?

Open-Source AI vs Closed Models: Who Wins?

AI Hallucinations: Why They Happen and How to Stop Them

A No-JS ‘Back to Top’ that isn’t cringe (VAX Micro UX)

Jason Bann — Sat, 13 Sep 2025 12:32:10 +0000

title: "A No-JS ‘Back to Top’ that isn’t cringe (VAX Micro UX)"
published: true
tags: wordpress, accessibility, performance, ux
series: "Micro UX That Respects Users"

canonical_url: "https://vibeaxis.com/Ai-tools/

description: "A tiny ‘Back to Top’ that ships zero JS, respects reduced motion, and only shows on long posts."

TL;DR: I shipped a WordPress plugin that adds a “Back to Top” button without JavaScript. It only renders on long posts, hides on desktop, respects prefers-reduced-motion, and doesn’t dunk your CLS. It’s called VAX Micro UX.

Why this exists
Most “Back to Top” widgets are 30KB of JS to do a native anchor jump. We turned a one-line feature into a cottage industry of scroll listeners, icon fonts, and layout jank.

I wanted the opposite: something you forget you installed.

No JS. Native anchor + smooth scroll (and we disable it for reduced-motion).

Contextual. Only appears on long posts (default ≥ 900 words).

Mobile-first. Hidden ≥ 900px by default—because desktops have page-up keys and sane scroll wheels.

Zero settings. Activate and move on.

How it works (boring on purpose)
Prints a #va-top anchor with wp_body_open.

On long single posts, prints a floating link with a small inline SVG arrow.

Injects a tiny CSS block for native smooth scroll and a focus ring.

No database writes, no tracking, no external assets.

Customize without opening the plugin
You can tweak thresholds and colors with filters:

php
Copy code
// functions.php or a small mu-plugin
add_filter('vax_backtop_min_words', fn()=> 1200); // show only on 1200+ words
add_filter('vax_backtop_mobile_breakpoint', fn()=> 768); // hide on >= 768px
add_filter('vax_backtop_bg', fn()=> '#ffd400'); // acid yellow button
add_filter('vax_backtop_fg', fn()=> '#000000'); // black arrow
That’s it. No admin pages. No “Pro” upsell. If you want a control panel for a back-to-top link, we disagree about life.

Accessibility notes
Uses a real link with aria-label, so it’s keyboardable and screen-reader friendly.

Adds a focus-visible ring.

Honors prefers-reduced-motion (native smooth scroll off).

Install
Install VAX Micro UX from wp.org (or upload the ZIP).

Activate.

Write something long and actually worth scrolling. The button appears on mobile near the bottom right.

When a feature can be done in CSS and markup, do it in CSS and markup. Save your JS budget for things that aren’t already built into the browser.

— VibeAxis (receipts, not vibes)

Anti-Influence Suit — Armor for the Feed

Jason Bann — Sun, 07 Sep 2025 14:26:11 +0000

title: Anti-Influence Suit — Armor for the Feed
published: true
tags: attention, productivity, psychology, social

canonical_url: https://vibeaxis.com/the-anti-influence-suit-browse-without-being-modeled/

The feed isn’t content. It’s a centrifuge for your mood.

The Anti-Influence Suit is a 30-second protocol you run once a week. It’s not a “digital detox.” It’s plumbing.

0) Baseline (1 minute)

Take a screenshot of your home feeds (YouTube, TikTok/IG, X/Threads). Label it with today’s date. If your pulse jumps, good—you’ve found the leak.

1) Kill the bait (90 seconds)

Mute words you compulsively click (celebrity names, outrage bait, your ex’s new hobby).
Turn off “personalized” notifications. Keep only DMs, calendar, payments, delivery.
Block the puppeteers who farm you for “engagement” then sell the corpse.

Rule: if it hijacks your Sunday, it doesn’t get Monday.

2) Rewire “recommended” into “requested” (60 seconds)

YouTube/Spotify: unsubscribe everything you don’t want weekly.
Home feeds: Follow → Lists (X) / Favorites (IG) / Collections (Threads). Visit lists first; kill home second.

3) Friction layer (30 seconds)

Add a 1-tap filter: “Today only,” “New uploads only,” or a saved search.
Put your creation app on the home screen; bury the infinite feeds on page 3.

4) Weekly audit (30 seconds)

Open last week’s screenshot. Is today noisier? If yes, you got re-trained. Re-fit the suit (mute more words, remove one app’s notifications entirely).

Quick checklist (paste into notes)

[ ] Weekly screenshots saved
[ ] Mute list updated (5+ words)
[ ] Notifications: DMs/calendar only
[ ] Lists/Collections used first
[ ] Re-followed 0; unfollowed 5+
[ ] One app demoted to page 3

What this fixes

Doomscroll dopamine loops → muted triggers
Parasocial junk → lists/favorites instead of home
“Just one more” → friction on infinite feeds
Decision fatigue → scheduled audit, not willpower

Canonicals / Receipts:

Full breakdown lives here → https://vibeaxis.com/anti-influence-suit/

CLI for fast links:


bash
pip install -U vax-receipts-cli
vax-receipts list
# Windows cranky?  py -m vax_receipts_cli.cli list

Source Fidelity Playbook — Catch AI's Fake Citations in 90 Seconds

Jason Bann — Sun, 07 Sep 2025 12:39:43 +0000

Confident answer, dead link. Classic.

This is a 90-second drill to test whether an “AI answer” cites reality or decorates fiction.

The 90-Second Drill

1) Copy the claim. Pull the exact sentence the model is selling.

2) Open 3 tabs.

site: filter for primary sources (e.g., site:.gov, site:nature.com).
filetype: for reports and methods (filetype:pdf OR filetype:csv).
date range: match the timeframe the claim pretends to cover.

3) Verify author + provenance. Is the author real? Is the publisher the originator or a blog copying a blog?

4) Label the verdict.

✅ trustworthy / ❓ unknown / ❌ garbage (decorative link or irrelevant source)

Query Patterns (Copy/Paste)

"quoted phrase from the claim" site:.edu
topic name filetype:pdf 2022..2025
site:arxiv.org "exact method"

Your 5-Line Receipt

Claim:
Primary source:
Method check:
Date match:
Verdict:

When to Use Perplexity/Bing vs. Go Direct

Use aggregators to discover candidates (fast).
Go direct for verification (slow by design).

Full breakdown, examples, and failure cases: (canonical)

https://vibeaxis.com/perplexity-vs-google-find-the-source-not-the-hype/

We built a Slop Index: fingerprints for templated AI writing

Jason Bann — Sun, 31 Aug 2025 08:34:08 +0000

TL;DR: Clean ≠ human. The Slop Index scores template fingerprints—repetition loops, hedges, passive spikes, buzzword foam, paragraph uniformity—without tracking or uploading your text.

Why

“Looks fine” content often reads like it was extruded from a mold. We wanted measurable tells that a human can reason about—not a black-box “truth score.”

Signals

Repetition: share of top bigram vs all bigrams
Burstiness: sentence length variance
Lexical diversity: type–token ratio
Clichés / Buzzwords / Hedges per 100w
Passive hits per sentence
Paragraph uniformity (rhythm sameness)
Too-simple grade (only penalized when other signals fire)

Try it fast

Paste text or fetch a URL.
Export JSON for receipts.
Privacy: runs client-side; the optional fetcher strips scripts and caches for 10 minutes.

Live tool: https://vibeaxis.com/tools/slop-index/?utm_source=devto&utm_medium=post

GitHub: https://github.com/vibeaxis/slop-index

If you want a one-click bookmarklet:


js
javascript:(()=>{location.href='https://vibeaxis.com/tools/slop-index/?url='+encodeURIComponent(location.href)})()

First post - hi all

Jason Bann — Sun, 30 Jul 2023 20:34:43 +0000

🚧 Building Emotional Resilience: Overcoming Guilt Trips 🚧

https://viableoutreach.com/guilt-trip-meaning/

No more feeling trapped! 💪 Learn effective communication strategies, assertiveness, and setting boundaries to combat guilt-tripping behavior.

You've got the power to reclaim control over your emotions and decisions!