DEV Community: Shirshak Nandy

# 🌿 TouchGrass AI — Go Outside. Touch Grass.

Shirshak Nandy — Tue, 06 Oct 2026 17:12:02 +0000

What I Built

I built TouchGrass AI, a local-first AI outdoor companion that creates simple and fun outdoor missions.

The idea is simple: instead of using AI to keep people on a screen, TouchGrass AI uses AI to encourage people to leave the screen and explore the real world. 🌿

The app generates missions such as:

🌳 Explore your neighborhood
🍃 Find different types of leaves
🐦 Listen for birds
🚶 Take a short outdoor walk
🌱 Observe something interesting in nature

Users can start a mission, complete tasks using an interactive checklist, track their progress, and generate a new mission whenever they want.

Most importantly, the AI runs locally using an open-weight model, so the project does not require a paid AI API.

Local Demo:
The application runs locally with a React frontend and Flask backend.

Frontend:
http://localhost:5173

Backend:
http://127.0.0.1:5000

Code

GitHub Repository:
https://github.com/nandyshirshak-cloud/TouchGrass-AI

The repository contains the complete frontend, backend, AI integration, and setup instructions.

How I Built It

TouchGrass AI was built using:

Frontend

React
Vite
JavaScript
CSS

Backend

Python
Flask
Flask-CORS

AI

Hugging Face Transformers
Qwen/Qwen2.5-0.5B-Instruct
PyTorch

The AI model runs locally through Hugging Face Transformers.

The basic flow is:

User → React Frontend → Flask Backend → Local Qwen AI → Outdoor Mission → User goes outside 🌿

The backend asks the local model to generate a structured outdoor mission containing a title, duration, and tasks.

The frontend then displays the generated mission as an interactive checklist.

I also added a fallback mission so the application can still provide an outdoor activity if AI generation fails.

Why Does Open Innovation Matter?

Open innovation matters because powerful AI should not only be available through expensive closed APIs.

With open-weight models, developers can:

Experiment with AI locally
Learn how AI systems actually work
Build without depending on a paid API
Keep more control over their applications
Create privacy-friendly experiences
Modify and improve their projects freely

TouchGrass AI is a small example of this idea.

Instead of building another AI tool that encourages people to spend more time online, I wanted to use open AI technology for something very simple:

Use AI to help people spend less time with technology.

My Agent Session

The development process involved using AI-assisted coding to design the application, debug the React frontend, connect the Flask backend, integrate the local Qwen model, improve the mission-generation prompt, and prepare the project for open-source publication.

One of the interesting parts was getting the local model to return structured JSON containing:

Mission title
Duration
Four outdoor tasks

This allowed the AI-generated content to be displayed directly inside the application.

What Makes It Different?

Most AI applications try to keep users engaged with a screen.

TouchGrass AI does the opposite.

The screen is only used to receive the mission.

After that, the user is encouraged to put the device down and complete the real-world activity.

Less screen. More world. 🌿

Future Improvements

I would like to expand TouchGrass AI with:

🌦️ Weather-aware missions
📍 Location-aware outdoor activities
🗺️ Outdoor exploration maps
🏆 Outdoor achievements and streaks
🌿 Plant and nature recognition
📱 Mobile application
👥 Community challenges
🤖 More local open-weight models

Challenge

Built for the Open-Source AI / Touch Grass Challenge.

The project focuses on using open AI technology to encourage people to disconnect from their screens and interact with the physical world.

Author

SHIRSHAK Nandy

GitHub:
https://github.com/nandyshirshak-cloud

devchallenge

hf26challenge

opensource

ai

🌿 Less screen. More world.
Go outside. Touch Grass.

RemixForge AI — One Story. Infinite Remixes.

Shirshak Nandy — Sun, 04 Oct 2026 07:29:58 +0000

This is a submission for the Sanity Challenge, Path Two: Vibe-Code Something Strange

What I Built

I built RemixForge AI, an AI-powered content remix workflow that turns one piece of content into multiple creative formats.

The idea is simple:

One story. Infinite remixes.

A creator can start with a video, story, article, or other source content. RemixForge AI organizes the content inside Sanity and creates structured remix possibilities such as:

AI summaries
Social media posts
Short-video ideas
GIF moments
Captions
Multilingual content

The interesting part is that AI generation is not treated as the final step.

RemixForge AI creates a structured workflow:

Create → AI Processing → AI Review → Human Review → Approve → Publish

AI creates the first version, while a human remains responsible for reviewing and approving the final content.

The project includes a custom dashboard and public showcase in addition to the embedded Sanity Studio.

Demo

Application

The project contains four main interfaces:

