DEV Community: Kshitij

Your most polite customers are the ones you’re about to lose.

Kshitij — Sun, 30 Aug 2026 17:43:23 +0000

Think of the last time you said an app was “fine.”

You still have it on your phone. You still open it when you’re tired. You would not recommend it to a friend. You also would not write to support. Support is for a missing order. “Fine” is quieter than that. “Fine” means you order less, then you stop.

This review is that moment:

“It’s not bad but I’m comparing every food order to getting downstairs 10 floors. The convenience tax is getting loud.”

— 3 stars

In plain English: skipping 10 floors of stairs used to be worth the extra fee. Now walking is starting to win. The person still has manners. They even left stars in the middle.

A normal sentiment tool reads “not bad,” sees 3 stars, and calls it okay. Maybe even positive. Green on the dashboard.

What happens next is not a complaint. It is fewer orders. Then the app comes off the phone.

That is the whole product: the review that looks okay and means goodbye.

What Resonance is

Resonance reads a sheet of reviews and tells you what people felt, not what they performed. It scores eight emotions. It notices when the words and the feelings disagree. It names the groups hiding in the 3- and 4-star pile. It writes a Hidden Ask — the need nobody filed as a ticket. Then it waits. It will not invent a product roadmap until you say yes.

Try it live: https://graphics-newsletters-usr-simplified.trycloudflare.com
Code: https://github.com/kernelKain/resonance
Watch a run: https://www.youtube.com/watch?v=QnLD8gl54OU

Two minutes. Then keep reading — the rest is what the clip doesn’t show.

kernelKain / resonance

Resonance

Customer emotion archaeology powered by Plutchik's Wheel

Resonance does not classify reviews as positive, negative, or neutral. It scores each review on Plutchik's eight emotions, flags cognitive dissonance, maps an unmet Maslow need, clusters the emotion vectors in a TrueForge sandbox, names psychological archetypes, writes Hidden Asks — then pauses for a human before any product-roadmap recommendation is emitted.

Built for The Agent Harness Hackathon on the TrueForge harness (filesystem MCP, Exa web search, Daytona sandbox, ask_user_question).

Live demo: https://graphics-newsletters-usr-simplified.trycloudflare.com

Always-on Oracle Always Free ARM VM in Mumbai. Nothing runs on a laptop. The URL is a Cloudflare Quick Tunnel (*.trycloudflare.com); it can change if that tunnel process restarts.

Screenshots

Zomato demo run (Plutchik profile → HITL approval → roadmap).

Upload a CSV → watch the Plutchik wheel fill in real time → approve the analysis → export a dark-theme PDF.

Sample analysis

Product	Dataset	Report

…

View on GitHub

Built for The Agent Harness Hackathon (WeMakeDevs × TrueForge × Qodo). The live URL is a Cloudflare tunnel on a small always-on VM. If that process restarts, the hostname can change. The repo and the video stay.

Drop a CSV. Watch the wheel fill. Approve or decline. Download a PDF.

The job I gave the agent

A product manager already has a spreadsheet. Their dashboard says “mostly positive.” They need the people hiding in the polite ratings.

The job, in order:

Read the file. Don’t make me paste reviews into a chat.
Learn what the product is, so “I love it” on food is not “I love it” on a bank.
Score every row: eight emotions, whether the words fight the feeling, one unmet need.
Group similar emotion patterns with real math — not a guess.
Name the groups. Write the Hidden Asks.
Ask me before any “you should build X.”

The eight emotions are Plutchik’s, not happy / sad / meh. Politeness is not joy.

This is the job: a shape of feeling, not a thumbs-up.

TrueForge: the harness in the middle

A chatbot answers. An agent has to reach a file, run code somewhere safe, and stop before it does something you can’t undo. I didn’t want to spend the week building that machinery. TrueForge is the layer between the model and everything it touches.

You (browser)  →  workbench  →  TrueForge agent
                                   ├ filesystem (the CSV)
                                   ├ web research (what is this product?)
                                   └ sandbox (the clustering script)

