DEV Community: Emani Sai Shanmukha Srinivas

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.

EcoSentinel: An Agentic AI Auditor for Earth Day 🌍

Emani Sai Shanmukha Srinivas — Sun, 19 Apr 2026 19:04:47 +0000

What I Built
EcoSentinel is an autonomous, multimodal environmental monitoring agent. It is designed to act as a "Security Operations Center (SOC) for the Planet," using vision-language models to analyze ecological data—ranging from satellite imagery to local photos of industrial waste—and generate structured remediation plans.

The core objective was to move beyond static data visualization and create an agent that can "see" environmental degradation, reason about regulatory compliance, and remember the history of a specific location to track its recovery over time.

Demo link - https://ai.studio/apps/45fd3395-6b00-4e5a-bb79-ea18db599750

To test it you can try this

Sector: Gran Chaco, Paraguay
Coordinates: -21.432658, -59.578124

Use the image below for the visual analysis

Demo of the same

Code
How I Built It
The project is built on an Agentic Workflow that prioritizes perception, memory, and verifiable identity:

Multimodal Perception (Google Gemini 1.5 Flash): I used Gemini 1.5 Flash via Google AI Studio to process high-resolution images. The model identifies environmental "threats" (e.g., deforestation, oil spills, or illegal dumping) and maps them against ecological standards.

Long-Term Memory (Backboard): To ensure the agent isn't just reacting to a single moment in time, I integrated Backboard. This allows EcoSentinel to store past audit results, enabling "Temporal Awareness." It can compare a new image of a site to one from six months ago to verify if restoration efforts are actually working.

Agent Identity (Auth0 for Agents): To prevent spoofed reports and ensure accountability, I implemented Auth0 for Agents. Every audit report generated by EcoSentinel is cryptographically signed with a unique machine-identity, making the data trustworthy for regulatory bodies.

Structured Reasoning: The agent doesn't just return text; it outputs structured JSON. This allows the data to be instantly piped into a dashboard or used to trigger automated alerts for environmental agencies.

Prize Categories
Best Use of Google Gemini: Leveraged Gemini 1.5 Flash for its massive context window and multimodal capabilities to analyze complex environmental imagery and output structured audit data.

Best Use of Backboard: Integrated Backboard to give the agent persistent memory across sessions, allowing it to track ecological site history.

Best Use of Auth0 for Agents: Used Auth0 to provide a verifiable identity for the AI agent, ensuring that every environmental report is authenticated and auditable.

Created for the Weekend Challenge: Earth Day Edition 2026.

I Built a Tool That Automatically Roasts Your Teammate Every Time They Use AI or Lose a Hackathon

Emani Sai Shanmukha Srinivas — Sat, 11 Apr 2026 13:49:18 +0000

This is a submission for the DEV April Fools Challenge

What I Built

dave-watch — a CLI tool that sits in the background, monitors your repo for AI-generated code commits and your team's hackathon history, and fires a personalised roast notification every single time Dave (or whoever your Dave is) does either of those things.

Did Dave just push a commit where every function has a docstring that starts with "Certainly!"? Roasted.
Did Dave's team just come last in a 48-hour hackathon where the only other team was two sleep-deprived undergrads? Absolutely roasted.

The notifications look like this:

Demo

$ dave-watch --target="dave@company.com" --hackathon-feed=devpost

👀 dave-watch is running. Watching Dave.
   (Dave does not know he is being watched.)
   (This will not take long.)

[09:14] ✅ No activity. Dave is in a meeting explaining
           why last sprint's tickets aren't done.

[09:47] 🚨 AI COMMIT DETECTED
        Commit: "refactor user service (cleanup)"
        Author: Dave <dave@company.com>
        Red flags found: 7
          • Docstring begins with "Certainly! Here's the..."
          • 3 nested try/catch blocks that all do the same thing
          • A comment that says "This is O(n log n) I think"
          • Variable: 'optimized_and_clean_final_v2_FINAL'
          • Dave pushed this 4 minutes after opening the file

        🎤 ROAST: "Dave asked an AI to write his code,
                   then asked a different AI to review it,
                   then asked Slack to explain the review.
                   Dave is a middle manager who learned to git push."

[11:30] 🚨 HACKATHON RESULT DETECTED
        Event:     HackIndia Regional 2025
        Teams:     18
        Dave's team placed: 17th
        Team above Dave: A solo 19-year-old who built
                         a Chrome extension that makes
                         fonts slightly more italic.
        Dave's post-mortem: "We were too ambitious"

        🎤 ROAST: "Dave's team had 4 people, a Figma file
                   with 38 screens, and a microservices
                   architecture for an app that showed
                   the weather. They did not show the weather.
                   They showed a loading spinner. For 3 minutes.
                   Then the tab crashed."