Homepage — introduction to RemixForge AI
Dashboard — AI Content Control Center
Showcase — scenes and AI-discovered GIF moments
Sanity Studio — structured content and workflow management

Demo Video

https://drive.google.com/file/d/1nxTfLu1T6v1iIzjaYw1G_ORqJb0nkoNl/view?usp=sharing
The demo shows:

Opening RemixForge AI
Opening Sanity Studio
Opening the Remix Project
Sending the project to AI
AI-generated outputs appearing in Sanity
Workflow moving through AI Review
Human Review
Approval
Publishing
Viewing the result in the Showcase

Code

GitHub repository: https://github.com/nandyshirshak-cloud/RemixForge-AI

[PASTE YOUR ACTUAL GITHUB REPOSITORY LINK HERE]

The project is built with:

Next.js
React
TypeScript
Sanity
Sanity Studio
GROQ
Next.js API routes
Sanity Document Actions

How I Used Sanity

Sanity is the structured content and workflow backbone of RemixForge AI.

Instead of storing everything as unstructured text, I modeled the remix process as structured documents.

Remix Project

A Remix Project stores the original content and its high-level state.

It includes fields such as:

title
description
source type
source URL
workflow status
AI summary
mood
target languages
creation time

Scene

Scenes represent important moments detected or selected from the source content.

Each scene contains:

scene number
title
description
start time
end time
mood
GIF-candidate status

AI Output

AI-generated results are stored as their own Sanity documents.

An AI Output can represent:

summary
social post
short-video idea
GIF idea
translation
caption

Each output also stores:

language
confidence score
review status
generation time
reference to its Remix Project

GIF Moment

GIF Moments represent potentially reusable moments from the source content.

They contain:

source scene
start time
end time
AI reasoning
generation status
generated GIF URL
approval information

Workflow Run

The workflow itself is also modeled as data in Sanity.

A Workflow Run tracks states such as:

Draft → AI Processing → AI Review → Human Review → Approved → Published

It also records:

last action
last actor
assigned reviewer
workflow history
timestamps

This means the content and its editorial workflow live together as structured Sanity data.

Custom Sanity Features

I went beyond using Sanity only as a simple CMS.

The project includes custom document actions inside Sanity Studio.

For Remix Projects, there is a:

🤖 Send to AI

action.

This calls the application's AI processing API.

The API then:

Reads the Remix Project from Sanity
Updates the project workflow state
Creates a Workflow Run
Creates multiple AI Output documents
Moves the workflow into AI Review
Updates the project with the AI summary

Workflow documents also have actions for:

👤 Send to Human Review
✅ Approve
🚀 Publish

These actions update the structured workflow data and maintain workflow history.

--- Local: http://localhost:3000

Custom Interface

I also built a custom RemixForge AI dashboard instead of relying only on Sanity Studio.

The dashboard shows:

project statistics
AI output counts
workflow states
recent Remix Projects
generated AI outputs
human approval queue
the complete AI → Human → Publish pipeline

There is also a separate Showcase interface that presents:

detected scenes
scene timelines
AI-selected GIF moments
workflow stages

This gives the structured Sanity content a user-facing creative interface.

Why Sanity?

Sanity works particularly well for this project because the application is not just about storing a final article or video.

The application needs to store the relationships between:

Projects → Scenes → AI Outputs → GIF Moments → Workflow Runs

Sanity allows these pieces to remain structured and connected.

The workflow can therefore be treated as content and data rather than only application state.

What I Learned

The biggest lesson from building RemixForge AI was that structured content becomes much more interesting when the content itself participates in a workflow.

Instead of:

AI → Final Answer

the project explores:

Content → AI Generation → Structured Outputs → Review → Human Decision → Publishing

Sanity became the place where those pieces could be modeled, connected and moved through the workflow.

I also learned that building a working AI-native application involves much more than generating text. The difficult part is making the generated results useful, reviewable and connected to the rest of the application.

Sanity Project Details

Sanity Project ID:

[PASTE YOUR SANITY PROJECT ID HERE]

Dataset:

production

The Sanity project contains the structured models used by RemixForge AI, including Remix Projects, Scenes, AI Outputs, GIF Moments and Workflow Runs.

Agent Session

This section is optional.

I did not use one of the supported Agent Session CLI transcripts for this project, so I am not claiming an agent session that I do not have.

Final Workflow