What the harness handled:

Files — the agent reads the upload by name and writes results. It doesn’t get the rest of the disk.
A specialist — one helper looks up the product. Scoring and the wait stay on the main agent.
A sandbox — grouping runs in a sealed machine, not on my laptop.
A pause — after Hidden Asks, TrueForge stops and asks. Roadmap items stay empty until Approve. Decline ends there.

I wrote the screen, the parser, and the PDF. The harness wrote the loop, the tools, the sandbox, and the wait.

TrueForge paused on ask_user_question — waiting for Approved or Decline.

The wait is not a fake button. The session actually stops.

What broke

Stage 1 — the model vanished. The first provider ran out of quota. I moved the agent to OpenRouter: one model first, a second if the first turn fails. A run stays on one model until you approve. Unsexy. Why the demo still works.

Stage 2 — the sealed room had no door. I told it to run the clustering script on the scored file. The sandbox had never seen that file. I had to copy the script and the data in. After that, it was just a tool.

Stage 3 — the answer got cut in half. Long replies died mid-stream. The UI said done. The wheel was empty. I stopped asking the model to “be complete” and started only drawing what I could actually read.

Stage 4 — the first model got tired. Same job, second model, more room. Not a second opinion.

Stage 5 — the small computer had opinions. The app had to listen for the real visitor IP behind the tunnel. The harness on that machine had to listen on all network interfaces or Docker couldn’t talk to it. The public URL is a tunnel. The only open door is SSH.

That’s the messy middle. That’s also why a stranger can click the link.

Qodo from the first PR

Every real change went through a pull request. Qodo read it before it landed. That was the way the repo grew, not a polish pass at the end.

Example: PR #4 — the approval step. The dangerous part of this product is emitting a roadmap. Qodo caught a High bug: if the pause data failed to parse, Approve would fake a local replay, mark the run done, and never send the answer back to TrueForge. The wait would look real. The harness would never hear you.

I stopped inventing a fake replay id. Approve only continues when the pause is a real TrueForge interrupt.

I don’t merge because the bot is green. I merge when the note is fixed, or the thread says why we skipped it.

All merged work: the PR list.

One Zomato run

I uploaded zomato_reviews.csv. Fifty reviews. No extra chat window — the file is the input.

First, the polite ones that don’t mean polite.

Same quote as the opening. Now you can see the tag.

Then the group that still opens the app.

They stay because discovery still works. One bad bill and they don’t.

Then the need that never became a ticket.

Not “make the bot nicer.” A person who can undo a wrong charge.

Then it waits. The roadmap side is blank on purpose.

Approve continues. Decline stops here. I tried both.

Only after Approve:

Same ask, now as something you could ship. That sentence did not exist before a human said yes.

Go try it

Open the live link at the top, or clone the repo, and hit Load demo dataset. Approve once. Decline once. The interesting screen is the one where the roadmap is still empty.

PawSpective: See the World Closer to How Your Dog Sees It

Kshitij — Mon, 17 Aug 2026 04:44:53 +0000

This is a submission for Weekend Challenge: Dog Days Edition.

Have you ever bought a bright red toy that looked impossible to miss only to watch your dog struggle to find it on green grass?

Humans and dogs do not experience color in the same way. That inspired me to build PawSpective, an application that combines a canine-vision approximation, AI-assisted scene understanding, deterministic visibility calculations, and playful narrated videos.

The central idea is one connected experience:

Capture a scene → explore a canine-vision approximation → discover which objects remain visible → turn the moment into a fictional story.

I also wanted PawSpective to be entertaining without pretending it can read a dog’s mind. It does not claim to determine exact canine vision, gaze, thoughts, feelings, smell, or intent.

What I Built

PawSpective helps dog owners explore how objects in an everyday scene may appear under a canine-inspired color transformation.

A user can:

Create a lightweight dog profile.
Open the Live Dog Lens.
compare Human View with a canine-vision approximation.
Record or upload a short video.
Let Google Gemini identify visible objects and scene events.
Review, rename, or remove incorrect AI detections.
Calculate the relative dog-visible contrast of an object.
Explore possible attention cues through the Curiosity Map.
Compare alternative toy colors in the Toy Color Lab.
Generate and download a fictional narrated Story Reel.

Live Dog Lens

The Live Dog Lens uses a browser-based WebGL transformation to provide an immediate Human/Dog Vision comparison.

The transformation preserves more blue and yellow differentiation while reducing red and green differentiation. A comparison slider makes the effect easy to understand, and a dog-height guide helps users frame the scene from a lower point of view.

This is deliberately described as a canine-vision approximation, not an exact reconstruction of what a particular dog sees.

AI scene analysis

After a user uploads a 5–15 second video, PawSpective sends a normalized, silent version of the clip to Google Gemini.

Gemini returns structured scene evidence, including:

Visible object labels
Approximate bounding boxes
Timestamps
Object categories
Confidence values
Visible evidence
Coarse motion levels

The response must pass a strict Pydantic and JSON Schema contract before the application accepts it.

Users can then remove incorrect events, rename objects, and select which object should be analyzed. These corrections become the source of truth for visibility calculations and Story Reel generation.

Visibility Lab

The Visibility Lab measures how strongly a selected object differs from its nearby background.

The backend:

Seeks to the event timestamp.
Samples pixels inside the object’s corrected bounding box.
Samples a surrounding background region.
Applies the same canine color transformation used by the frontend.
Converts colors into CIE Lab.
Measures foreground/background color and luminance separation.
Produces a relative dog-visible contrast score.

The result is presented as a product score and qualitative visibility band—not as a scientific probability.

For example:

Dog-visible contrast: High

The blue toy remains visually distinct from the surrounding grass after the canine-vision transformation.

Curiosity Map

The Curiosity Map highlights objects that may visually stand out in the scene.

It combines:

AI-inferred motion
Measured dog-visible contrast
Apparent object size
A small optional profile-relevance bonus

Every result explains why it appeared. PawSpective calls these possible attention cues, because the application does not track a dog’s gaze or know what the dog is actually paying attention to.

Toy Color Lab

Toy Color Lab compares six screen colors against the measured background around a selected object.

It keeps the surrounding background unchanged, simulates alternative colors for the object, applies the canine transformation, and ranks the colors by approximate dog-visible contrast.

The preview is illustrative—it does not claim that a physical toy will look exactly the same or guarantee a dog’s response—but it makes the red-versus-blue-on-grass problem immediately understandable.

Story Reel

The final step turns the reviewed scene into an 8–10 second vertical video.

Google Gemini uses only the user-reviewed scene timeline to generate grounded story and animation direction. ElevenLabs creates the fictional dog narration, and FFmpeg combines the video, narration, captions, overlays, music, watermark, and disclaimer into a downloadable 9:16 MP4.

The result remains clearly labeled Just for fun.

Demo

The application is available at:

👉 https://pawspective.onrender.com/

Demo note: [My Gemini API daily usage limit ran out, so I couldn’t publish the complete demo.]

The interface and deployed application can still be explored through the link above. The complete demonstration will be added to the repository once the provider usage limit is available again.

Code

The complete source code is available on GitHub:

kernelKain / pawSpective

See the world closer to how your dog sees it. PawSpective combines canine-vision simulation, AI-powered object visibility analysis, curiosity mapping, and playful narrated story reels.

PawSpective

See the world closer to how your dog sees it. PawSpective combines a canine-vision approximation, reviewed AI scene analysis, deterministic visibility scoring, color comparison, curiosity mapping, and downloadable fictional Story Reels.

What it does

