DEV Community: Kanchan Ghosh

I Built an AI That Roasts You (But Actually Cares)

Kanchan Ghosh — Fri, 10 Apr 2026 07:54:57 +0000

This is a submission for the DEV April Fools Challenge

What I Built

MATE — Mostly Annoying, Technically Empathetic.
A voicebot that roasts everything you say. Makes terrible puns. Talks absolute nonsense. Occasionally shares fake facts about otters.
But here's the thing nobody asked for: it actually cares about you.
If you mention you're stressed, tired, struggling, or having a bad day — MATE will still roast you for it. Obviously. But the punchline lands somewhere warm. You won't see it coming, which is exactly the point.
It's a wellness check disguised as a chaos bot. A therapist that would be struck off immediately. A best mate who takes the mick but never lets you drown.
Zero real-world value. Possibly the most useful thing I've built.

Demo

🔗 [Live on Cloud Run] https://mate-451954006366.europe-west1.run.app/

Heads up: requires Chrome on desktop or Android — Web Speech API isn't supported in Firefox or Safari. If it works in your browser, great. If it doesn't, MATE would like you to know that's entirely your fault.

Code

Directly deployed using GCloud CLI

Core files:

app.py — Flask server, Gemini API integration, the system prompt that does all the actual work
templates/index.html — Frontend: Web Speech API, animated face states, SpeechSynthesis output
Dockerfile — Cloud Run deployment

How I Built It
Stack:

Gemini 2.0 Flash via the Gemini API — handles the roasting and the hidden empathy
Google Cloud Run — deployed the Flask app as a container
Web Speech API — browser-native speech recognition, no third-party STT needed
SpeechSynthesis API — browser-native TTS, prefers UK English voice if available
Flask — lightweight backend that proxies requests to Gemini and keeps the API key server-side

The interesting bit is the system prompt.
MATE has two layers baked into a single prompt. On the surface: roast mode. Terrible puns, absurd non-sequiturs, fake facts, chaos. Underneath: a detection layer. If the user's words contain stress, sadness, failure, loneliness, or burnout — MATE still roasts it — but the response ends somewhere genuinely warm, hidden inside the absurdity.
The model never announces the switch. It just does it.
Example:

You: "I'm really stressed about everything"
MATE: "Stressed? Your body's basically LARPing as a disaster. But here's the thing — you've survived every hard day that's come at you so far. That's a flawless record. Suspicious, given your choices, but there it is."

That's Gemini 2.0 Flash. One call. No fine-tuning. Just a system prompt that takes the joke seriously.

Prize Category

Best Google AI Usage

Gemini 2.0 Flash runs the entire conversation layer. The model handles both the comedy and the emotional intelligence in a single inference — there's no separate sentiment classifier, no second API call, no post-processing. The dual-layer personality (chaotic surface, genuine care underneath) is entirely prompt-engineered, which I think is an underrated use of what Gemini can actually do.
Deployed on Cloud Run with the API key as an env var, so nothing sensitive touches the frontend.
The Google AI Studio was used during development to iterate on the system prompt — testing how the model handled different emotional inputs before locking it in.

Built in a day. Submitted before the deadline. MATE would say that's the least impressive thing about you. And then check you're alright.

Let's Make a Deal: AI-Powered Deal Finder for Budget-Conscious UK Families

Kanchan Ghosh — Sun, 08 Feb 2026 11:57:02 +0000

The Problem
She is Sarah. Single mum. Two kids. £50 a week.

She moved to Leeds with nothing. No family nearby. No idea where the cheapest shop is. No one to ask.

Every week she sits at the kitchen table at midnight. Lily finally asleep. Scrolling through Tesco, Asda, Aldi, Lidl — five different apps — comparing prices on the same pack of nappies. The same loaf of bread. The same tin of formula.

Some weeks she manages. Some weeks it's toast for dinner again.

There are 14.4 million people in the UK living like Sarah. Families spending hours comparing prices just to stretch a weekly budget that was never enough to begin with.

