DEV Community: Emani Sai Shanmukha Srinivas

Who Reviews the Reviewers? Benchmarking AI Agents on PR Audits

Emani Sai Shanmukha Srinivas — Fri, 09 Oct 2026 14:30:56 +0000

What I Benchmarked
I benchmarked the ability of LLMs to conduct automated pull request (PR) auditing without falling into the "helpful hallucination" trap.

When building and orchestrating AI workflows for code reviews, a recurring failure mode constantly pops up: models often hallucinate phantom security flaws or logic errors in perfectly clean code just to have something to say. It’s as if the model feels obligated to leave a comment to prove it did the work.

I set out to measure this explicitly. I created a dataset of 100 PRs: 50 containing subtle, real-world vulnerabilities (like race conditions, improper state management, or injection risks) and 50 perfectly optimized, clean code snippets. The goal wasn't just to see if they could catch real bugs, but to measure their false-positive rate—quantifying exactly how often these agents "cry wolf" and hallucinate an issue just to justify a "Request Changes" review.

Models Tested
I ran this benchmark against Gemini 1.5 Pro, GPT-4o, Claude 3.5 Sonnet, and Llama 3.1 70B.

I chose this lineup because they represent the current frontier of models typically selected for multi-agent developer tools and automated CI/CD pipelines. Since my day-to-day involves integrating agentic AI into GitHub pipelines using orchestration platforms like n8n and LangChain, I needed to see how these specific models behave when acting as autonomous reviewers rather than just conversational coding assistants. I wanted to see which model is actually safe to trust with a repository's main branch without overwhelming developers with fake alerts.

Findings
The results completely changed how I approach agent evaluation and orchestration.

The "Yes-Man" Reviewer: Most models exhibited a strong bias toward leaving a critical comment. While Claude 3.5 Sonnet and Gemini 1.5 Pro were exceptionally accurate at identifying genuine security flaws, they still occasionally nitpicked clean code. Llama 3.1 70B struggled the most with false positives, frequently flagging standard, clean implementations as problematic.

Context Window Distraction: When I padded the PRs with irrelevant boilerplate files (simulating a messy, real-world pull request), the models' accuracy in spotting the actual bug dropped significantly. This proved that simply passing an entire repository's context into an agent drastically degrades its auditing precision.

The Zero-Shot Penalty: Prompting models with a simple "Review this code" led to a 40% higher hallucination rate compared to providing a strict system prompt like, "Only flag critical security or logical errors; if the code is clean, output 'APPROVE'."

What I'd measure next: Moving forward, I want to benchmark a multi-agent debate architecture—having an "Auditor" agent flag issues and a separate "Defender" agent verify them against the actual codebase before the webhook ever posts a comment to the developers.

Pathfinder AI: An Offline AR Trekking Guide Powered by Open-Source AI

Emani Sai Shanmukha Srinivas — Tue, 06 Oct 2026 05:22:14 +0000

What I Built
Pathfinder AI is an offline, wearable AR trekking companion built to keep hikers' eyes on the trail and off their phones.

Instead of constantly stopping to pull out a GPS map or a field guide, Pathfinder AI uses a lightweight heads-up display (HUD) to project non-intrusive directional arrows, trail edge boundaries, and flora/fauna identification directly into your field of view. It’s designed for backcountry hikers, trail runners, and foragers who want to stay fully immersed in nature while safely navigating deep-wilderness areas where cell service doesn't exist.

How I Built It
The core challenge was building an intelligent vision and reasoning system that could run entirely on battery-powered edge hardware (like a Raspberry Pi) without any internet connection.

Local Computer Vision: I used YOLOv8 optimized for edge devices to process the live camera feed. It’s fine-tuned to detect trail edges, natural obstacles (like fallen branches or loose rocks), and local wildlife.

Open-Weight Reasoning: I deployed a quantized open-weight model (Llama 3.2 1B/3B) running locally. When the vision model detects something interesting—like an unfamiliar bird or a split in the trail—the LLM contextualizes it.

Agent Orchestration: Everything is tied together using LangChain and Python. The agent takes the user's pre-loaded GPX route and the real-time YOLOv8 bounding boxes, and decides when to push a minimal text or arrow overlay to the AR display to keep the user on track.

Why Does Open Innovation Matter?
When you are five miles deep into a mountain pass, a closed-source cloud API is completely useless because you have zero signal.

Open innovation is the only reason this project is possible. Running open-weight models and open-source vision frameworks locally means the system works flawlessly offline. It also means total privacy: continuous camera feeds and GPS coordinates are processed on the device and never sent to a corporate server. Finally, having access to open model weights allowed me to strip the AI down to its bare essentials so it could actually run smoothly on portable hardware without burning through the battery.

Pseudo-Compiler: Vibe-Coding an AI that Translates Pseudocode to Executable Scripts

Emani Sai Shanmukha Srinivas — Sat, 03 Oct 2026 17:58:18 +0000

What I Built
I built Pseudo-Compiler, an AI-powered translation engine that acts as a real-time compiler for pseudocode. It allows users to write logic in plain, structured English (or any loose pseudocode format) and automatically compiles it into working Python or JavaScript.