Opens a live Human/Dog Vision comparison or accepts a 5-15 second video.
Detects visible objects with Gemini and lets the user correct the result.
Measures foreground/background contrast with OpenCV and CIE Lab color.
Shows possible attention cues in a timestamp-aligned Curiosity Map.
Compares six screen colors in Toy Color Lab.
Creates an 8-10 second animated dog-height POV reel with fictional narration.
Supports a SHA-256-bound controlled demo for offline rehearsals.

PawSpective labels deterministic calculations as Research-grounded model interpretation as AI-inferred, and fictional output as Just for fun. It does not claim exact canine vision, gaze, thoughts, emotions, smell, intent, or behavioral diagnosis. See the AI disclosure for data flow, limitations, and provider details.

…

View on GitHub

Repository: https://github.com/kernelKain/pawSpective

The repository also contains the product contract, AI disclosure, deployment guide, exported schemas, automated tests, Docker configuration, and release checklist.

How I Built It

PawSpective uses a Next.js frontend and a Python media-processing backend.

Frontend

The frontend uses:

Next.js 16
React 19
TypeScript
WebGL for the live color transformation
Canvas and video APIs for previews and overlays
Vitest and Testing Library
Playwright for end-to-end smoke testing

The browser handles the live Dog Lens, comparison slider, dog profile, recording and upload flow, object-correction interface, visibility results, Toy Color Lab, Curiosity Map, job polling, and Story Reel download.

Backend

The backend uses:

FastAPI
Pydantic
Google Gemini
OpenCV
NumPy
ElevenLabs
FFmpeg and FFprobe
SQLite

FastAPI validates uploaded media, normalizes videos, coordinates AI requests, performs deterministic calculations, and manages background Story Reel jobs.

SQLite stores job metadata and progress, while generated media is stored on a writable backend volume. Story rendering runs through a bounded background worker so the frontend can submit a job, poll its progress, and download the completed reel.

Google Gemini

Gemini is used for three related tasks:

Scene analysis

Gemini examines the short clip and returns visible objects, approximate bounding boxes, timestamps, motion levels, and supporting visual evidence.
Grounded story generation

Gemini receives the reviewed event timeline instead of being allowed to invent details directly from the raw video.
Animation direction

Depending on the configured model and access, Gemini Omni or Veo can create a canine-vision-inspired artistic edit using the source clip or reference frames.

One of my most important engineering decisions was requiring structured model output. Gemini responses are validated against strict schemas, and malformed coordinates, unsupported fields, impossible timestamps, or ungrounded results are rejected.

ElevenLabs

ElevenLabs generates the complete fictional dog narration for the Story Reel.

Only the finalized narration text is sent to ElevenLabs—the original video is not. The selected voice is intentionally described as a fictional dog voice, rather than an attempt to recreate a real animal’s voice or internal thoughts.

The application also supports narration failure handling and cached demo output so a temporary voice-service problem does not break the entire user journey.

Deterministic computer vision

I did not want an AI confidence value to become a fake scientific visibility score.

Instead, the Visibility Lab and Toy Color Lab use deterministic OpenCV and NumPy calculations. They sample pixels from the video, apply the documented color transformation, convert the colors to CIE Lab, and measure relative foreground/background contrast.

This creates a clear boundary between what the model inferred and what the application calculated.

Video composition

FFmpeg performs the final media work:

Video normalization
Portrait 9:16 composition
Captions
Narration synchronization
Curiosity overlays
Visibility result cards
Music
Watermarking
Final MP4 encoding

Using a fixed template made the rendering pipeline more reliable and kept the project focused on one polished experience instead of becoming a general-purpose video editor.

Reliability and responsible AI

PawSpective separates its output into three categories:

Research-grounded: deterministic transformations and calculations
AI-inferred: visible-object and motion interpretation from Gemini
Just for fun: fictional narration and story framing

The application includes recovery paths for camera denial, unsupported browsers, malformed AI output, dark footage, empty detections, narration failures, rendering errors, portrait and landscape uploads, and missing profile photos.

It also supports a controlled rehearsal mode. Cached analysis and media are bound to one exact video using a SHA-256 fingerprint, preventing saved bounding boxes from being incorrectly applied to an unrelated upload.