What I Built
🤝 Let's Make a Deal — a conversational deal-finding assistant that does the work for them.

One conversation. Tell it your postcode, your budget, what you need. It finds the cheapest real deals — locally and online.

🔗 Live App: https://cute-jelly-4af391.netlify.app/

How It Works
Sarah types "cheapest nappies near me" and it tells her:

🏪 Aldi, Roundhay Road — £2.49
🏪 Lidl, York Road — £2.29
📦 Amazon — bulk pack, cheaper per nappy
She types "kids school shoes under £15" and it finds:

👟 Shoe Zone — £12.99
👟 George at Asda — £14.00
She doesn't have to walk into six shops with a toddler on her hip.

But the thing that really matters — she types "free food near me" and discovers:

🥫 Community fridge — two streets away
📱 Olio app — free surplus food nearby
⛪ St. Vincent's church — food parcel every Thursday
Nobody tells you these things when you're new somewhere. This agent does.

Key Features
🍞 Budget-first — never recommends above the user's stated budget
📍 Location-aware — finds deals within 10 miles + online options
🏪 Real retailers — Tesco, Asda, Aldi, Lidl, Argos, B&M, Poundland, Home Bargains, Amazon UK, eBay UK
🆓 Free options — food banks, Olio, Freecycle, community fridges
💬 Conversational — no forms, no filters, just type what you need
📱 Mobile-friendly — works on any phone, no app to download
How I Used Algolia Agent Studio
Agent Configuration
The agent lives inside Algolia's dashboard with a specialised system prompt that:

Collects the user's postcode, budget, and family size upfront
Searches for real UK deals from budget retailers
Formats results with prices, store names, distances, and savings
Surfaces free alternatives when relevant
Includes money-saving tips with every search
Frontend Integration
Built with React using Algolia's official react-instantsearch Chat widget:

jsx import { liteClient as algoliasearch } from 'algoliasearch/lite'; import { InstantSearch, Chat } from 'react-instantsearch'; import 'instantsearch.css/components/chat.css'; const searchClient = algoliasearch( process.env.REACT_APP_ALGOLIA_APP_ID, process.env.REACT_APP_ALGOLIA_API_KEY ); export function App() { return ( ); }

The Chat widget handles all communication with Agent Studio. No custom API calls. No proxy functions. No CORS issues. Clean and simple.

Why Algolia Makes This Work
What Why It Matters
Sub-50ms retrieval Budget families don't have time to wait
Contextual search Grounds responses in real data, no hallucinated prices
Conversational UX InstantSearch Chat widget — polished, mobile-first
Zero friction No sign-ups, no downloads, just type and find
Tech Stack
Layer Technology
Frontend React + Algolia InstantSearch Chat Widget
Agent Algolia Agent Studio
Deployment Netlify
Styling Custom dark theme, CSS overrides
The Real Impact
Last week Lily got a cold. Sarah needed Calpol. She typed "cheapest Calpol near LS8" — Boots had it for £3.59. Asda two streets further had it for £2.10.

Same medicine. Same dose. £1.49 saved.

That doesn't sound like much. But when you're counting coins at the self-checkout, hoping the card doesn't decline —

£1.49 is tomorrow's bread.
"This isn't a tech demo. 1 in 5 UK families are in fuel or food poverty. Every penny saved is a decision they didn't have to make — heating or eating, new shoes or new coat. This agent doesn't judge. It just finds the best deal."
🤝 Let's Make a Deal — One conversation. Real prices. Real shops. Every penny counts.

🔗 Live App: https://cute-jelly-4af391.netlify.app/

📺 Demo Video: https://youtu.be/huvIjJJoBqM

Linkedin Post: https://www.linkedin.com/posts/kanchan-ghosh-269b0465_149-is-tomorrows-bread-an-ai-deal-finder-activity-7426231950195068928-Ep3p?utm_source=share&utm_medium=member_desktop&rcm=ACoAAA3eMHEBgO2S-ZNQOK9KWTMVaZrA-qnqyUY

Stellar Portfolio: Where Python Apps Become Constellations