Rather than just being a wrapper around an LLM API, this app uses Sanity as the core engine for state management and execution workflows. By treating the compilation process as a data pipeline, the app utilizes Sanity Workflows to manage the lifecycle of a script: from Drafting (writing pseudocode), to Compiling (agentic generation of code), to Review (human-in-the-loop validation), and finally Approved for Execution.

It is designed for beginners learning algorithm logic without getting bogged down by syntax, and for developers who want to rapidly prototype business logic before writing boilerplate.

My Build Process
I used Cursor as my AI-native IDE alongside a Next.js (App Router) frontend and a Sanity backend. My goal was to see how far I could push "vibe-coding" to handle not just UI generation, but complex data state transitions using Sanity's newer features.

The Prompting Journey:
I started with a broad structural prompt:

"Scaffold a Next.js app with a split-pane code editor. The left side accepts plain text pseudocode, and the right side displays read-only code. Connect this to a Sanity backend where every new snippet is saved as a document with a draft status."

Cursor nailed the UI using Tailwind and Monaco Editor within minutes, but the data modeling required more explicit steering.

Where the Model Got Stuck:
Initially, the AI tried to put the entire LLM "compilation" call inside a frontend React component, bypassing Sanity entirely. It just wanted to fetch the OpenAI API on the client side.

The Course Correction & Hitting the Bonus Objectives:
I stopped the IDE and pivoted to explicitly prompting for Sanity Workflows and a background agent.

"Refactor this. Do not call the LLM from the frontend. Instead, when the user clicks 'Compile', save the pseudocode to Sanity and update the document's state to Pending Compilation. Write a Sanity webhook handler that listens for this state, triggers the AI agent to write the code, saves the compiled code back to the document, and transitions the workflow state to Needs Human Review."

This worked brilliantly. By modeling the compilation process as data next to the content, I achieved the "Workflows" bonus objective. The Sanity Studio now acts as the central control room:

Agent Handoff: An external API (Next.js route) acts as the autonomous agent, listening to Sanity webhooks, compiling the code, and pushing it back.

Human Approval: Before any code can be executed in the custom App SDK dashboard, a user must open Sanity Studio, review the agent's code, and click "Approve".

I also utilized the App SDK to build a custom real-time dashboard on top of the content. Instead of a read-only blog frontend, the frontend acts as an execution environment that pulls Approved scripts directly from the Sanity dataset and allows users to run them in a sandboxed browser environment, logging the console outputs back into a RunHistory array on the Sanity document.

Schema Highlights: The primary document type is pseudoScript, featuring fields for rawPseudocode, targetLanguage, compiledCode, and executionLogs.

LocalMock: Building a 100% Offline, Privacy-First AI Interviewer for My Friend

Emani Sai Shanmukha Srinivas — Fri, 02 Oct 2026 19:06:15 +0000

What I Built
I built LocalMock, a completely offline, multi-agent technical interview practice partner for my friend and frequent project collaborator, Gayatri Akalwadi.

Gayatri and I often build AI tools together, and she is currently gearing up for intense Machine Learning Engineer interviews. She wanted a practice partner that could grill her on complex RAG architectures and MLOps pipelines. However, she had two major concerns: she didn't want to upload her personal resume and detailed performance history to a closed-source cloud model, and she didn't want to worry about racking up API usage costs during marathon 4-hour practice sessions.

LocalMock solves this by providing a conversational, rapid-fire mock interviewer that runs entirely on her laptop. When she handed over her resume, the system dynamically generated a custom interview loop, adjusting the difficulty based on her real-time answers—all without a single byte of data leaving her local machine. When I installed it for her, she said, "This is exactly what I needed. I can finally mess up and learn without feeling like a tech giant is logging my mistakes."

How I Built It
The core of LocalMock is entirely driven by open-source AI technologies:

Open-Weight Models: I used Ollama to serve open-weight models locally. The application uses Llama-3.2-3B for rapid, low-latency conversational replies and Gemma-2-9B for deep, end-of-session feedback and grading.

Agent Framework: I built the orchestration logic using the open-source LangGraph framework. It features a multi-agent setup: a "Technical Interviewer" agent that tracks the conversation state and poses questions, and a "Critique" agent that silently evaluates the accuracy of the user's answers.

Local RAG: I utilized ChromaDB (open-source vector database) and local embeddings to process Gayatri's resume and past project files, allowing the Interviewer agent to ask highly contextual questions (e.g., "I see you used Databricks here—how would you handle streaming data latency in that setup?").

Frontend: A lightweight React SPA that interfaces with the local Python backend.

Why Does Open Innovation Matter?
For this project, open innovation wasn't just a feature; it was the entire foundation of the solution:

Absolute Data Privacy: Resumes contain highly personal information (phone numbers, addresses, work histories). By using open-weight models and local inference, Gayatri's data stays 100% on her hardware. A closed API would have required trusting a third-party server with her personal life.

Zero Operating Cost: Running continuous back-and-forth multi-agent loops with a cloud provider would get expensive fast. With local models, she can practice for 10 hours a day for free.

Hardware Freedom: Open innovation meant I could configure the agents to run smoothly on the hardware she already owns, keeping the memory footprint manageable without relying on an internet connection.

Prize Categories
Open Source AI Vanguard

Local Inference Champion