[14:02] ✅ No activity. Dave is on LinkedIn writing a post
           about 'lessons learned' from the hackathon.
           Dave has used the phrase 'fail forward' twice.
           Dave is not failing forward. Dave is failing sideways.

Code

# dave-watch.py
# Requirements: git, python3, devpost scraper, zero mercy

import subprocess
import time
import random

AI_TELLS = [
    "Certainly! Here",
    "As an AI language model",
    "I hope this helps!",
    "Here's the refactored",
    "optimized_and_clean_final",
    "# This function does",      # nobody writes this naturally
    "handle error here",
    "TODO: fix this later",
    "it works on my machine",
]

HACKATHON_ROASTS = [
    "Dave's team had a pitch deck with 22 slides. Slide 1 was the title. Slide 22 was 'Thank You'. The 20 slides in between were the vision. There was no product.",
    "Dave came to the hackathon with a pre-built template, renamed the variables, and called it a pivot. The judges called it something else.",
    "Dave's README had a 'Getting Started' section. Step 1 was 'Install Node.js'. There was no Step 2. The app did not start.",
    "Dave lost to a team who had never coded before. Their app crashed on launch. The judges said it had 'more soul'.",
    "Dave described his tech stack as 'scalable, cloud-native, and AI-powered'. It was a Google Form connected to a spreadsheet.",
]

AI_ROASTS = [
    "Dave has not written an original line of code since 2023. This is not an insult. This is a git log.",
    "Dave uses AI to write the code, AI to review the code, and AI to explain the code to himself. Dave is a project manager now. Dave does not know this.",
    "Dave copied the AI output, ran it, it failed, pasted the error back into the AI, copied the fix, and called this 'debugging'. Dave has been doing this for 4 hours. Dave will not read the error message himself.",
    "Dave's variable names are full sentences. This is because he copied the AI explanation and forgot to stop copying.",
    "The AI wrote a comment saying 'you may want to handle this edge case'. Dave deleted the comment. Dave did not handle the edge case.",
]

def check_latest_commit_for_ai(repo_path, target_email):
    result = subprocess.run(
        ["git", "log", "-1", "--author", target_email,
         "--pretty=format:%H", "-p"],
        cwd=repo_path, capture_output=True, text=True
    )
    output = result.stdout
    flags = [tell for tell in AI_TELLS if tell.lower() in output.lower()]
    return flags

def watch(target_email, repo_path, check_interval=300):
    print(f"👀 dave-watch is running. Watching {target_email}.")
    print(f"   (They do not know they are being watched.)")
    print(f"   (This will not take long.)\n")

    seen_commits = set()

    while True:
        flags = check_latest_commit_for_ai(repo_path, target_email)

        commit_hash = subprocess.run(
            ["git", "log", "-1", "--author", target_email,
             "--pretty=format:%H"],
            cwd=repo_path, capture_output=True, text=True
        ).stdout.strip()

        if flags and commit_hash not in seen_commits:
            seen_commits.add(commit_hash)
            print(f"🚨 AI COMMIT DETECTED")
            print(f"   Red flags: {', '.join(flags)}")
            print(f"\n   🎤 ROAST: {random.choice(AI_ROASTS)}\n")

        time.sleep(check_interval)

if __name__ == "__main__":
    watch(
        target_email="dave@company.com",
        repo_path=".",
        check_interval=300
    )

How I Built It

Tech stack:

Python 3 (for the git log parsing and general Dave surveillance)
subprocess (to run git commands with the energy of someone filing a formal complaint)
A curated list of AI tells scraped from three months of reviewing Dave's PRs
Devpost's public results pages (parsed manually, with increasing personal investment)
Anger

The process:

Dave pushed a PR. The first line of every function was a docstring that began with "Certainly!". I approved it anyway. I think about this every day.
Dave entered HackIndia Regional. Dave's team had a Notion doc with 6 pages of planning. Dave's team had zero pages of working code at submission time. Dave's team submitted the Notion doc.
I built this tool.
The tool works. Dave does not know it exists.
Dave has triggered it 11 times this week. It is Wednesday.

Known issues:

The tool has no off switch, which feels appropriate.
It will also flag your own commits if you've ever copied from an AI. You have. I have. We don't talk about this.
The hackathon scraper breaks if Dave doesn't enter under his real name. Dave once entered a hackathon as "DaVinci_Codes". The scraper found him anyway.

Prize Category

Community Favorite — because every team has a Dave. You read this and you thought of your Dave. You smiled a specific smile. This tool is for you.

Also: HTTP 418. I am a teapot. Dave is also a teapot. Dave does not know he is a teapot.