DEV Community: Ayush Kumar

UX Hell: The Login

Ayush Kumar — Sat, 11 Apr 2026 06:59:12 +0000

This is a submission for the DEV April Fools Challenge

What I Built

I built UX Hell: The Login, a digital torture chamber disguised as a standard authentication flow. It is a masterclass in "Hostile Design," featuring a login system that doesn't just fail—it mocks you.
Key features include:

The Emotional Password Field: It flips upside down while you type and rejects your password for being "too emotional."

The Regret CAPTCHA: You must select all squares containing "regret" (spoiler: it's all of them).

The Soul Contract: A 6,000-word Terms & Conditions page you must read aloud via voice recognition. If you lose your "sincerity," the AI resets your progress.

The Suffering Stream (Vlog Mode): A hidden "back door" leads to a live webcam feed filtered with glitch effects, accompanied by a fake chat of bots like BarnabyTheGhost mocking your failure.

Sarcastic AI: A vocal assistant powered by Gemini that generates custom insults based on your specific input failures.

Demo

You can experience the frustration live here:

site-never-let-you-login-zspp.vercel.app

Code

The project is built with a modular React architecture. You can explore the chaos in the repository below:https://github.com/ayush382004/site_never_let_you_login/tree/main

How I Built It

This project was built using a modern (yet heavily abused) tech stack:

React 19 & Vite: For the core application structure and lightning-fast "Brain Errors."

Google Gemini API: To power the AI Overseer’s sarcastic personality and real-time critiques.

Framer Motion: Used for the glitch effects, screen shakes, and popups that actively dodge your cursor.

Web Speech API: Utilized both SpeechSynthesis for the AI voice and SpeechRecognition to enforce the reading of the Soul Contract.

Tailwind CSS 4: For that specific "neon-drenched nightmare" aesthetic

Prize Category

I am submitting this for the Best Google AI Usage category. as well as
Best Ode to Larry Masinter

The “Ping-Pong” Effect: Breaking Infinite Logic Loops in Multi-Agent AI

Ayush Kumar — Thu, 09 Apr 2026 14:01:49 +0000

If you’ve graduated from building basic chatbots and started experimenting with Multi-Agent Systems (MAS) using tools like LangGraph or CrewAI, chances are you’ve already hit a frustrating (and expensive) wall:

The Infinite Logic Loop.

It doesn’t crash your system.
It doesn’t throw an obvious error.

It just keeps going.
A Familiar Nightmare
You design two agents:

A Coder Agent
A Reviewer Agent

The workflow seems perfect:

Coder writes code
Reviewer checks it
Feedback loops back

But then…

Reviewer flags a tiny issue
Coder fixes it—but introduces a new bug
Reviewer sends it back again

Repeat. Repeat. Repeat.

Ten minutes later, your agents are stuck arguing over a semicolon…
…and your API bill quietly climbs.

Welcome to Delegation Ping-Pong.
Why This Happens: The Hidden Flaw in MAS
In a single-agent setup, life is simple:

You define a max_iter
If the task isn’t done → system stops

But Multi-Agent Systems don’t play by those rules.

Here’s the trap:

Agent A finishes → hands task to Agent B
Agent B rejects → sends back to Agent A
Each agent resets its iteration counter

So technically, each agent is behaving correctly.

But globally?

Your system is stuck in a loop with zero real progress.
But every problem has solutions so , i am share solution -:

Solution 1: The Supervisor Pattern (Your System Needs a Boss)

Letting agents talk freely is like letting two interns review each other’s work endlessly.

You need structure.

Enter: The Supervisor Agent

Instead of peer-to-peer communication:

All tasks go through a central Supervisor
Agents don’t directly talk to each other

What the Supervisor Does:

Assigns tasks
Tracks global state
Monitors how often tasks bounce between agents

The Key Insight:

If a task keeps bouncing, it’s not progress—it’s a loop.

Practical Implementation (in Python)

Use a global state object (like_ TypedDict in LangGraph_)

What Happens Then:

Hard stop is triggered
Or escalation to human review
Or fallback logic kicks in

You’ve just turned chaos into controlled orchestration.

Solution 2: Detect “Semantic Loops” (The Sneaky Ones)

Not all loops are obvious.

Sometimes agents:

Rephrase the same idea
Change one variable
Rearrange wording

To your system, it looks different.
But in reality?

It’s the same output wearing a disguise.

The Smarter Approach: Semantic Similarity

Instead of comparing raw text, compare meaning.

How:

_- Store last few outputs as embeddings

Use cosine similarity to compare_

If similarity is extremely high:
one line and you solve your headache

*if cosine_similarity(current_output, last_output) > 0.98:
raise AgentLoopException("Semantic loop detected") *

Why This Works:

You’re no longer tracking what was said
You’re tracking what was meant

And that’s where real loops hide.

Solution 3: The Circuit Breaker (Protect Your Wallet)

Let’s be honest—this isn’t just a technical issue.

It’s a financial one.

In 2026, running AI systems without guardrails is like deploying code without logging.

You need a Circuit Breaker.
1. Token Budgeting

Assign limits per session:

Example: 100K tokens per workflow
If exceeded → terminate

2. Timeouts

Loops take time.

If a workflow runs longer than ~120 seconds:

It’s probably stuck
Kill it
Return the last best state

3. Fail Gracefully

Instead of crashing:

Return partial results
Add a warning
Log the loop

Users prefer imperfect answers over infinite waiting.

Bigger Picture: MAS = Microservices for AI

Think of Multi-Agent Systems like microservices.

They are:

Modular
Scalable
Powerful

But also:

Hard to debug
Easy to misconfigure
Prone to hidden loops

Without orchestration, they become chaos engines.

Final Takeaway

The real skill in AI engineering isn’t making agents that can think endlessly.

It’s designing systems that know:

When to stop thinking.
**
Because sometimes, the smartest move your AI can make…
is to stop arguing with itself**.

Kavach: Building a Real-Time Parametric Insurance System for the Gig Economy

Ayush Kumar — Tue, 24 Mar 2026 05:24:36 +0000

Why We Built This

Gig workers operate in one of the most unpredictable environments. A delivery rider facing a 48°C heatwave or sudden flooding doesn’t just have a “bad day”—they lose their entire day’s income.

Existing insurance systems don’t address this problem well:

Claims take days or weeks
Policies are expensive and rigid
Micro-duration risks (like a single day of extreme weather) are ignored

We wanted to design something fundamentally different:
a real-time, automated, low-cost insurance system that reacts instantly to environmental risk.

That’s how Kavach was born.

*What is Kavach?
*
Kavach is a parametric insurance platform designed specifically for gig workers.

Instead of manual claims, payouts are triggered automatically when predefined conditions are met.

Key Design Goals

Low cost: Affordable daily subscription model
Instant payouts: No claim filing or manual approval
Fraud-resistant: Hardware-backed verification
Scalable: Built on a modular MERN + AI architecture

System Overview

At a high level, Kavach works through three tightly coupled layers:

Weather Data → Risk Model → Fraud Detection → Payout Engine

+-------------------+ +---------------------+
| Weather API | -----> | Climate Oracle AI |
| (Temperature, etc)| | (Random Forest) |
+-------------------+ +----------+----------+
|
v
+--------+--------+
| GDI Calculator |
+--------+--------+
|
GDI > 0.85 → | Trigger
v
+-------------------+ +---------------------+
| Mobile Sensors | -----> | Sentry-AI |
| (Motion, Temp) | | (Fraud Detection) |
+-------------------+ +----------+----------+
|
v
+--------+--------+
| Risk Controller |
| (Node.js Backend)|
+--------+--------+
|
v
+--------+--------+
| Payout Engine |
| (UPI / Wallet) |
+------------------+

We call this the “Sword & Shield” architecture:

Sword: Detects real-world risk

Shield: Verifies the authenticity of the claim

⚔️ Sword (Risk Detection)

Weather Data → AI Model → GDI Score
|
v
Is Risk High?

                 ↓ YES

🛡️ Shield (Fraud Detection)

Sensor Data → Motion Check
→ Thermal Check
→ EV Filter
|
v
Is User Legit?

                 ↓ YES

💸 Payout Triggered Instantly

Layer 1: Climate Oracle (Risk Detection Engine)

We built a Random Forest model that processes real-time weather data from external APIs.

Inputs
Temperature
Humidity
Wind speed
Output

A computed score called the Gig Disruption Index (GDI).

GDI > 0.85 → Red Alert
Automatically flags a high-risk event
Why Random Forest?
Handles nonlinear relationships well
Robust against noisy environmental data
Works efficiently with tabular inputs

This layer answers:
👉 “Is the environment actually dangerous enough to disrupt work?”

Layer 2: Sentry-AI (Fraud Detection via Sensor Fusion)

Parametric systems are vulnerable to exploitation if not validated.
We addressed this with a sensor-driven verification layer.

Core Idea

Don’t just trust external data—verify the user’s physical context.

Signals Used

Accelerometer (Kinetic Jitter)
Detects motion patterns consistent with riding
Filters out idle or stationary devices
Battery Temperature (Thermal Correlation)
Compared with external temperature
Detects “indoor spoofing” (e.g., AC room fraud)
Edge Case Handling
EV-specific logic to avoid false positives from charging heat
Outcome
Only users who are:
Actually active
Physically exposed to conditions

…are eligible for payouts.

Layer 3: Risk Controller (Liquidity & Payout Engine)

The backend ensures the system remains financially stable while delivering instant payouts.

Responsibilities
Monitor liquidity pool in real time
Prioritize high-risk users during peak events
Prevent over-disbursement
Implementation
Built into a Node.js + Express service layer
Uses MongoDB for:
User risk profiles
Subscription tracking
Transaction logs Tech Stack Breakdown

Layer	Technology
Frontend	React.js (Web Sensor APIs)
Backend	Node.js + Express
Database	MongoDB
AI Engine	Python (Scikit-learn, .joblib)

Why This Stack?
MERN enables rapid prototyping and scalability
Python integrates seamlessly for ML inference
Web APIs allow direct hardware signal capture

Phase 1: What We Achieved
Built a working end-to-end MERN prototype
Implemented real-time sensor data ingestion
Integrated dual AI layers (risk + fraud detection)
Validated system behavior against spoofing scenarios

Key Engineering Challenges
1. Bridging Web Apps with Hardware Signals

Accessing reliable sensor data in a browser environment required careful handling of:

Permissions
Data sampling rates
Noise filtering

2. Synchronizing AI Pipelines

We needed a clean handshake between:

Weather-based risk scoring
Sensor-based validation Ensuring both layers agreed before triggering payouts was critical.

3. Designing for Real-Time Decisions

The system had to:

Process inputs quickly
Avoid false positives
Trigger payouts without delay

What’s Next (Phase 2)

We’re moving toward a mobile-first architecture.

Planned Improvements

Native mobile app for better sensor fidelity
Background telemetry collection
One-tap UPI payouts (<60 seconds target)

This will significantly improve reliability and user experience.

Final Thoughts

Kavach is an attempt to rethink insurance from the ground up.
By combining:

Real-time environmental data
On-device sensor validation
Automated payouts

…we’re building a system that aligns with how gig workers actually live and work.

The goal isn’t just innovation—it’s impact.