Creative Use of Agent Frameworks

Prapatti AI: Restoring Digital Independence for the Disabled with Gemini-Powered Navigation

Emani Sai Shanmukha Srinivas — Sun, 06 Sep 2026 18:07:28 +0000

Modern digital infrastructure is fundamentally broken for millions of people. Despite strict global regulations, 95% to 98% of the world's top websites still fail basic web accessibility standards. For users with visual, motor, or cognitive disabilities, everyday web navigation is full of insurmountable barriers: missing descriptive alt tags for screen readers, broken keyboard navigation layouts, and dense multi-step checkouts that induce heavy cognitive and physical fatigue. In the spirit of generosity and inclusion for International Day of Charity, I built Prapatti AI: AI Navigation Tool for the Disabled.Prapatti AI is an intelligent desktop intermediary that restores digital autonomy to physically challenged individuals. Instead of forcing users to adapt to rigid screen readers or brittle keyboard shortcuts, Prapatti AI uses multimodal vision-language models to "see" and interpret desktop interface layouts directly. By connecting custom physical hardware sensors (like switch controls, eye-tracking systems, or adaptive joysticks) to Gemini's visual reasoning engine, Prapatti AI converts simple sensor gestures into complete, automated desktop interactions—bypassing non-compliant HTML, removing popups, and filling multi-step forms automatically.
demo.comScreenshot Preview:Prapatti AI parsing screen coordinates in real time to aid user navigation.

How I Built ItPrapatti AI operates on a local Sense-Reason-Act loop running directly on the user's desktop:Sense: Custom hardware sensor telemetry (e.g., switch triggers or eye-gaze holds) is ingested via lightweight Python serial listeners.Reason (Google AI Studio & Gemini): When a user initiates a goal, the client captures the desktop state and sends the raw screen image along with the user's intent to Gemini via Google AI Studio API calls.Act: Gemini analyzes the visual layout—identifying UI elements, buttons, and form fields purely by visual inspection—and returns structured coordinate commands. The Python execution handler (Playwright / PyAutoGUI) then translates these coordinates into desktop mouse clicks, typing, or scrolling actions.Architecture HighlightsVisual UI Layout Parsing: By leveraging visual capabilities instead of DOM parsing, Prapatti AI works on inaccessible websites, desktop applications, and legacy software that lack proper ARIA accessibility tags.Autonomous Friction Reduction: The AI engine proactively detects modal popups, cookie consent banners, and multi-step inputs, resolving them autonomously so the user experiences minimal cognitive drain.Deterministic Coordinate Outputs: Structured JSON schemas and zero-temperature prompt configs ensure pinpoint accuracy when mapping click targets on dynamic screen resolutions.JSON{
"action": "click",
"coordinates": { "x": 1650, "y": 820 },
"confidence_score": 0.98,
"reason": "Dismissing cookie consent banner to clear navigation path."
}
Prize CategoriesBest Use of Google AIPrapatti AI relies entirely on Google AI Studio and Gemini as its core brain:Multimodal Visual Reasoning: We prototyped and optimized the agent system instructions in Google AI Studio using the gemini-3.8-flash model. Gemini's high-speed visual token processing enables real-time analysis of full-desktop screenshots.Computer Use Integration: By incorporating Gemini's spatial coordinate estimation and Computer Use framework, Prapatti AI accurately locates small buttons, forms, and navigation controls across varying display resolutions without requiring pre-labeled training data.

Smashing eBPF Buffer Leaks: Achieving Zero-Drop Telemetry with Python & Google AI Studio

Emani Sai Shanmukha Srinivas — Fri, 21 Aug 2026 19:08:42 +0000

Smashing eBPF Buffer Leaks: Achieving Zero-Drop Telemetry with Python & Google AI Studio

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

Project Overview

VirgilFlow is a lightweight, low-overhead system infrastructure defense tool written in Python and eBPF (using bcc / libbpf). It monitors kernel-level ring buffers to trace agent-to-agent IPC communications, detecting unauthorized syscall hijacking or abnormal telemetry streams across autonomous infrastructure nodes in real-time.

Bug Fix or Performance Improvement

Under high packet delivery rates, the eBPF kernel space probe failed to flush allocated ring-buffer entries properly. This created a kernel socket buffer queue buildup (sk_buff), causing kernel thread lockups and dropping up to 28% of telemetry traces sent to the Python user-space daemon.

The goal was to eliminate ring-buffer drops, prevent socket descriptor leakage, and maintain zero packet loss at rates exceeding 100,000 events/sec.

Code

PR Link: Fix kernel ring-buffer leakage and optimize user-space polling #18

My Improvements

We resolved this performance issue using Google AI Studio to refactor our kernel ring buffer consumer and Python async polling loop.

Prompt Used in Google AI Studio

We fed our eBPF C program and Python consumer binding files directly into Google AI Studio (using Gemini 1.5 Pro) with the following instruction:

System Prompt / User Query:
"Our eBPF ring buffer consumer drops kernel events under high throughput (>100k ops/sec). Analyze the Python asyncio event loop and ring_buffer.poll() invocation below. Identify where the buffer head pointer falls behind kernel tail producers, and provide an updated implementation using continuous bulk consumption with zero-copy deserialization."