This separation became one of the most important lessons from the project: an AI product can be playful while still explaining where every result came from.

Prize Categories

Best Use of Google AI

Google Gemini powers PawSpective’s structured scene analysis, grounded story generation, and optional video-animation workflow.

Gemini is not used as an unrestricted narrator. Its output is schema-validated, reviewed by the user, and checked against visible scene evidence before it enters later stages of the application.

Best Use of ElevenLabs

ElevenLabs converts the grounded fictional script into narration for the downloadable Story Reel.

Voice generation is integrated into a complete media pipeline rather than presented as an isolated text-to-speech example. The narration is synchronized with captions, scene events, overlays, music, and the final vertical video.

What I Learned

The hardest part was not adding more AI. It was deciding which parts should not depend on AI.

Gemini is useful for interpreting a scene, but object visibility is better represented by deterministic calculations over measured pixels. Storytelling can be imaginative, but it must remain grounded in events the user has reviewed.

That led to the design principle behind PawSpective:

Use AI for interpretation and creativity, deterministic code for measurable calculations, and clear labels wherever uncertainty remains.

PawSpective started as a fun question about how dogs experience color. It became an experiment in building an AI-powered product that combines delight, practical insight, transparency, and responsible storytelling.

I Built a Tool to Detect Delayed Access Revocation

Kshitij — Sun, 09 Aug 2026 20:16:36 +0000

This weekend, I built TimeTrap.

It started with a simple question:

What if access is revoked, but something that depends on it stays active?

That small delay can become a real security problem.

🔗 Try TimeTrap live

💻 View the source code

The problem

Imagine a user cancels a premium subscription at minute 10.

The subscription is revoked immediately, but a cached permission remains active until minute 60. The system allows a five-minute grace period.

So the timeline looks like this:

Time	What happens
Minute 10	Subscription is revoked
Minute 15	Allowed grace period ends
Minute 60	Cached access finally expires

The user keeps premium access for 50 minutes after cancellation. Of those, 45 minutes violate the rule.

Each part of the system may look correct by itself. The subscription was revoked, and the cache eventually expired. The problem is the gap between those two events.

That is what TimeTrap finds.

What TimeTrap does

You describe the objects in your authorization flow—subscriptions, caches, sessions, or tokens—and add events such as:

issue
refresh
revoke
expire

Then you choose a rule, such as “cached access must end within five minutes of subscription revocation.”

TimeTrap checks the timeline and shows:

whether the scenario is safe;
the exact time the violation begins and ends;
how long stale access remains active;
the events that caused the problem;
a suggested correction.

For the example above, TimeTrap reports the violation as [15, 60) and suggests revoking the cached permission when the subscription is revoked.

You can see the complete flow here:

How it works

The analyzer is written in Go and is fully deterministic. The same input always produces the same result.

Instead of checking every minute, it checks only the moments where something can change: an issue, refresh, revocation, expiry, or rule deadline. It then joins failed periods into one clear violation interval.

The rest of the application uses:

React and TypeScript for the interface;
Go for the API and analyzer;
PostgreSQL for saved scenarios and results;
Zerops for deployment.

Saved results use their own URLs, so they can be refreshed or shared. Applying a fix creates a corrected copy instead of replacing the original unsafe result.

What I learned

Authorization is not only about who can access something. It is also about when that access should stop.

TimeTrap is currently a design-time tool. It checks the scenario you provide; it does not inspect or change a live production system. The model is intentionally small and uses integer-minute timing, but it makes this easy-to-miss problem visible.

OpenAI Codex helped me with planning, implementation, testing, documentation, and deployment. I still reviewed the code and verified the behavior through tests, builds, API checks, and browser testing.

I built TimeTrap for the WeMakeDevs challenge and deployed it on Zerops.

If this kind of authorization problem sounds familiar, try the demo and let me know what you think.

👉 Open TimeTrap

⭐ Explore the GitHub repository