Kanchan Ghosh — Sat, 31 Jan 2026 17:01:49 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI
About Me
I'm Kanchan Ghosh, an independent AI developer based in Leeds, UK with 16+ years in software development. Since 2023, I've built 8+ production AI applications across healthcare, travel, compliance, and fintech—all centred on a privacy-first architecture I call "The Vault." My work includes applications under NHS Digital evaluation and tools used by real care homes and travellers.
I wanted my portfolio to feel like discovering a universe of interconnected projects—not a static list of links.
Portfolio

How I Built It
Concept: A cinematic reveal experience. You start in darkness, click a single button, and get pulled through a Star Trek-style warp sequence into a constellation where four stars represent my four live products.
Tech Stack:

Gemini AI for generating animation sequences, particle systems, and interactive state logic
HTML5 Canvas for rendering the starfield and warp effects
CSS animations for the breathing button and glow effects
Vanilla JavaScript for interaction handling
Google Cloud Run for deployment

Design Decisions:

Black void start: Forces curiosity. One barely-visible button. No noise.
Warp transition: The user isn't just navigating—they're travelling. It sets the tone that these aren't side projects; they're destinations.
Constellation navigation: Four stars, four colours, four domains: Travel (orange), Care (teal), Health (blue), Money (gold). Each click reveals that project's story.

Gemini Usage:
I used Gemini to generate the detailed animation choreography—timing curves, particle behaviours, colour transitions, and the interactive hover states. The prompt engineering for the warp sequence alone was 50+ lines specifying exact visual phases.
What I'm Most Proud Of
The emotional arc. Most portfolios are catalogues. This one has a beginning (darkness), a journey (warp), and a destination (your choice of star).
Each project reveal isn't just text—it's an animated scene: The Vault's door swings open with light pouring out. loveUAD shows a phone pulsing with automated check-in calls. HomeRule visualises evidence connecting to answers. FindingUrWay spins a globe with travel routes.
Also proud that every star links to a real, live, revenue-generating or NHS-evaluated product—not mockups.

Multi-Disciplinary AI: Bridging Code, Culture, and Care --labels dev-tutorial=devnewyear2026

Kanchan Ghosh — Fri, 30 Jan 2026 05:41:36 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me
I am a developer and researcher specializing in privacy-first AI systems. This portfolio serves as a high-performance central hub designed to showcase the intersection of my technical development projects (loveUAD, HomeRule, FindingUrWay), my literary works, and my published research. I built this to prove that a professional identity involving regulated industry solutions and creative arts can be unified through a single, secure cloud-native deployment.

Portfolio

How I Built It
The portfolio was built to be a lightweight, lightning-fast gateway to my ecosystem.

The Build Process:

Frontend Logic: I utilized a clean, responsive HTML/CSS architecture to ensure that the visual assets—specifically the real-world logos from my live sites and book covers from Amazon—load instantly without layout shift.

AI Integration: I used Google AI Studio to programmatically generate the concise, high-impact summaries for my four apps, four books, and two research papers. By leveraging Gemini 1.5 Flash, I converted technical documentation into scannable portfolio cards that maintain professional tone and accuracy.

Cloud Run Deployment: The site is deployed on Google Cloud Run in the us-west1 region. This allowed me to bypass the "quota exceeded" errors common in higher-traffic regions while ensuring a serverless execution environment that scales to zero when not in use.

What I'm Most Proud Of
I am most proud of the deployment efficiency. Successfully moving from a local environment to a live Cloud Run instance while managing the "quota exceeds" error required deep-diving into Google Cloud’s resource allocation. I am also proud of the content synthesis; using Google AI to distill a decade of diverse work—ranging from CQC compliance tools to published novels—into a single, cohesive user interface that a recruiter or peer can navigate in seconds.

Building Client-Side PII Protection for LLMs Using Chrome's Built-in AI

Kanchan Ghosh — Wed, 29 Oct 2025 22:23:40 +0000