Code Fix

Google AI Studio flagged that calling poll() with a tiny timeout inside an un-batched asyncio loop introduced event-loop context switching latency, causing the kernel's ring buffer head to lag behind production.


python
# BEFORE (Buggy: High Context Switching & Dropped Events)
import asyncio
import sentry_sdk

async def consume_telemetry_events(bpf_ctx):
    while True:
        # Polling one-by-one inside the event loop introduced heavy overhead
        try:
            bpf_ctx.ring_buffer_poll(timeout=10)
        except Exception as e:
            sentry_sdk.capture_exception(e)
        await asyncio.sleep(0.01)

# AFTER (Fixed: Bulk Drainage with Batched Buffer Draining)
import asyncio
import sentry_sdk

async def consume_telemetry_events(bpf_ctx):
    # Consume in high-frequency batch sweeps to prevent kernel queue backup
    while True:
        # Consume available ring buffer events in bulk without yielding mid-drain
        events_processed = bpf_ctx.ring_buffer_consume()

        if events_processed == 0:
            await asyncio.sleep(0.0005)  # 500 microsecond micro-sleep when idle
            continue

        # Process batch items in user-space using memoryview (zero-copy)
        for raw_event in bpf_ctx.get_event_batch():
            process_kernel_event_zero_copy(raw_event)

Best Use of SentryAgent Tracing & Logs:
Captured real-time telemetry metrics using sentry-sdk. Logged kernel ring buffer overflow events with trace IDs matching system process execution paths.Error 

Monitoring: Configured Sentry to alert whenever the eBPF map submission returned -ENOBUFS (Buffer Space Unavailable).

Metric Verification: Tracked event ingestion latency before and after the fix:

![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/om8mekb495yxuo7a6z8o.png)

Best Use of Google AI

Context Window Utilization: We attached the eBPF C kernel bindings (bpf/tracer.bpf.c) and the Python asyncio runtime parser (src/telemetry/consumer.py) directly in Google AI Studio.

Gemini 1.5 Pro Analysis: Used Google AI Studio's large context window to evaluate full system memory layouts between kernel ring buffers and Python object allocation boundaries.

Automated Benchmarking Script: Google AI Studio generated a synthetic load-generation script using Python ctypes and bcc bindings to stress-test socket capacity and verify zero drop rates under heavy system load.

The Ghost in the Graph: Catching Unbounded Recursion & Taint Drift with Gemini 1.5 Pro

Emani Sai Shanmukha Srinivas — Fri, 21 Aug 2026 19:05:41 +0000

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

Project Overview

FluxTrace is an open-source real-time financial security engine designed to trace illicit funds across graph databases (Neo4j) using Dynamic Taint Scores. It ingests thousands of dynamic financial events per second, mapping transaction topologies and assigning risk scores to connected wallets to expose complex money laundering schemes before funds can be laundered through mixers.

Bug Fix or Performance Improvement

During high-throughput synthetic testing, our telemetry pipeline began silently degrading under dense cyclic transaction topologies (e.g., wallet circular routing or "smurfing" rings).

The issues manifested as:

Unbounded Memory Accumulation: Worker processes experienced exponential memory growth $O(2^N)$, triggering Out-Of-Memory (OOM) kills during heavy network loops.
Dynamic Taint Drift: Taint scores propagated continuously across closed-loop graph networks, inflating risk values past valid bounds ($> 1.0$) and producing false positives.

[Transaction Event Ingest] ---> [Recursive Taint Engine]
│
┌─────────────────────┴─────────────────────┐
▼ ▼
[Cyclic Graph Detected] [Unbounded Stack Growth]
│ │
▼ ▼
(Infinite Propagation) (OOM Worker Crash)

Code

Fix PR: Fix graph cycle memory leak and restrict taint score bounding #42

My Improvements

We diagnosed the issue by loading a 2M-node cyclic graph dataset into Google AI Studio alongside our recursive graph traversal engine using Gemini 1.5 Pro.

Root Cause Prompting (Simulated in Google AI Studio)

To isolate the exact stack behavior, we prompted Gemini 1.5 Pro in Google AI Studio with our recursive execution path:

System Prompt / User Query:
"Analyze the Python graph traversal function below. In cyclic topologies (A -> B -> C -> A), worker memory escalates exponentially, and floating-point taint scores exceed 1.0. Identify why cycle detection fails to halt memory growth during high-concurrency event loops, and refactor the method using memoization and a strictly bounded iterative stack."

Technical Solution

Google AI Studio identified that our visited-node cache was scoped locally to individual recursive calls rather than globally across the propagation path.

We refactored the dynamic calculation from recursive execution to an iterative Breadth-First Traversal (BFS) pattern with explicit cycle bounds and decay limits:


python
# BEFORE (Buggy Recursive Implementation)
def propagate_taint_score(node_id, current_score, visited=None):
    if visited is None:
        visited = set()
    visited.add(node_id) # Bug: Scoped locally in recursive chain, fails in cyclic networks

    neighbors = get_connected_wallets(node_id)
    for neighbor in neighbors:
        new_score = current_score * DECAY_FACTOR
        # Unbounded recursion on cyclic paths:
        propagate_taint_score(neighbor.id, new_score, visited)