text
                    REMIXFORGE AI

                         │
                         ▼
                  CREATE PROJECT
                         │
                         ▼
                    🤖 SEND TO AI
                         │
                         ▼
                  AI PROCESSING
                         │
              ┌──────────┼──────────┐
              ▼          ▼          ▼
           SUMMARY     SOCIAL      GIF
                       POSTS      MOMENTS
              │          │          │
              └──────────┼──────────┘
                         ▼
                      AI REVIEW
                         │
                         ▼
                   HUMAN REVIEW
                         │
                         ▼
                       APPROVE
                         │
                         ▼
                      PUBLISH
                         │
                         ▼
                      SHOWCASE

Clear the Lineup: Eliminating an N+1 Query Bug to Boost API Performance by 6

Shirshak Nandy — Thu, 16 Jul 2026 02:22:27 +0000

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

Project Overview

The project is a full-stack web application built using Node.js, Express, and MongoDB. It provides REST APIs for managing user data and resources.

While testing the application, I noticed that one API endpoint became significantly slower as the database size increased. The issue was caused by unnecessary database queries being executed inside a loop.

Bug Fix or Performance Improvement

Problem

The API fetched each document individually inside a loop.

This resulted in:

Slow response times
Increased database load
Higher CPU usage
Poor scalability for large datasets
Root Cause

Instead of retrieving all required data in one database query, the application performed one query for every record (the classic N+1 Query Problem).

Code

Before
const result = [];

for (const id of ids) {
const item = await Item.findById(id);
result.push(item);
}

res.json(result);
After
const result = await Item.find({
_id: { $in: ids }
});

res.json(result);
Pull Request

Replace this section with your GitHub Pull Request link.

My Improvements

My optimization focused on reducing unnecessary database operations.

The improvements include:

Eliminated repeated database queries
Reduced API response time
Lowered database workload
Improved scalability for larger datasets
Simplified the code, making it easier to maintain
Result
Metric Before After
Database Queries N Queries 1 Query
Response Time ~1200 ms ~180 ms
CPU Usage High Lower

Best Use of Sentry

I used Sentry Error Monitoring to verify that the optimization did not introduce new runtime errors.

Sentry helped me:

Monitor API exceptions
Validate successful deployments
Confirm that no new backend errors appeared after the fix

Best Use of Google AI

Google AI was used to:

Analyze the inefficient database access pattern
Suggest alternative MongoDB query strategies
Review the optimized implementation
Validate the final code for readability and correctness

Google AI accelerated the debugging process while keeping the final implementation clean and maintainable.
Conclusion

This optimization removed unnecessary database queries, significantly improved API performance, and reduced server load without changing any existing functionality.

The fix demonstrates how a small code change can provide a noticeable improvement in application performance while maintaining clean and readable code.

About Me

Hi, I'm Shirshak Nandy, a Computer Science student and open-source enthusiast from India.

💻 GitHub: https://github.com/nandyshirshak-cloud

I enjoy building AI, web development, and open-source projects while continuously learning new technologies.

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.

`****

DEV Community: Shirshak Nandy

# 🌿 TouchGrass AI — Go Outside. Touch Grass.

What I Built

Code

How I Built It

Frontend

Backend

AI

Why Does Open Innovation Matter?

My Agent Session

What Makes It Different?

Future Improvements

Challenge

Author

Tags

devchallenge

hf26challenge

opensource

ai

RemixForge AI — One Story. Infinite Remixes.

What I Built

Demo

Application

Demo Video

Code

How I Used Sanity

Remix Project

Scene

AI Output

GIF Moment

Workflow Run

Custom Sanity Features

Custom Interface

Why Sanity?

What I Learned

Sanity Project Details

Agent Session

Final Workflow

Clear the Lineup: Eliminating an N+1 Query Bug to Boost API Performance by 6

Project Overview

Bug Fix or Performance Improvement

Code

My Improvements

Best Use of Sentry

Best Use of Google AI

About Me

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

[🎮 Video Demo

💻 Code

⚙️ How I Built It

Reviving My AI Incident Agent with GitHub Copilot

My Experience with GitHub Copilot

Building the Future of Local AI Intelligence

How Local AI Models Are Quietly Changing the Future of Development

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

⚡ Why Gemma 4 Stands Out

🧠 The Engineering Behind the Model Variants

🔹 2B / 4B (Small Models)

🔹 31B Dense Model

🔹 26B Mixture-of-Experts (MoE)

💡 What Developers Can Build with Gemma 4

🌍 A Bigger Shift in AI Thinking

🚀 Final Thoughts

My First Look at Hermes Agent

Introduction

What is Hermes Agent?

Why Open-Source Agents Matter

Key Features

1. Multi-Step Reasoning

2. Tool Integration

3. Memory and Learning

4. Model Flexibility

Potential Applications

My Thoughts

Conclusion

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

What I Built

Demo

The Comeback Story

My Experience with GitHub Copilot