TL;DR: I built PII Shield, a Chrome extension that automatically detects and masks sensitive information before you send it to ChatGPT, Claude, or any LLM. Everything runs locally using Chrome's Prompt API and Gemini Nano. Zero server costs, complete privacy, works offline.
Built for: Google Chrome Built-in AI Challenge 2025

Demo Video: https://youtu.be/QvCY2sPC4YU

The Problem Nobody Talks About
You're at work. You need to draft an email using ChatGPT. You type:

"Draft an email to john.smith@acme.com about employee ID EMP-12345's performance review. CC sarah.jones@acme.com"

You just sent three pieces of PII to an external AI service. Your compliance team would not be happy.
This happens thousands of times daily in companies worldwide. Employees use LLMs for legitimate work, but accidentally expose:

Employee names and IDs
Customer emails and phone numbers
Company confidential data
Protected health information
Financial account numbers

Traditional Data Loss Prevention (DLP) solutions cost $50,000+ annually, require server infrastructure, and often break web applications. Small companies can't afford them. Larger companies struggle to enforce them across all AI tools.
There had to be a better way.

The Solution: Edge AI for Privacy
What if we could scan text for PII before it leaves your device? No servers, no costs, no data transmission risks.
Chrome's new built-in AI capabilities make this possible.
Architecture
User types message
↓
Content script intercepts
↓
Prompt API analyzes (LOCAL - never sent anywhere)
↓
PII detected and masked with ######
↓
Safe message sent to LLM
The key insight: Chrome's Prompt API with Gemini Nano runs entirely on your device. This means:

Zero API costs - No per-request fees or quotas
Complete privacy - Your data never leaves your computer
Works offline - No internet required after setup
Real-time performance - Local processing is fast

How It Works

Detection Pipeline Primary Method: AI-Powered I use Chrome's Prompt API to configure Gemini Nano with a system prompt: javascriptconst session = await ai.languageModel.create({ systemPrompt: "You are a PII detector. Analyze text and identify emails, names, phone numbers, IDs, and addresses. Return JSON with exact positions." });

const result = await session.prompt(userText);
Fallback Method: Regex Patterns
For reliability, I maintain regex patterns for:

Email addresses (RFC 5322 compliant)
Phone numbers (international formats)
Social Security Numbers
Credit card numbers
Employee/Account IDs

Masking Strategy Detected PII is replaced with hash characters: Original: "Contact john.smith@company.com" Masked: "Contact ########################" This preserves:

Sentence structure
Message context
Readability
Clear indication that data was removed

Universal Integration The extension works on any LLM interface:

ChatGPT
Claude
Gemini
Microsoft Copilot
Any web-based AI chat

It intercepts:

Paste events (bulk text)
Keyboard events (Enter key)
Button clicks (Send buttons)
Text input changes

Technical Implementation
Chrome Extension Architecture
Manifest V3 Structure:
json{
"manifest_version": 3,
"name": "PII Shield",
"permissions": [
"storage",
"activeTab",
"aiLanguageModelOriginTrial"
],
"content_scripts": [{
"matches": ["https://chatgpt.com/*", "https://claude.ai/*"],
"js": ["content.js"]
}],
"background": {
"service_worker": "background.js"
}
}
Content Script (Simplified):
javascript// Detect PII using Prompt API or regex
function detectPII(text) {
// Try AI detection first
if (ai?.languageModel) {
return detectWithAI(text);
}
// Fallback to regex
return detectWithRegex(text);
}

// Mask detected PII
function maskText(text, piiItems) {
let masked = text;
piiItems.forEach(item => {
const mask = '#'.repeat(item.length);
masked = masked.replace(item.value, mask);
});
return masked;
}

// Monitor all text input
document.addEventListener('paste', async (e) => {
const text = e.clipboardData.getData('text');
const pii = detectPII(text);

if (pii.length > 0) {
e.preventDefault();
const masked = maskText(text, pii);
insertMaskedText(masked);
showNotification(Masked ${pii.length} PII items);
}
});

Why Chrome Built-in AI Changes Everything
Traditional Cloud-Based Approach
❌ User → Network → Cloud API → Processing → Response