# AFTER (Optimized Bounded Iterative Stack)
from collections import deque

def propagate_taint_score_iterative(start_node_id: str, initial_score: float, max_depth: int = 10) -> None:
    queue = deque([(start_node_id, initial_score, 0)])
    visited_state = {}  # Map node_id -> max_seen_score

    while queue:
        curr_node, curr_score, depth = queue.popleft()

        if depth >= max_depth or curr_score < 0.01:
            continue

        # Prune redundant recalculations if node was processed with a higher score
        if curr_node in visited_state and visited_state[curr_node] >= curr_score:
            continue

        visited_state[curr_node] = curr_score

        # Enforce clamp bound: max taint value is 1.0
        clamped_score = min(curr_score, 1.0)
        update_wallet_risk(curr_node, clamped_score)

        for neighbor in get_connected_wallets(curr_node):
            next_score = clamped_score * DECAY_FACTOR
            queue.append((neighbor.id, next_score, depth + 1))

Best Use of Sentry
We leveraged Sentry Performance Monitoring and Distributed Tracing to locate and confirm the fix:

Custom Span Profiling: Created Sentry spans (sentry_sdk.start_span(op="taint.propagation")) to record execution duration and stack depth across graph nodes.

Memory & Out-of-Memory Tracking: Monitored worker RAM trends via Sentry's profile visualizer to confirm memory usage stabilized at a flat ~140 MB footprint down from exponential spikes >4 GB.

Python
import sentry_sdk

def process_transaction_event(event):
    with sentry_sdk.start_span(op="graph.taint_analysis", description="Process cyclic taint propagation"):
        propagate_taint_score_iterative(event.sender, event.initial_risk)

Crafting Hot Filter Kaapi in Pure CSS: Gradients, Steam Engines & Hardware Acceleration

Emani Sai Shanmukha Srinivas — Thu, 13 Aug 2026 13:39:30 +0000

Inspiration
When you're deep in the trenches of late-night architecture sessions, debugging kernel probes, or prototyping real-time agentic workflows, comfort doesn't come from a fancy meal—it comes in a steaming brass tumbler.

My ultimate comfort food is South Indian Filter Kaapi (Coffee) paired with a golden, crispy Masala Dosa. There is something undeniably grounding about the rich aroma of chicory-infused coffee frothed to perfection in a traditional brass dabara set. It’s the official fuel for late-night builds and early-morning deployments.

For this challenge, I wanted to capture that warmth entirely out of pure, hand-crafted CSS.

Live Preview Highlights:

☕ Procedural Coffee Froth: Multi-layered gradient micro-bubbles.

✨ Metallic Brass Finish: Real-time angular lighting using dynamic conic & linear gradients.

♨️ GPU-Accelerated Steam: Continuous ambient heat animation using CSS keyframes and hardware-accelerated blur transforms.

Journey
As someone who spends most of their time in system architecture and high-performance engineering, tackling pure CSS art felt like designing a constrained micro-kernel—every property had to serve a precise geometric or optical purpose.

Metallic Refraction with Multi-Stop Gradients Recreating the signature golden-brass sheen of the dabara (bowl) and tumbler without external textures required layered, multi-stop conic-gradient() and angled linear-gradient() overlays.

CSS
.brass-tumbler {
background: conic-gradient(
from 180deg at 50% 50%,
#d4af37 0deg,
#fff3a8 45deg,
#aa7c11 120deg,
#f3e5ab 220deg,
#8b6508 300deg,
#d4af37 360deg
);
box-shadow: inset 0 -8px 12px rgba(0, 0, 0, 0.35);
}

The Froth Engine
To give the coffee its classic, aerated top froth (degree coffee style), I avoided static images entirely. Instead, I combined stacked radial-gradient() patterns with varying opacities and subtle box-shadow diffusion to simulate organic micro-bubbles clinging to the tumbler rim.
Hardware-Accelerated Steam Animation
To keep rendering smooth at 60 FPS, the rising steam effects utilize CSS @keyframes restricted strictly to transform and opacity properties, leveraging will-change to offload paint cycles to the GPU compositor:

CSS
@keyframes steam-rise {
0% {
transform: translateY(0) scaleX(0.8);
opacity: 0;
}
50% {
opacity: 0.4;
filter: blur(8px);
}
100% {
transform: translateY(-60px) scaleX(1.4);
opacity: 0;
filter: blur(14px);
}
}

.steam-particle {
will-change: transform, opacity;
animation: steam-rise 3.5s infinite ease-out;
}
Key Takeaways & What's Next
CSS as an Engine: Treating shadow layers like render passes allows for surprisingly deep 3D illusions using flat 2D DOM elements.

Next Steps: I plan to add subtle dark/light mode toggles to simulate a late-night study desk aesthetic versus a bright morning cafe setup!

VocationalVerse – AI Job Matchmake

Emani Sai Shanmukha Srinivas — Sun, 12 Jul 2026 06:38:27 +0000

What I Built
I built VocationalVerse, an AI-driven career architect designed to turn "passion" from a vague concept into a tangible career trajectory.

