DEV Community: Shirshak Nandy

Balance of Light — A Time-Based Survival Game for the June Game Jam

Shirshak Nandy — Thu, 04 Jun 2026 11:42:41 +0000

[This is a submission for the June Solstice Game Jam

## What I Built
I built a browser-based game called Solstice: Balance of Light, inspired by the theme of the June Solstice — the balance between light and darkness, and the natural cycles of time and transition.

The game is a simple survival experience where:

Light energy continuously decreases over time 🌑
The player must collect light to stay alive 🌞
The environment simulates a day and night cycle 🌗
The objective is to maintain balance between light and darkness ⚖️

The idea is to represent the solstice as a moment of equilibrium — where opposing forces must be balanced to survive.

[🎮 Video Demo

[🔗 Live Game:
https://github.com/nandyshirshak-cloud/solstice-game
📂 Source Code:
__
https://github.com/nandyshirshak-cloud/solstice-game/tree/main

💻 Code

The full source code is available here:
👉 https://github.com/nandyshirshak-cloud/solstice-game
The project uses:
HTML for structure
CSS for UI styling
JavaScript for game mechanics and logic
No external frameworks were used — the game is built entirely using vanilla web technologies.

⚙️ How I Built It

I built the game in a simple iterative process:
Created a basic UI with a light energy system
Implemented a game loop using JavaScript (setInterval) to simulate time
Added a light decay mechanic to create pressure and urgency
Introduced a day/night cycle system to reflect the solstice theme
Added win/lose conditions based on maintaining balance
The focus was on building a minimal but meaningful gameplay loop rather than complex graphics or systems.

✨ Final Note
This project represents my interpretation of the solstice as a moment of balance and transition.
Through simple mechanics, I tried to express how opposing forces — light and darkness — interact over time, creating tension, urgency, and equilibrium.](url)

Reviving My AI Incident Agent with GitHub Copilot

Shirshak Nandy — Thu, 04 Jun 2026 11:07:54 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

I originally built AI Incident Agent, an AI-powered system designed to help engineers detect, analyze, and respond to system incidents faster using intelligent automation.

The goal of this project is to reduce mean time to resolution (MTTR) by leveraging AI to:

Detect and analyze incidents in real time
Assist in root cause identification
Provide actionable insights for faster resolution

It was initially started as a prototype during a learning phase, but remained incomplete due to limited time and complexity in building full incident-response workflows.

This challenge gave me the opportunity to bring it back, improve it, and turn it into a more complete and usable system.

*🎥 Demo *

GitHub Repository: https://github.com/nandyshirshak-cloud/ai-incident-agent

📸 Screenshots / Demo:

Architecture and workflow improvements (add screenshots here if available)
Incident detection flow
AI analysis output examples

**
🔁 The Comeback Story
**
When I first built this project, it was in a very early stage:

Basic AI logic was implemented
Incident detection flow was incomplete
No proper structure for real-world usage
Limited error handling and missing refinements

During this revival, I focused on turning it into a more production-ready system.

🔥 Before vs After

Before:

Prototype-level implementation
Incomplete incident handling pipeline
Limited modular structure

After:

Improved architecture and cleaner structure
Enhanced AI-driven incident analysis flow
Better scalability and maintainability
More complete workflow for incident handling

My Experience with GitHub Copilot

🤖 My Experience with GitHub Copilot

GitHub Copilot played a key role in accelerating the development of this project.

I used Copilot to:

Generate boilerplate code for backend modules
Refactor and clean complex logic
Improve structure of incident handling workflows
Debug and fix implementation issues faster
Speed up iteration while improving code quality

Copilot helped me focus more on system design and logic rather than repetitive coding tasks, making it easier to push this project toward completion.
🏁 Final Thoughts

This project represents my journey from an unfinished prototype to a more complete AI-powered incident management system.

It also helped me better understand:

Building AI-assisted developer tools
Structuring scalable backend systems
Improving code quality with AI tools like Copilot

Building the Future of Local AI Intelligence

Shirshak Nandy — Mon, 01 Jun 2026 07:32:36 +0000

Introduction

Artificial intelligence is rapidly moving from cloud-only systems to local, developer-controlled intelligence.

One of the strongest examples of this shift is Gemma 4 — a model family designed to bring powerful reasoning, long-context understanding, and efficient deployment closer to developers.

This is not just another model release. It represents a change in how AI is used, deployed, and owned.

What Makes Gemma 4 Important?
🔹 1. Long Context Understanding

Gemma 4 supports extremely large context windows, enabling it to work with:

Entire codebases
Research papers
Multi-file reasoning tasks

This allows deeper understanding instead of isolated prompt responses.

🔹 2. Strong Reasoning Ability

It is designed to handle:

Multi-step reasoning
Structured outputs (JSON, APIs, workflows)
Debugging and code generation

This makes it suitable for real-world development use cases.

🔹 3. Local-First AI Deployment

Gemma 4 is optimized for running locally, which means:

Reduced dependency on cloud APIs
Better privacy and control
Lower long-term cost
Offline AI capabilities

This is especially powerful for personal tools and enterprise systems.

⚙️ Why Developers Should Care

Gemma 4 opens up new possibilities for builders:

🧑‍💻 Offline coding assistants
📄 Document analysis tools
🤖 Custom AI agents
🎓 Educational AI applications

It allows developers to move from using AI APIs to owning AI systems.

🌍 Bigger Impact

The rise of models like Gemma 4 suggests a major shift:

AI is becoming infrastructure, not just a service.

This leads to:

More privacy-focused applications
More offline intelligence systems
More customizable AI behavior
Reduced reliance on expensive APIs
Conclusion

Gemma 4 represents more than performance improvements — it represents control and accessibility.

The future of AI is not only about bigger models in the cloud, but about smarter models running everywhere — on every device, for every developer.

How Local AI Models Are Quietly Changing the Future of Development

Shirshak Nandy — Mon, 01 Jun 2026 07:28:49 +0000

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Gemma 4: How Local AI Models Are Quietly Changing the Future of Development

We are entering a new phase of AI development where powerful models are no longer locked inside cloud APIs.

Gemma 4 represents a major shift: high-performance AI that can run locally, on devices ranging from laptops to mobile phones and even edge hardware like Raspberry Pi.

What makes this important is not just performance—but accessibility, privacy, and control.

⚡ Why Gemma 4 Stands Out

Unlike traditional large-scale AI systems that depend heavily on cloud infrastructure, Gemma 4 introduces a more flexible approach:

AI that can run locally without constant internet dependency
Lower latency responses since computation happens on-device
Better privacy because user data doesn’t always need to leave the device
More freedom for developers to customize and experiment

This changes the developer experience completely—AI becomes something you can embed anywhere, not just call via an API.

🧠 The Engineering Behind the Model Variants

Gemma 4 is not a single model—it is a family of optimized architectures, each designed for a specific computing environment.

🔹 2B / 4B (Small Models)

These are designed for efficiency-first environments:

Mobile applications
Embedded systems
Lightweight AI tools

They sacrifice some reasoning depth for speed and portability, making them ideal for real-time applications.

🔹 31B Dense Model

This version focuses on raw capability and general-purpose intelligence:

Strong reasoning ability
Better code generation
Suitable for production-level AI applications

It acts as the “balanced powerhouse” of the family.

🔹 26B Mixture-of-Experts (MoE)

This is the most efficient architecture in the lineup.

Instead of activating all parameters at once, it dynamically selects parts of the model, enabling:

High performance reasoning
Lower computational cost compared to dense models
Scalability for real-world deployments

This is where efficiency meets intelligence.

💡 What Developers Can Build with Gemma 4

The real value of Gemma 4 becomes clear when you start building with it.

Some practical applications include:

Offline AI study assistants for students
Local coding copilots that work without cloud APIs
Privacy-first journaling or note-taking AI
Multimodal tools combining text + images
Smart edge applications for IoT devices

What was previously “research-only” is now becoming achievable for individual developers.

🌍 A Bigger Shift in AI Thinking

Gemma 4 reflects a larger movement in AI:

From centralized intelligence → to distributed intelligence

Instead of depending on massive cloud systems, developers can now embed intelligence directly into applications, devices, and workflows.

This reduces dependency, increases privacy, and unlocks creativity at the edge.

🚀 Final Thoughts

Gemma 4 is not just another model release.

It represents a practical step toward making AI:

more accessible
more private
more developer-friendly

For developers, this is an opportunity to rethink architecture—not just use AI, but own where it runs.

I’m excited to see how the community builds with it.

My First Look at Hermes Agent

Shirshak Nandy — Sat, 30 May 2026 03:10:26 +0000

# My First Look at Hermes Agent: Exploring the Future of Open-Source AI Agents

Introduction

Artificial intelligence has evolved rapidly over the past few years. While chatbots are useful, AI agents represent the next step because they can reason, plan, use tools, and complete multi-step tasks. Recently, I explored Hermes Agent, an open-source AI agent developed by Nous Research, and I wanted to share my observations.

What is Hermes Agent?

Hermes Agent is an open-source AI agent framework designed to perform complex tasks through planning, tool usage, memory, and reasoning. Unlike traditional chatbots that respond to a single prompt, Hermes Agent can break down larger objectives into smaller steps and work through them systematically.

Why Open-Source Agents Matter

Many AI systems today are cloud-based and closed-source. Open-source projects such as Hermes Agent give developers greater flexibility, transparency, and control. Developers can customize the system, choose their preferred models, and deploy it on their own infrastructure.

Key Features

1. Multi-Step Reasoning

Hermes Agent can analyze a problem and divide it into multiple steps before generating a solution.

2. Tool Integration

The framework can interact with external tools and services to complete tasks more effectively.

3. Memory and Learning

One of the most interesting aspects is its ability to retain useful information and improve future interactions.

4. Model Flexibility

Developers are not locked into a single provider and can experiment with different AI models.

Potential Applications

Research assistants
Study assistants for students
Productivity automation
Knowledge management systems
Software development workflows

My Thoughts

What impressed me most is the project's focus on openness and adaptability. As AI agents become more capable, frameworks like Hermes Agent could help developers build powerful applications without depending entirely on proprietary solutions.

Conclusion

Hermes Agent demonstrates how open-source AI agents are evolving beyond simple chat interfaces. Its support for reasoning, memory, and tool usage makes it an exciting project for developers interested in the future of AI automation. I look forward to seeing how the community continues to build and innovate around this framework.

CyberShield AI — My Revived Phishing Detector (Finish-Up-A-Thon Submission)

Shirshak Nandy — Fri, 29 May 2026 04:17:36 +0000

[*_`*This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

I built CyberShield AI, a phishing email detector using HTML, CSS, and JavaScript. It checks messages for suspicious words and warns users about possible phishing attempts.

This project was originally incomplete, but I revived and finished it for the GitHub Finish-Up-A-Thon Challenge.
`
!_**Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gsoi651bjckwuie4p8gh.png)

`_

Demo

GitHub Repository:
https://github.com/nandyshirshak-cloud/cybershield-ai

The Comeback Story

This project was previously unfinished. During this challenge, I completed the logic, improved the design, and made it fully functional.

My Experience with GitHub Copilot

GitHub Copilot helped me improve code structure and speed up development by suggesting better logic and cleaner code.

`****