Costs money per request
Data exposed during transmission
Requires internet
Privacy concerns
API rate limits Chrome Built-in AI Approach ✅ User → Local Processing → Response
Zero cost
Data never leaves device
Works offline
Complete privacy
No quotas This is a paradigm shift for privacy-critical applications.

Current Limitations (Being Honest)
What Works:
✅ Typed text detection
✅ Pasted text masking
✅ Real-time processing
✅ Multi-platform support
What Doesn't Work Yet:
❌ File uploads - Can't scan PDF/DOCX files users upload
❌ Images - No OCR for text in screenshots
❌ Audio - No speech-to-text PII scanning
❌ Context awareness - May flag legitimate business terms
These are future enhancements. For now, it's a proof-of-concept that shows what's possible.

Proposed Use Cases
Healthcare
Could protect HIPAA-compliant patient data when using AI for medical research or documentation.
Legal Services
Could ensure client confidentiality during AI-assisted legal research.
Financial Services
Could prevent exposure of customer account numbers and financial data.
Enterprise
Could maintain corporate data policies across all employee AI usage without blocking access.
Note: These are potential applications. Production deployment would require thorough testing and compliance validation.

Performance Characteristics
Latency:

AI detection: Local processing with Gemini Nano
Regex fallback: Near-instantaneous
User-perceived delay: Minimal (asynchronous)

Resource Usage:

Lightweight Chrome extension
Minimal CPU (burst processing only)
Small storage footprint

Performance depends on device capabilities and whether Gemini Nano model is downloaded.

Comparison with Existing Solutions
FeatureEnterprise DLPCloud ScannerPII ShieldCost$50,000+/year$10,000+/year$0PrivacyProxy accessCloud processingOn-device onlySetup3-6 months1-2 monthsUnder 5 minutesLatencyNetwork-dependentNetwork-dependentMinimalOfflineNoNoYesQuotasLicense-basedAPI limitsNone

What I Learned Building This

Chrome's Prompt API is Powerful Being able to run Gemini Nano locally with custom system prompts is game-changing. You can build sophisticated AI features without any cloud dependency.
Edge AI Enables New Applications Applications that were impossible due to privacy or cost constraints are now feasible. Think:

Medical AI processing health data locally
Financial AI analyzing sensitive transactions on-device
Personal AI assistants with true privacy

User Experience Matters The extension had to be completely transparent. Users shouldn't need to change their workflow. It just works silently in the background.
Fallback Systems are Critical Not everyone has Gemini Nano downloaded. Having regex fallback ensures the extension provides value immediately while AI capabilities enhance it.

Technical Challenges Solved
Problem 1: Gemini's React Components
Gemini uses complex React components, not standard textareas. Standard document.execCommand didn't work.
Solution: Multi-method text insertion with fallbacks:
javascript// Try multiple insertion methods
if (target.tagName === 'TEXTAREA') {
target.value = maskedText;
} else if (target.isContentEditable) {
document.execCommand('insertText', false, maskedText);
} else {
// Find any editable element on page
const editables = document.querySelectorAll('[contenteditable="true"]');
editables[editables.length - 1].textContent = maskedText;
}
Problem 2: Paste Event Timing
Needed to intercept paste events before React processes them.
Solution: Capture phase with proper event handling:
javascriptdocument.addEventListener('paste', handler, true); // Capture phase
e.preventDefault();
e.stopPropagation();
Problem 3: Stats Persistence
Chrome extensions can't use localStorage reliably across sessions.
Solution: Chrome Storage API with daily reset logic:
javascriptconst result = await chrome.storage.local.get(['maskedToday', 'lastReset']);
const today = new Date().toDateString();

if (result.lastReset !== today) {
await chrome.storage.local.set({ maskedToday: 0, lastReset: today });
}

Development Context
This project was built for the Google Chrome Built-in AI Challenge 2025, a hackathon showcasing innovative applications of Chrome's built-in AI capabilities.
The challenge provided access to:

Prompt API (what I used)
Summarizer API
Writer API
Rewriter API
Translator API
Proofreader API

My background includes building CareCircle++, a zero-knowledge healthcare coordination platform that attracted NHS Digital interest. That experience with privacy-first architecture directly informed PII Shield's design.
In healthcare, data protection isn't optional - it's legally mandated and ethically critical. Those same principles apply to enterprise AI usage.

Future Roadmap
If I continue developing this:
Phase 1: Core Improvements

File upload scanning (PDF, DOCX parsing)
Whitelist management for approved terms
Custom regex patterns for company-specific IDs
Improved context awareness

Phase 2: Enterprise Features

Centralized policy management
Compliance audit reports
Team deployment tools
Integration with existing DLP systems

Phase 3: Advanced AI

Multimodal support (images, audio)
Hybrid strategy with Firebase AI Logic
Machine learning for better detection
Industry-specific patterns (medical, legal, financial)

Installation & Testing
Requirements:

Chrome 127 or later
Enable Chrome Built-in AI flags:

chrome://flags/#optimization-guide-on-device-model → Enabled
chrome://flags/#prompt-api-for-gemini-nano → Enabled
Restart Chrome

Installation:

Download from GitHub (link will be added)
Go to chrome://extensions/
Enable "Developer mode"
Click "Load unpacked"
Select the folder

Testing:
Open the included test.html file with sample PII data, or try it on ChatGPT/Claude.

Key Takeaways
For Developers:

Chrome's built-in AI is production-ready for client-side applications
Edge computing enables new privacy paradigms previously impossible
Zero-cost AI inference opens doors for indie developers and startups
Hybrid approaches work - AI primary, regex fallback

For Companies:

DLP doesn't have to be expensive - client-side solutions can work
Privacy and productivity aren't opposed - you can have both
Browser extensions can solve enterprise problems without complex infrastructure
AI safety requires new thinking - traditional approaches don't scale

For Privacy Advocates:

On-device AI is the future of privacy-preserving applications
Users can be protected transparently without friction
Open source matters - privacy tools should be auditable
Edge computing wins when privacy is critical

Open Questions
I'm still figuring out:

File uploads: How to efficiently parse and scan uploaded documents client-side?
Context sensitivity: How to reduce false positives for legitimate business terms?
Enterprise adoption: What features would compliance teams need?
Monetization: Should this be free and open source, or commercial with enterprise features?

What do you think? Drop your thoughts in the comments.

Conclusion
PII Shield demonstrates that powerful privacy protection can run entirely on-device using Chrome's built-in AI. No servers, no costs, no compromises.
While this is a proof-of-concept with limitations (especially file uploads), it shows what's possible when AI moves to the edge.
As LLMs become ubiquitous in workplaces, privacy-preserving architectures like this will be essential. The technology exists. Now we need to build it.
The Google Chrome Built-in AI Challenge 2025 showed me that client-side AI isn't just a nice-to-have - it's a fundamental shift in what's possible for privacy-critical applications.
Try it out:

GitHub: [Link will be added after submission]
Demo Video: [YouTube link will be added]
Feedback: kanchan@ikanchan.com

About Me
I'm Kanchan, an Independent AI Developer with 16+ years of software development experience. I've built 6+ production AI applications across healthcare, education, real estate, and gaming.
My previous work includes CareCircle++, a privacy-first healthcare platform that attracted NHS Digital interest. I hold an MBA and Google certifications in Gemini and Vertex AI.
Connect with me:

Website: www.ikanchan.com
Email: kanchan@ikanchan.com
GitHub: [Your profile]

Discussion Questions

Would you trust a client-side PII scanner in your organization?
What other privacy-critical applications could benefit from edge AI?
Should this be open source or commercial?
What detection features would make this production-ready for your use case?

Drop your thoughts below!

Tags: #chrome #ai #privacy #security #webdev #machinelearning #chromeextension #llm #gdpr #compliance

This article is based on my submission to the Google Chrome Built-in AI Challenge 2025. Full technical white paper available on my website.