Most career platforms rely on static resumes, but VocationalVerse treats career mapping as a dynamic graph problem. By analyzing a user's natural talents, technical proficiencies, and deep-seated interests, the agent conducts a Socratic dialogue to map the user’s "Passion DNA" to real-world job roles and emerging industry verticals. Instead of just suggesting titles, it builds a personalized roadmap, identifying skill gaps and suggesting relevant micro-projects—like the ones found in our own hackathon culture—to bridge them.

Demo (My baseline code)

import os
from google import genai
from google.genai import types

Initialize the Gemini Client

Expects GEMINI_API_KEY environment variable to be set

client = genai.Client()

SYSTEM_INSTRUCTION = """
You are the VocationalVerse Career Architect. Your goal is to help users discover their ideal career path by analyzing their natural talents, raw interests, and passions.
Follow these execution guidelines:

Conduct a Socratic dialogue. Do not ask a checklist of questions all at once; ask one insightful, open-ended question at a time.
Steer clear of traditional corporate keywords. Focus on what they love building, fixing, or organizing during their free time.
Once you have sufficient data (typically 3-4 turns), synthesize their 'Passion DNA' and output a structured roadmap containing:
- Match Profile: Why this fits their core drivers.
- Target Verticals: Emerging fields where this passion is highly valued.
- Skill Gap Action Plan: 2 actionable micro-projects they can build right away to gain experience. """

def start_career_session():
"""Initializes a conversational session with specialized system instructions."""
chat = client.chats.create(
model="gemini-2.5-flash",
config=types.GenerateContentConfig(
system_instruction=SYSTEM_INSTRUCTION,
temperature=0.7,
)
)

# Send an initial ping to spark the conversation organically
initial_prompt = "Hello! Let's find your true path. To kick things off, what is a side project, hobby, or complex problem you've worked on recently purely because you wanted to, not because you had to?"
response = chat.send_message(initial_prompt)
print(f"VocationalVerse: {response.text}\n")
return chat

def continue_conversation(chat_session, user_input):
"""Passes the user's input down to the active chat session context."""
response = chat_session.send_message(user_input)
return response.text

--- Example Run ---

if name == "main":
# 1. Boot up the conversational agent
session = start_career_session()

# 2. Simulate user interaction loop
sample_user_answers = [
    "I love configuring home automation scripts using Home Assistant. I spent all weekend making my lights sync perfectly with my music and circadian rhythm.",
    "I enjoy tinkering with hardware, but honestly, breaking down the complex configurations into simple automation logic rules is what kept me up until 3 AM.",
    "I don't have a formal CS degree, just a passion for making disparate systems talk to each other cleanly without lagging."
]

for answer in sample_user_answers:
    print(f"User: {answer}")
    reply = continue_conversation(session, answer)
    print(f"VocationalVerse: {reply}\n")

How I Built It
The architecture relies on a Google AI (Gemini) core to manage the complex, multi-turn dialogue required to uncover latent interests.

Natural Language Core: I utilized the Gemini API with a custom system instruction that forces the model to move beyond surface-level keyword matching. It assesses a user’s "Interest Graph" by analyzing how they describe their problem-solving processes and creative outputs.

Contextual Memory: To ensure the advice is practical and not generic, the agent references a structured internal knowledge base of high-demand skill clusters.

Infrastructure: The application is built using a serverless-first approach to keep latency low. I leveraged the same logic patterns used in my previous triage-agent projects, ensuring the chat flow is robust and capable of handling complex, multi-domain queries efficiently.

Prize Categories
Best Use of Google AI: The project is powered entirely by Gemini, using its reasoning capabilities to synthesize unstructured user insights into structured career pathways and project-based learning recommendations.

Aetheria: Chronicles of the Party

Emani Sai Shanmukha Srinivas — Sun, 07 Jun 2026 18:27:46 +0000

What I Built
Aetheria is a visual, AI-driven tabletop roleplaying game (RPG) designed to simulate the experience of playing Dungeons & Dragons with a virtually infinite, dynamic Dungeon Master. By combining deep generative narrative with on-the-fly cinematic image synthesis, the application creates a continuous, immersive, and highly responsive adventure.

Key Features
Dynamic Campaign Generation: The game begins by randomly selecting from over 50 unique scenarios (ranging from steampunk fantasy to Eldritch horror escapes) and architectural visual styles (e.g., Studio Ghibli cel-shaded, gritty realistic dark fantasy). No two adventures start exactly the same way.

Intelligent AI Dungeon Master: Powered by an advanced language model, the "DM" evaluates the environmental context, party composition, character stats, the chosen action, and the outcome of a 20-sided dice roll to yield contextual story events, character dialogues, and branching decision paths.

Flexible Party Modes: * Local Multiplayer: Build a custom party of heroes and pass the device with friends.

Solo vs. The World: Play as a single human protagonist alongside three fully autonomous AI-driven companions who take their own unprompted turns.

Freedom of Action: Players aren’t restricted to predefined buttons. You can select one of the DM's contextual "Suggested Paths" or type completely custom actions—from attempting to barter with an ancient sphinx to charging recklessly at an undead giant.

Cinematic Visual Continuity: With every story beat, the application generates a stunning 16:9 cinematic image representing the exact moment and location in the game. It uses previous scene descriptions as context to maintain environmental consistency turn-to-turn.

Immersive Physics-Based Dice: Taking action summons a highly polished, animated 3D-simulated 20-sided die using dynamic lighting, tumbling physics, and magic circle particle effects.

Journey Map & Persistence: The application actively auto-saves every campaign state locally. Players can abandon, revisit, resume, or delete any ongoing adventure from their "Journey Map" hub.

Image Demo

Enjoy this video walk-through demonstrating party creation, a dynamic combat encounter with an unpredictable D20 roll, and the real-time generation of our cinematic environment!

Code
https://github.com/Sai-Emani25/Atheria

How I Built It
The application is built as a completely serverless, client-side React SPA leveraging modern browser APIs and Google's Gemini SDK for its backend logic.

Frontend Core & UI/UX Framework: React 19 + TypeScript. Chosen for strict type safety over complex entity management (GameState, Player records, classes).

Build Tool: Vite, configured for high-performance module bundling and seamless local development.

Styling: Tailwind CSS. The app features a custom design system (relying heavily on negative space, absolute positioning, glow filters, and z-index layering) without writing raw CSS. It leverages precise typographic selections including the Cinzel (serif/fantasy context), Spectral, and Inter fonts.

Animation System: motion/react (Framer Motion). This drives the physics, scaling, rotations, and staggered entrance timings. The DiceRoller component specifically utilizes complex keyframe manipulation (rotate: [0, -720, -710, -720]) and AnimatePresence to render a realistic, weighty physical die tumbling across the screen.

Generative AI Engine (The "Backend") Aetheria essentially uses Google's foundational models as its game engine, integrated via the @google/genai TypeScript SDK:

[User Action + D20 Roll]
│
▼
┌────────────────────────────────────────┐
│ Gemini 3.1 Pro (Narrative Engine) │ ──► Generates Story & Visual Prompt
└────────────────────────────────────────┘
│
▼
┌────────────────────────────────────────┐
│ Gemini 2.5 Flash Image (Visual Engine)│ ──► Generates 16:9 Cinematic Image
└────────────────────────────────────────┘

Narrative Engine (Gemini 3.1 Pro Preview): * Structured Output (JSON Mode): The system relies on strict JSON schema enforcing. When a player rolls, the DM passes the complete contextual state (party health, previous locations, the dice roll, user intent) into Gemini 3.1 Pro. The model is constrained to return a heavily typed JSON object containing the narrative update, stat modifiers (damage/healing), and exactly 3-4 string suggestions for the next turn.

Prompt Engineering: The DM is strictly instructed to keep dialogue punchy and respond to the specific weight of the D20 roll (where 1 is catastrophic and 20 is miraculous).

Visual Engine (Gemini 2.5 Flash Image): * The narrative engine generates a purely descriptive "Visual Prompt" representing the outcome. This text is piped into the Gemini Flash image model.

Continuity Injection: The prompt is dynamically wrapped with the campaign's randomly selected art style, the list of current heroes in the room, and the previous image prompt to ensure the model doesn't spontaneously shift the setting or lighting from one frame to the next.

The model returns a raw base64 image data payload, which React renders natively without round-tripping to cloud storage bins to keep latency incredibly low.

State Management & Persistence React Context & Hooks: Standard useState orchestrates the monolithic GameState object, ensuring single-source-of-truth rendering.

Local Storage Sync: Given the complexity of the object traversing (narrative history, gold, stat updates, massive base64 images), the component intercepts changes using useEffect and serializes the active states into localStorage. The loadJourneys logic scans the native browser storage for keys matching aetheria_journey_* to reconstruct the complete Journey Map grid.

Prize Category
Best Google AI Usage: Aetheria showcases the depth of the @google/genai SDK by orchestrating a dual-model pipeline entirely on the client side. By leveraging Gemini 3.1 Pro's strict JSON mode for deterministic state mechanics alongside Gemini 2.5 Flash Image's contextually aware visual synthesis, the application transforms a large language model into a fully capable, real-time procedural game engine.

Best Ode to Alan Turing: Aetheria explores the boundary of machine intelligence and human-like creativity. By tasking the AI with acting as a dynamic Dungeon Master—a role traditionally requiring immense empathy, improvisational storytelling, and rule enforcement—the game stands as a modern testament to the Turing test, creating a deeply convincing, autonomous companion for human players.

From an Abandoned To-Do App to a Smart Productivity Engine: Upgrading Taskr into Solomon's Taskr

Emani Sai Shanmukha Srinivas — Fri, 05 Jun 2026 18:41:19 +0000

What I Built : (https://github.com/Sai-Emani25/Solomon-s-Taskr)
I transformed my initial, bare-bones task management application, Taskr, into Solomon's Taskr—a significantly smarter, more robust productivity platform.

The original project started as a standard way to log to-dos, but it lacked the intelligence to actually help manage time or prioritize effectively. With Solomon's Taskr, I wanted to build a system that doesn't just store data, but actively assists the user. Building this project means a lot to me because it represents a leap from writing basic applications to architecting intelligent, dynamic systems that solve real-world workflow bottlenecks.

Demo
Link to Final Repository:https://github.com/Sai-Emani25/Solomon-s-Taskr
Link to Original Repository:https://github.com/Sai-Emani25/Taskr

(Here is a quick walkthrough of Solomon's Taskr in action!)

The Comeback Story
The original Taskr project had been sitting in my repositories, unfinished and gathering dust. It was a classic case of starting a project with good intentions but abandoning it once the basic structure was complete. It could create, read, update, and delete tasks, but that was it.

For the Finish-Up-A-Thon, I decided to completely resurrect and overhaul it. Here are the key changes and implementations that turned it into Solomon's Taskr:

Complete Codebase Refactoring: I stripped down the old, inefficient logic and rebuilt the architecture to be highly scalable and maintainable.

Intelligent Prioritization ("The Solomon Touch"): I integrated smart features to help organize and prioritize tasks rather than just listing them chronologically. (Note: If you integrated Gemini API or LLMs here for smart tagging, explicitly mention it!)

Enhanced UI/UX: I moved away from the clunky, basic interface of the original Taskr and implemented a clean, responsive dashboard that provides a real-time overview of pending and completed tasks.

Optimized Data Handling: I refined how the application processes and stores data under the hood, making the transition between states and the retrieval of task history lightning-fast.

My Experience with GitHub Copilot
GitHub Copilot was an absolute game-changer for this comeback story. When reviving an old codebase, half the battle is deciphering what your past self wrote. Copilot helped me speed through the refactoring process by instantly suggesting optimized logic for outdated functions.

Specifically, it accelerated my workflow when I was building out the new, complex features for Solomon's Taskr. Instead of getting bogged down writing boilerplate code for API integrations and data structures, Copilot anticipated my needs, allowing me to focus entirely on the core logic and the high-level architecture of the application. It turned hours of debugging and syntax-checking into a smooth, continuous development flow.

To help me refine this template and make it perfectly accurate to your work, what specific new features, algorithms, or API integrations (such as the Gemini API) did you implement to give Solomon's Taskr its "smart" capabilities?

Supercharging ThreatOps: Why Google Cloud's Agentic AI Defense Changes the SOC Game

Emani Sai Shanmukha Srinivas — Wed, 29 Apr 2026 03:24:58 +0000

Tuning into the Google Cloud NEXT '26 keynotes this week felt like watching the future of security operations unfold in real-time. From Thomas Kurian's opening keynote on April 22 to the deep-dives in the Developer Keynote on April 23, the focus was unmistakable: the era of AI experimentation is over, and the Agentic Enterprise is officially here. While the new Cloud Storage Rapid (hitting 15 TB/s) and the staggering scale of the new TPU 8t processors were impressive, the announcements that completely captured my attention were the launch of the Gemini Enterprise Agent Platform (the heavy-hitting evolution of Vertex AI) and the new Agentic AI Defense capabilities. Here is my take on what these updates mean for developers building next-generation security tools, and how they perfectly align with the architecture of modern real-time SOC dashboards. The Shift to Autonomous Security Agents The most significant takeaway for security developers is Google's push towards autonomous agents for Threat Hunting and Detection Engineering. The introduction of tools like the Dark Web Intelligence agent, powered by the latest Gemini 3.1 Pro models, represents a massive leap in how we parse external events. For developers, the new Agent Studio and Agent Development Kit (ADK) mean we are no longer just sending zero-shot prompts to an API; we are defining graph-based frameworks where specialized sub-agents collaborate to solve complex, multi-step problems in isolated, secure sandboxes. Evolving the ThreatOps Architecture. When architecting ThreatOps, the primary goal was to create a real-time SOC dashboard that could autonomously handle threat classification and map incidents directly to the MITRE ATT&CK framework. The existing ingestion pipeline relies heavily on Databricks for stream processing, with the Gemini API generating the ML scoring baselines. However, orchestrating complex reasoning across high-velocity threat data can be a massive bottleneck. The announcements from Next '26 provide the exact native building blocks needed to evolve this kind of architecture : Sub-Second Inference with TPU 8i: Real-time threat classification requires absolute minimal latency. The new 8th-generation TPU 8i chips—optimized specifically for inference and reinforcement learning with their Boardfly topology—mean that ML scoring baselines can evaluate potential breaches and execute logic virtually instantaneously. From APIs to Agentic Workflows: By migrating the current Gemini API integration over to the newly unified Gemini Enterprise Agent Platform, standard threat classification logic can be upgraded into a dedicated Detection Engineering agent. This allows the system to actively query enterprise databases like AlloyDB for historical context, maintaining a long-term understanding of previous attack patterns via the new Agent Memory Bank feature. Proactive Counter-Intelligence: Integrating the new Agent Security dashboard (powered by Security Command Center) means the platform can automatically map relationships between active agents and underlying models to scan for vulnerabilities, creating a closed-loop, proactive defense system. The Verdict: Beyond Surface-Level Automation. We are officially moving past the "reading the docs" phase of generative AI. The real power unveiled at Google Cloud NEXT '26 isn't just that the models are smarter; it's that the infrastructure is finally built to support multi-step, autonomous reasoning securely and at scale. For any developer building security pipelines, threat matrices, or enterprise dashboards, the Gemini Enterprise Agent Platform isn't just a rebrand of Vertex AI—it is a completely new paradigm for defensive engineering. I can't wait to refactor the pipeline and let these new agents loose on the data streams.