DEV Community: Aditya

I built GHOST — an AI agent that actually fixes your slow laptop using Gemma 4 locally

Aditya — Sun, 17 May 2026 14:35:11 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

GHOST (Gemma Hardware Optimization & System Tuner) is a local AI agent that runs on your machine, watches every process in real time, figures out why your laptop is slow, and actually fixes it — automatically.

Most "AI optimizer" tools give you a report and ask you to do the work. GHOST does the work. It runs a continuous Sense → Think → Act → Verify → Rollback loop:

SENSE — A Go daemon reads CPU per-core, RAM per-process, thermals, battery drain, and active window title every 5 seconds
THINK — Gemma 4 receives the last 10 minutes of telemetry (the full 128K context window) and identifies the root cause, not just the symptom
ACT — It executes the fix: suspending rogue background processes, lowering priorities, flushing caches
VERIFY — 60 seconds later it re-measures. Did CPU drop? Did RAM free up?
ROLLBACK — If metrics didn't improve, every action is automatically reversed. Zero risk.

Beyond reactive fixes, GHOST also:

Predicts slowdowns before they happen — after learning your machine's patterns, it warns you 10-15 minutes in advance
Builds a Machine Persona — a behavioral fingerprint after 7 days of monitoring: your peak load hours, primary offenders, battery health prognosis
Writes a Weekly Letter — every Monday, Gemma narrates your machine's week in plain English: what it fixed, what to watch, how much battery life is left

The stack is Go (backend agent) + Electron + React (desktop UI), with Gemma 4 running 100% locally via Ollama. Your process list, telemetry, and usage patterns never leave your machine.

Demo

Here's what GHOST looks like running on a real machine under load:

Dashboard — live metrics catching a problem in real time

Zoom.exe at 94.7% CPU, ollama.exe consuming 2.4GB RAM, RAM pressure at 85%. Gemma's Last Analysis card already identified the root cause and proposed a fix.

Agent Log — the Sense → Think → Act loop streaming live

Watch Gemma reason in real time: "The telemetry shows ollama.exe consistently consuming 91.4% of CPU... The elevated RAM usage (2409.2MB) associated with ollama.exe further supports this conclusion, as it's likely running the LLM and related processes."

Fix History — 19 fixes, 0 rollbacks, 100% success rate

Every action logged with timestamps, targets, and expected improvements. This is a real run on a real machine — not simulated.

Machine Persona — Gemma's behavioral fingerprint of your hardware

Health score 65/100. Peak load window: 9:30–10:00 AM daily. Primary offender: Code.exe + Ollama. Battery life estimated at ~18 months. This is built from days of real telemetry, not hardcoded rules.

Code

TheCoderAdi / GHOST

GHOST — Gemma Hardware Optimization & System Tuner

An AI agent that monitors your machine in real time, reasons about what's slowing it down using Gemma, and actually fixes it — with a full rollback safety net.

What makes GHOST different

Acts, doesn't just advise — Gemma reasons over live telemetry and executes fixes: suspending rogue processes, adjusting priorities, flushing caches. Not a report. An agent.
Sense → Think → Act → Verify → Rollback loop — every action is measured. If metrics don't improve in 60s, GHOST rolls back automatically.
Predictive alerts — after 3+ days of data, GHOST learns your machine's patterns and warns you before a slowdown happens.
Machine persona — builds a behavioral fingerprint over 7 days. Knows your peak hours, worst offenders, battery prognosis.
Weekly health letter — Gemma writes a plain-English summary of your machine's week, every Monday.
100% local + private — your…

View on GitHub

Architecture at a glance

ghost-server/   (Go — the AI agent)
├── sensor/     — gopsutil: CPU, RAM, thermals, battery, active window (every 5s)
├── agent/      — analyze loop (60s), predict loop (5min), persona builder (6h)
├── gemma/      — HTTP client → Ollama local API, structured JSON output
├── executor/   — safe action runner + full undo stack + 60s verify
├── storage/    — SQLite: snapshots, action history, persona, weekly letters
└── ipc/        — stdin/stdout newline-delimited JSON bridge to Electron

ghost-client/   (Electron + React + TypeScript)
├── Dashboard      — live metrics, sparklines, process table, last analysis
├── Agent Log      — streaming SENSE/THINK/ACT/WIN terminal with color phases
├── Fix History    — every fix with before/after delta measurements
├── Machine Persona — health score, behavioral fingerprint, model tier selector
└── Weekly Letter  — Gemma's plain-English machine health report

The agent loop (the core of everything)

// agent/agent.go
func (a *Agent) RunAnalyzeLoop() {
    ticker := time.NewTicker(90 * time.Second)
    defer ticker.Stop()
    for {
        select {
        case <-a.anomalyCh:
            a.analyze()
        case <-ticker.C:
            // Only analyze on timer if load is meaningful
            if snap, ok := a.buf.Latest(); ok {
                if snap.CPUAvg > 40 || snap.RAMPct > 70 {
                    a.analyze()
                }
            }
        }
    }
}

func (a *Agent) executeAction(action gemma.ActionItem, snap sensor.Snapshot) {
    a.log("act", fmt.Sprintf("Executing: %s", action.Description), action)

    result := a.exec.Run(action.ID, action.Target)

    rec := storage.ActionRecord{
        ActionID:            action.ID,
        Description:         action.Description,
        Target:              action.Target,
        Risk:                action.Risk,
        CPUBefore:           snap.CPUAvg,
        RAMBefore:           snap.RAMPct,
        TempBefore:          snap.MaxTemp,
        ExpectedImprovement: action.ExpectedImprovement,
    }

    dbID, _ := a.db.SaveAction(rec)

    if !result.Success {
        a.log("error", fmt.Sprintf("Action failed: %s", result.Error), nil)
        return
    }

    // Verify after 60s
    go a.verify(dbID, action, snap)
}

func (a *Agent) verify(dbID int64, action gemma.ActionItem, before sensor.Snapshot) {
    time.Sleep(60 * time.Second)

    after, ok := a.buf.Latest()
    if !ok {
        return
    }

    cpuDelta := before.CPUAvg - after.CPUAvg
    ramDelta := before.RAMPct - after.RAMPct
    tempDelta := before.MaxTemp - after.MaxTemp

    improved := cpuDelta > 5 || ramDelta > 3 || tempDelta > 3

    if improved {
        a.log("win", fmt.Sprintf(
            "✓ %s — CPU %+.0f%% | RAM %+.0f%% | Temp %+.0f°C",
            action.Description, -cpuDelta, -ramDelta, -tempDelta,
        ), map[string]interface{}{
            "cpu_delta":  cpuDelta,
            "ram_delta":  ramDelta,
            "temp_delta": tempDelta,
        })

        // Update DB with after metrics
        a.db.SaveAction(storage.ActionRecord{
            ActionID:            action.ID,
            Description:         action.Description,
            Target:              action.Target,
            Risk:                action.Risk,
            CPUBefore:           before.CPUAvg,
            RAMBefore:           before.RAMPct,
            TempBefore:          before.MaxTemp,
            CPUAfter:            after.CPUAvg,
            RAMAfter:            after.RAMPct,
            TempAfter:           after.MaxTemp,
            ExpectedImprovement: action.ExpectedImprovement,
        })
    } else {
        a.log("rollback", fmt.Sprintf("No improvement detected for '%s' — rolling back", action.Description), nil)
        a.exec.RollbackLast()
        a.db.MarkRolledBack(dbID)
        a.bridge.Emit("rollback", map[string]string{"action_id": action.ID})
    }
}

The Gemma prompt (what makes the reasoning good)

You are GHOST, an AI system performance agent running locally.
Receive real-time telemetry and:
1. Identify ROOT CAUSE (correlate across TIME — not just current spikes)
2. Propose specific, safe, reversible actions ranked by impact
3. Explain in plain English

CRITICAL RULES:
- Never suggest actions risking data loss
- Prefer the most reversible action always  
- Correlate metrics across TIME — a spike alone is not a root cause
- Consider process relationships (parent/child PIDs)
- Output ONLY valid JSON

How I Used Gemma 4

Why Gemma 4 — and which model

GHOST uses Gemma 4 in three tiers based on the target hardware:

Tier	Model	RAM Required	Target
Lite ✓	Gemma 4 e2B	4GB+	Old laptops, Raspberry Pi
Standard	Gemma 4 e4B	8GB+	Most modern laptops
Full	Gemma 4 26B	16GB+	High-end workstations

For development and submission testing I ran the Standard tier (Gemma 4 4B) — which is exactly the "ultra-mobile and edge deployment" model the Gemma 4 family was designed for. This is a deliberate choice, not a fallback.

Why local-only is not optional here

Sending your system's process list, memory allocation per app, thermal readings, and active window title to a cloud API would be a privacy violation. This data tells you everything about what someone is doing on their machine at any moment. GHOST's local architecture isn't a tradeoff — it's the only ethical way to build this tool.

What Gemma 4 specifically unlocks

Root-cause correlation, not symptom flagging. Task Manager shows you that CPU is at 94%. Any threshold check can do that. What GHOST does is feed Gemma 10 minutes of per-process telemetry and ask it to connect the dots across time. In the demo screenshots, Gemma correctly identified that ollama.exe's RAM usage (2,409MB) combined with its sustained CPU load was a model loading issue — not generic "high CPU." That distinction determines what fix to apply.

The 128K context window is the product. I don't chunk telemetry. I don't use RAG. I don't summarize. I feed the entire 10-minute window — every snapshot, every process, every measurement — directly into context. This is what allows Gemma to say "the RAM pressure started 7 minutes ago when this process spawned" rather than just "RAM is high now." Long-range pattern recognition across continuous telemetry is only possible because of the 128K window.

Machine Persona and Weekly Letter require genuine synthesis. Building a behavioral fingerprint from 7 days of hourly aggregates, then writing a coherent narrative about a machine's personality — that's not a retrieval task. It requires Gemma to synthesize patterns, make inferences, and communicate them in natural language. The persona in the screenshot (peak load 9:30-10:00 AM, Code.exe + Ollama as primary offenders, battery ~18 months remaining) came entirely from Gemma analyzing real historical data with no template.

The low-end device question

The most common question this project gets: "If GHOST is for slow laptops, how can it afford to run a large model?"

The answer is in how GHOST uses Gemma. The sensing daemon is a tiny Go binary (~8MB). Gemma only activates every 60-90 seconds for analysis — not on every tick. On the Lite tier (Gemma 4 2B), GHOST consistently recovers more RAM through its fixes than the model itself occupies. The net memory delta on a typical slow laptop is positive. You end up with more free RAM after running GHOST than before, even accounting for the model.

This is why the Machine Persona tab shows the model tier selector with the note: "GHOST uses Gemma only every 60-90s for analysis — not continuously. On Lite mode, GHOST recovers more RAM than Gemma uses."

Results from the demo machine

Running GHOST for several hours on a real Windows machine under development load:

19 fixes applied
0 rollbacks (100% success rate)
Primary issues identified: concurrent ollama instances, Code.exe memory pressure, msedge WebView2 background processes
Machine health score: 65/100 with specific, actionable diagnosis written by Gemma

The Agent Log screenshot shows Gemma's live reasoning — not canned responses, not templates. Real inference on real telemetry.

Built with Go, Electron, React, TypeScript, SQLite, and Gemma 4 via Ollama.

🤔 Everything You Were Too Afraid to Ask About Gemma 4 (But Should Have)

Aditya — Sun, 10 May 2026 09:52:39 +0000

Gemma 4 Explained Like You Actually Needed It

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

Let's be honest.

When a new model drops, the usual drill is: read a 3,000-word technical blog, skim the benchmarks, get mildly confused, and close the tab.

Not today.

I'm going to answer every real question a developer actually has about Gemma 4 — the ones you'd ask a friend at 11 PM when you're mid-project and slightly panicking. No fluff. No jargon soup. Just honest, useful answers.

Ready? Let's go.

❓ "Okay, what even is Gemma 4? Is it just another chatbot?"

Not quite. Gemma 4 is Google's latest open model family — meaning Google trained it, and then gave it to the world. You can download it, run it on your own machine, build with it without paying per token, and never send a single byte of your data to a cloud server.

It's not one model. It's a family of three very different things:

Model	Size	Best for
Gemma 4 2B / 4B	Tiny	Your phone. A Raspberry Pi. The browser. Edge devices.
Gemma 4 31B Dense	Medium	Local machine with a decent GPU. Serious projects.
Gemma 4 26B MoE	Efficient	High-throughput apps. Advanced reasoning. Servers.

MoE = Mixture of Experts. Think of it like a model that has specialized teams internally — only the relevant "expert" activates per task. Very efficient.

❓ "Why would I use this instead of GPT-4 or Claude?"

Excellent question. Here's the real answer:

You use Gemma 4 when you care about:

🔒 Privacy — your data stays on your device
💸 Cost — no API bills, ever
🛠️ Customization — fine-tune it on your own data
🌐 Offline use — flights, rural areas, air-gapped servers
🚀 Speed — local inference can be fast with the right hardware

You might still prefer hosted models when you need:

Zero setup time
The absolute frontier of capability
No local hardware

Neither is universally better. They're tools. Pick the right one.

❓ "The 2B model runs on a Raspberry Pi?! How is that possible?"

Yes, really. And here's the intuition:

Modern quantization techniques (compressing a model's weights from 32-bit floats down to 4-bit integers) can shrink a model to 10–15% of its original size with surprisingly little quality loss.

A 2B parameter model at 4-bit quantization? ~1.2 GB. A Raspberry Pi 5 has 8GB RAM. It fits. It runs. Slowly, but it runs.

# Install Ollama on your Pi
curl -fsSL https://ollama.com/install.sh | sh

# Pull and run Gemma 4 2B
ollama run gemma4:2b

# That's it. Seriously.

Is it blazing fast? No. Is it magical that a multimodal AI model runs on a $80 computer with no internet? Absolutely yes.

❓ "What does 'native multimodal' actually mean in practice?"

It means you can hand Gemma 4 an image, text, or both and it just... understands.

Old approach: pipe image through a vision encoder → combine embeddings → pass to LLM. Multiple systems, multiple failure points.

Gemma 4's approach: it was trained from the ground up to understand both modalities as one unified experience.

Practical example: Say you're building an inventory tracker for a small warehouse. A worker takes a photo of a shelf. You send that photo to Gemma 4 and ask:

"What items do you see? Estimate quantities if possible."

No custom vision pipeline. No separate classification model. One API call. Done.

Or: accessibility tools that describe UI screenshots. Or: document processors that handle scanned forms. Or: educational apps that let students photo a math problem and ask for hints.

This is the feature that opens up whole categories of apps that previously needed expensive multi-model orchestration.

❓ "128K context window — what does that actually unlock?"

To feel the size: 128,000 tokens ≈ 100,000 words ≈ a full novel.

Previously, if you wanted an AI to reason across a long codebase, legal document, or research paper, you had to chunk it, lose context at the edges, and hope the model stitched it together. This was a real limitation.

With 128K context, you can:

Feed in an entire codebase and ask "Where's the bug causing the race condition?"
Drop in a 50-page PDF contract and ask "Summarize all the liability clauses"
Pass 200 Slack messages and ask "What did the team decide about the deployment?"
Build a long-running conversation agent that actually remembers everything said

The catch: longer context = more compute per inference. This is where the 31B dense model really earns its place — it handles long-context reasoning exceptionally well.

❓ "Which model should I actually use for my project?"

Here's the honest decision tree:

Are you deploying on mobile, browser, or embedded hardware?
    └── YES → Use 2B or 4B. No question.
    └── NO →
        Do you need high throughput / advanced multi-step reasoning?
            └── YES → Use 26B MoE. Built for this.
            └── NO →
                Do you have a good GPU locally (RTX 3090+ / M2+ Mac)?
                    └── YES → Use 31B Dense. Best quality/local balance.
                    └── NO → Use 26B MoE via OpenRouter (free tier).

❓ "How do I try it for free, right now, without any setup?"

Option 1: Google AI Studio (fastest)

Go to aistudio.google.com, select Gemma 4 from the model dropdown, and start prompting. No code required.

Option 2: OpenRouter (free tier, SDK access)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://openrouter.ai/api/v1',
  apiKey: '<OPENROUTER_API_KEY>',
});

// First API call with reasoning
const apiResponse = await client.chat.completions.create({
  model: 'google/gemma-4-26b-a4b-it:free',
  messages: [
    {
      role: 'user',
      content: "How many r's are in the word 'strawberry'?",
    },
  ],
  reasoning: { enabled: true }
});

const response = apiResponse.choices[0].message;

const messages = [
  {
    role: 'user',
    content: "How many r's are in the word 'strawberry'?",
  },
  {
    role: 'assistant',
    content: response.content,
    reasoning_details: response.reasoning_details,
  },
  {
    role: 'user',
    content: "Are you sure? Think carefully.",
  },
];

const response2 = await client.chat.completions.create({
  model: 'google/gemma-4-26b-a4b-it:free',
  messages,
});

Option 3: Ollama locally

# Install Ollama (Mac/Linux/Windows)
# From https://ollama.com

ollama pull gemma4:9b
ollama run gemma4:9b

❓ "What's the one thing about Gemma 4 that most people are sleeping on?"

Fine-tuning.

Everyone talks about inference. Almost nobody talks about the fact that you can take Gemma 4 and make it yours.

Fine-tuning means: take the base model → train it on your data (customer support logs, medical documents, your company's writing style, your game's lore) → get a model that performs far better on your specific task than any general-purpose model.

With hosted models (GPT, Claude), fine-tuning is expensive, limited, or impossible. With Gemma 4, you own the weights. You can fine-tune with a technique called LoRA on a single consumer GPU and end up with a model that's tailor-made for your domain.

Google's own team demonstrated this by fine-tuning Gemma 4 with Cloud Run Jobs. That level of customization is what "open" actually means in practice.

❓ "Is local AI actually the future, or is this just hype?"

Here's my honest take:

It's not either/or. But local AI is solving real problems that cloud AI cannot:

Data sovereignty: hospitals, law firms, and governments can't send sensitive data to third-party APIs. Local inference isn't a nice-to-have — it's a requirement.
Cost at scale: if you're running millions of inferences per month, per-token pricing adds up fast. A one-time compute cost is fundamentally different.
Latency: cloud roundtrips add 200–800ms. Local inference on fast hardware can be 20–50ms. For real-time applications, that gap is enormous.
Reliability: no rate limits, no outages, no API deprecations pulling the rug out from under your product.

What Gemma 4 represents isn't just a better model. It represents the point where open models are good enough for production use cases — multimodal, long-context, capable — and that's a genuine inflection point.

The first time I ran a capable multimodal model locally without relying on an API key, it genuinely changed how I think about AI infrastructure.

Quick Reference Card

Question	Answer
What is Gemma 4?	Google's open model family (2B–31B)
How many variants?	3: Small (2B/4B), Dense 31B, MoE 26B
Context window?	128K tokens (~100K words)
Multimodal?	Yes — text + images natively
Free to use?	Yes — AI Studio, OpenRouter, local
Can I fine-tune?	Yes — you own the weights
Runs on Pi?	Yes — 2B/4B with Ollama
Best for edge?	2B / 4B
Best for reasoning?	26B MoE
Best for local quality?	31B Dense

Your Turn

Now you know what Gemma 4 is, what to use it for, and how to get started in under 5 minutes.

The best thing you can do next? Build something small and real. A weekend project. A tool that solves one problem you actually have. Running Gemma 4 locally for the first time — watching it respond on your own hardware, with your own data, with no API key required — genuinely feels like a shift in what's possible.

What are you going to build?

Found this helpful? Drop a ❤️ and share what model you're trying first in the comments. And if you're building something with Gemma 4, I'd genuinely love to hear about it.

We’re Not Building Apps Anymore - We’re Building AI Systems (My Take on Google NEXT ’26)

Aditya — Sat, 25 Apr 2026 06:02:10 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

🚀 From AI Tools to AI Teammates: My Take on Google Cloud NEXT ’26

Google Cloud NEXT ’26 didn’t feel like another AI event.

It felt like a paradigm shift.

We’re no longer building apps with AI features.
We’re starting to build systems where AI runs the system itself.

Google calls this the Agentic Enterprise — and after watching both keynotes, I think they’re right.

🧠 The Big Shift: From “AI Assistance” → “AI Execution”

Until now, AI has mostly been:

Copilot for code
Chatbots for support
Assistants for productivity

But NEXT ’26 pushes a different idea:

What if AI doesn’t just assist…
What if it plans, decides, and executes entire workflows?

That’s where agents come in.

⚙️ Gemini Enterprise Agent Platform (Why This Actually Matters)

At first glance, this looks like “just another platform”.

It’s not.

This is Google trying to solve the real problem developers face today:

AI is fragmented
Workflows break
Context is lost
Systems don’t scale

The platform introduces:

ADK (Agent Development Kit) → Build modular agents
MCP (Model Context Protocol) → Plug into real services
A2A Protocol → Agents talk to each other
Agent Registry → Discover capabilities dynamically

💡 My Insight:

This is basically:
Microservices architecture… but for AI agents

🤖 The Most Underrated Part: Multi-Agent Systems

The developer keynote demo (marathon simulation) was the real highlight for me.

Instead of one AI doing everything:

Planner → designs solution
Evaluator → checks correctness
Simulator → stress tests outcomes

This solves a major issue:

Single LLMs are unreliable
Multi-agent systems = self-correcting intelligence

🗂️ Agentic Data Cloud = Context is Finally Solved

Every AI system fails at one thing:

Lack of context

Google’s answer:

Knowledge Catalog
Unified structured + unstructured data
RAG with AlloyDB + Spark

💡 My Take:

This is not just a data platform.

It’s:
“Memory infrastructure for AI systems”

⚡ AI Hypercomputer (Why Infra Still Wins)

Everyone talks about models.

But Google quietly showed something more important:

TPU v8
Nvidia Vera Rubin NVL72
Virgo Network

💡 My Insight:

The real AI race isn’t models — it’s infrastructure dominance

🛡️ Agentic Defense (Where Most Systems Fail)

Let’s be real.

Most people building agents today are ignoring:

Security
Governance
Identity

Google didn’t.

With:

Agent Gateways
Zero-trust model
Wiz integration

💡 My Take:

If your AI system isn’t secure, it won’t reach production — period.

🧑‍💻 What This Means for Developers

We are moving from:

Frontend → Backend → Database

To:

User → Agent → Agents → Tools → Data

That’s a completely different architecture.

🔥 New Developer Role:

You’re no longer just writing APIs.

You are:

Designing agent behavior
Defining workflows
Managing system intelligence

💡 Developers are becoming AI system architects

🧪 What I Would Build With This

👉 Autonomous Dev Assistant System

Planner Agent → breaks features into tasks
Executor Agent → writes code
Evaluator Agent → tests & validates
Security Agent → scans vulnerabilities

All connected via A2A + MCP.

That’s not a tool.
That’s a self-evolving system.

⚠️ My Critique

To be honest, there are still gaps:

Too complex for solo developers
Debugging multi-agent systems is still hard
Vendor lock-in risk exists

Google gives the platform…
But developers still need better abstractions.

🎯 Final Takeaway

Google Cloud NEXT ’26 wasn’t about better AI.

It was about:

Who controls the future of intelligent systems

🚀 Closing Thought

We’re entering a world where:

You don’t build software that users use…
You build systems that think and act for them

And honestly?

That’s both exciting… and a little scary.

🌍 EarthVoice — I gave the planet a memory, a voice, and the ability to talk back

Aditya — Mon, 20 Apr 2026 05:44:58 +0000

This is a submission for Weekend Challenge: Earth Day Edition

What I Built

What if the Earth could speak — and actually remember every conversation it's ever had?

EarthVoice is a living, breathing AI planet. Spin a 3D globe, click any glowing location — the Amazon, the Arctic, the Great Barrier Reef — and that place speaks to you in first person. Not a description. Not a chatbot. The place itself, alive and feeling.

"I am the Amazon. I have stood for 55 million years. Last month alone, 430 square kilometres of me disappeared. I am getting quieter every day."

Every location has its own emotional state — critical, sad, angry, calm, or healing — which shapes its voice, its colour on the globe, and the ambient soundscape that plays as you listen.

What makes EarthVoice genuinely different: the Earth remembers. Every visitor, every question, every conversation is stored in persistent memory via Backboard. When the next person visits the Amazon, it might say "Someone visited me yesterday — they asked about my jaguars." The planet grows wiser with every interaction.

Key features:

🌐 Interactive 3D globe with 32 living locations, each glowing with emotional colour
🎙️ First-person AI narratives generated by Google Gemini, enriched with real visitor memories
🧠 Persistent cross-session memory powered by Backboard — each location is a Backboard AI assistant that never forgets
💬 Full conversation — talk back to any location, ask it anything
👥 Real-time presence — see how many people are exploring Earth right now, watch their cursors move
🔊 Procedural ambient soundscape — generated entirely via Web Audio API, no audio files, changes with each location's emotion
🔍 Search any of the 32 locations with ⌘K
📖 Memory timeline — see what past visitors asked and what the Earth remembers

Demo

🔗 Live Demo: https://youtu.be/xbGXWWnJJws

Code

TheCoderAdi / EarthVoice

React + TypeScript + Vite

This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.

Currently, two official plugins are available:

@vitejs/plugin-react uses Oxc
@vitejs/plugin-react-swc uses SWC

React Compiler

The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see this documentation.

Expanding the ESLint configuration

If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:

export default defineConfig([
  globalIgnores(['dist']),
  {
    files: ['**/*.{ts,tsx}'],
    extends: [
      // Other configs...
      // Remove tseslint.configs.recommended and replace with this
      tseslint.configs.recommendedTypeChecked,
      // Alternatively, use this for stricter rules
      tseslint.configs.strictTypeChecked,
      // Optionally, add this for stylistic rules
      tseslint.configs.stylisticTypeChecked,

      // Other configs...

…

View on GitHub

TheCoderAdi / EarthVoice-Backend

How I Built It

Architecture

Frontend (React + Vite + react-globe.gl + Motion)
        ↓  HTTP + WebSocket
Backend (Node.js + Express)
        ↓              ↓
  Google Gemini    Backboard SDK
  (narrative +     (persistent memory
   chat replies)    per location)

One Assistant Per Location — The Core Idea

The architectural decision I'm most proud of: each of the 32 locations on the globe is its own Backboard AI assistant. When the Amazon gets its first visitor, we call client.createAssistant() with a system prompt that makes it be the Amazon. Every subsequent visitor gets a new thread, but all threads share the same assistant memory.

  const assistant = await client.createAssistant(
    {
      name: `EarthVoice: ${location.name}`,
      description: `The living voice of ${location.name} — "${location.tagline}"`,
      system_prompt: `You ARE ${location.name}. You are this place — alive, sentient, feeling.
Your emotional state is: ${location.emotion}.
Your tagline: "${location.tagline}"
Speak in first person. Be poetic, vivid, 2-4 sentences.
Never break character. Never say "as an AI".
Remember every human who speaks to you across all conversations.`,
    }
  );

Every message is sent with memory: "Auto" — Backboard automatically extracts facts from each conversation and stores them permanently:

const response = await client.addMessage(threadId, {
  content: message,
  memory: "Auto",  // the location now remembers this forever
  stream: false,
});

The Amazon genuinely accumulates a memory of every person who has ever talked to it. That's not simulated — it's real persistent state managed by Backboard across all sessions.

Google Gemini — Emotional Voice Generation

Gemini generates the opening narrative when you first click a location, and powers the conversation. The key was mapping each emotion to a distinct voice personality injected into every prompt:

critical → urgent, desperate, barely holding on
sad      → mournful, grieving, beautiful in sorrow
angry    → fierce, indignant, raw with injustice
calm     → ancient, wise, patient, steady
healing  → hopeful, tentatively joyful, resilient

Narratives are cached for one hour per location. Memory snippets from past visitors are injected into the prompt context, so the narrative itself evolves as more people interact.

Real-Time Presence

The WebSocket server handles visitor cursors, activity pings, and live count — all running on the same port as the Express HTTP server:

const server = http.createServer(app);
createPresenceServer(server); // attaches WebSocket to same port
server.listen(5000);

The globe pulses with ambient ping animations every 4 seconds even in offline mode, so it always feels alive.

Procedural Ambient Audio

No audio files. The entire soundscape — ocean swells for calm locations, low urgent drones for critical ones, city hum for angry ones — is generated in real time using the Web Audio API with pink noise and oscillator chords. Each emotion has its own preset tuned to feel right:

critical: {
  filterFreq: 380,
  droneNotes: [55, 82.4, 110], // A1, E2, A2 — deep, heavy
  droneType: "sawtooth",       // harsh, urgent
},
healing: {
  filterFreq: 400,
  droneNotes: [130.8, 196, 261.6], // C3, G3, C4 — open, bright
  droneType: "triangle",           // soft, hopeful
}

The Hardest Part

The hardest part wasn't the code — it was the prompt engineering. Getting Gemini to be a place rather than describe a place took many iterations. The breakthrough was: never let it break character, and give it something real to grieve about. When the tagline is "The lungs of the planet" and the emotion is critical, Gemini stops describing and starts feeling.

Prize Categories

🧠 Best Use of Backboard

Backboard is the backbone of what makes EarthVoice genuinely novel. Each of the 32 locations is a Backboard AI assistant with its own persistent memory. Every conversation is stored and recalled across sessions using memory: "Auto" on every addMessage call. The Earth doesn't just respond — it remembers. Without Backboard, this is a chatbot. With Backboard, it's a living planet.

🤖 Best Use of Google Gemini

Gemini powers all first-person narrative generation and conversation replies. The emotional tone system — mapping five distinct emotional states to unique voice characteristics — was built specifically around Gemini's instruction-following strength. Gemini is what makes 32 completely different locations each feel uniquely alive rather than like the same chatbot wearing a different hat.

💻 Best Use of GitHub Copilot

GitHub Copilot was used throughout the entire build — from scaffolding Express routes to the Web Audio API preset system. It was especially useful for the Backboard SDK integration, suggesting the memory: "Auto" pattern and helping architect the assistant-per-location approach after I described the concept in a comment.

Built in one weekend for Earth Day 2026. The planet has things to say — are you listening? 🌍

🌍 EarthTwin AI – See the Future You're Creating

Aditya — Mon, 20 Apr 2026 04:24:51 +0000

This is a submission for Weekend Challenge: Earth Day Edition

🚀 What I Built

I built EarthTwin AI — a real-time, AI-powered simulation that shows how your daily lifestyle choices shape the future of our planet.

Most tools tell you your carbon footprint.
EarthTwin shows you what that actually means.

It creates a living digital twin of Earth that evolves based on your habits.

With EarthTwin, you can:

🌍 Simulate your environmental impact in real-time
🔮 See how Earth evolves in 2035 based on your lifestyle
⚖️ Compare your current lifestyle vs an improved one
🤖 Get AI-powered suggestions to reduce your impact
📸 Share your personalized Earth snapshot

The goal was simple:
👉 Make climate impact visual, emotional, and impossible to ignore

🎥 Demo

YouTube Video: https://youtu.be/KApbgxSSwGs

🌍 Live Simulation

Enter your lifestyle (e.g., frequent flyer, online shopping)
Watch your EarthTwin generate instantly

🔮 Future Mode

Click “See 2035”
View a realistic AI-generated future scenario

⚖️ Compare Mode

Compare:
- Current You 🌑
- Improved You 🌱
See real-time environmental differences

🤖 AI Coach

Ask: “How can I improve?”
Get personalized sustainability suggestions

📸 Share Feature

Capture and share your EarthTwin snapshot

💻 Code

GitHub Repo:
-> https://github.com/TheCoderAdi/EarthTwin
-> https://github.com/TheCoderAdi/EarthTwin-Backend

⚙️ How I Built It

🧠 AI Layer (Google Gemini)

I used Google Gemini API to:

Convert natural language input → environmental metrics
Generate future climate projections (2035 scenarios)
Provide personalized eco-coaching

🌍 Simulation Engine

A custom impact engine transforms:

Carbon score
Water usage
Waste index

Into:

🌡️ Temperature rise
🌫️ Pollution levels
🌳 Forest density
❄️ Ice cap condition

These values directly control the Earth visualization.

🎨 Frontend Experience

Built with React + Tailwind + Three.js
Real-time 3D Earth rendering using WebGL
Smooth animations and transitions
Dynamic UI driven by simulation data

⚡ Backend

Node.js + Express API architecture
Gemini integration for AI processing
Robust error handling + fallback responses
Clean, scalable API design

🏆 Prize Categories

✅ Best Use of Google Gemini

Natural language → environmental analysis
AI-generated future simulations
Personalized sustainability coaching

✅ Best Use of GitHub Copilot

Accelerated development of APIs and UI
Faster iteration and debugging

🌱 Why This Matters

Climate change is hard to grasp because it's invisible.

Numbers don’t change behavior.
Experiences do.

EarthTwin AI makes the invisible visible.

👉 It shows you the future you're actively creating.

By turning climate impact into a living, interactive Earth, users can:

See consequences instantly
Understand long-term effects
Make better decisions

This is not just a tool —
it’s a mirror of our planetary future.

🚀 What’s Next

📱 Mobile version (React Native)
🧠 Smarter AI predictions using real datasets
🎮 Gamification of sustainable behavior

🙌 Final Thought

If we can see the future,
we might finally change it.

🌍💚

I Built a Mental Model for OpenClaw — And It Completely Changed How I See AI

Aditya — Fri, 17 Apr 2026 16:19:23 +0000

This is a submission for the OpenClaw Writing Challenge

⚡ The Moment It Clicked

Most AI tools today feel like this:

You ask → AI answers → You manually act

But OpenClaw felt different.

The first time I ran:

openclaw "Create a project folder and initialize README"

…it didn’t suggest steps.

👉 It actually did the work.

And that’s when it hit me:

OpenClaw is not an AI tool.
It’s an execution engine powered by intelligence.

🧠 The Mental Model (THIS is the key insight)

To really understand OpenClaw, think of it like this:

👉 This is NOT chat.
👉 This is intent → execution pipeline

🔥 OpenClaw = AI + Operating System

Here’s the best way I can describe it:

OpenClaw is like giving AI access to your operating system

🧩 Internal Architecture

Breakdown:

Gateway → receives and routes commands
Agent Runtime → manages logic
Planner → breaks tasks into steps
Executor → performs real actions

🚀 From Chatbot → Autonomous Agent

Capability	ChatGPT-like AI	OpenClaw
Generate answers	✅	✅
Execute commands	❌	✅
Modify system	❌	✅
Automate workflows	❌	✅

⚙️ Getting Started (Real Setup)

1️⃣ Install

npm install -g openclaw@latest

2️⃣ Initialize

openclaw onboard --install-daemon

3️⃣ Verify

openclaw doctor
openclaw status

4️⃣ Try This

openclaw "Create a file hello.txt with content 'Hello from AI'"

👉 You’ll see:

File created
Action executed
AI actually doing work

🧠 What Actually Happens Internally

When you give a command:

👉 This is the ReAct loop in real life

💡 Real Use Cases That Matter

🧑‍💻 Developer Mode

Bootstrap projects
Automate scripts
Manage repos

🧠 Personal AI

Manage tasks
Handle emails
Schedule workflows

⚡ Power Users

Chain multi-step automation
Build AI-driven pipelines
Create custom tools

⚠️ The Hidden Problem (Most People Ignore This)

OpenClaw is powerful.

Too powerful.

👉 It can:

Run shell commands
Modify files
Send messages

Which means:

❗ Blind trust = dangerous

🧠 My Biggest Realization

After experimenting deeply, I realized:

The problem with AI is NOT capability…
It’s lack of control + visibility

🔥 The Missing Layer (Future Idea)

What OpenClaw needs next:

👉 This is where the future is heading:

Transparent AI
Controllable AI
Reversible AI

🧠 Why OpenClaw is Different

✅ Local-first

Your machine. Your data.

✅ Hackable

Everything is editable

✅ Real execution

Not simulation — actual actions

✅ Extensible

Build your own skills

🚀 Where This Is Going

We are entering a new phase:

Era	AI Type
Past	Chatbots
Present	Assistants
Future	Autonomous Agents

OpenClaw is already in that future.

⚡ Final Thought

Using OpenClaw felt like this:

“What if AI didn’t just think…
but actually acted on your behalf?”

And once you experience that,
you can’t go back to normal AI tools.

ClawCon Michigan

I did not attend ClawCon Michigan, but I explored OpenClaw hands-on and studied its ecosystem deeply through experimentation and community resources.

💬 Let’s Connect

If you’re building with OpenClaw or exploring AI agents:

Drop a comment 👇
Let’s build the future together 🚀

I Built a Multi-Agent AI Debate Arena Inside Notion Using MCP — Meet The Council

Aditya — Sun, 15 Mar 2026 11:06:24 +0000

This is a submission for the Notion MCP Challenge

What I Built

Engineering teams constantly face difficult technical decisions.

PostgreSQL or MongoDB?

Microservices or monolith?

Offline-first mobile app or web-first architecture?

Usually the process looks like this:

Engineers research the problem
Everyone has different opinions
A decision gets made
The reasoning disappears forever

Six months later someone asks:

"Why did we make this decision?"

And nobody remembers.

I wanted to fix that permanently.

So I built The Council — a multi-agent AI debate system that runs directly inside Notion.

Instead of a single AI giving generic advice, four specialized AI agents debate a technical question from completely different perspectives.

Each agent:

• Reads the current Notion page

• Generates an argument

• Counters other agents

• Writes its reasoning back to Notion

After several rounds of debate, an Arbiter AI evaluates the arguments and produces the final decision.

Everything gets documented:

every argument
every counter-argument
the final verdict
action items

Technical decisions become permanent institutional knowledge.

Meet The Council

Each AI agent represents a different engineering priority.

⚔️ SENTINEL — Security & Risk

Focuses on vulnerabilities, worst-case scenarios, and system failures.

⚡ MERCURY — Performance & Speed

Analyzes latency, throughput, and developer velocity.

💰 MIDAS — Cost & Business Value

Translates engineering decisions into ROI and operational cost.

🌍 ATLAS — Scale & Architecture

Focuses on long-term scalability and technical debt.

Instead of balancing perspectives, each agent defends its viewpoint strongly.

That tension produces realistic engineering debates.

A Real Debate Example

I asked The Council:

Should we build an offline-first mobile app?

Round 1 — Opening Arguments

Each agent writes its argument directly to the Notion page.

SENTINEL

Offline-first apps store sensitive data locally.

A compromised device could expose user data instantly.

MERCURY

Our web application deploys in seconds and serves requests with low latency.

Mobile build pipelines slow development speed dramatically.

MIDAS

Offline-first development costs significantly more than web-first architecture.

ATLAS

Offline synchronization introduces complexity that becomes dangerous at scale.

Round 2 — Counter Arguments

Agents read the Notion page through MCP and challenge each other's claims.

Security challenges performance.

Cost challenges scale assumptions.

Performance challenges cost projections.

The debate evolves dynamically.

The Verdict

After two rounds, the Arbiter evaluates every argument and produces the final decision.


DECISION:
Build a web-first architecture with PWA offline support.

REASONING:
This approach maintains centralized security controls,
preserves fast development velocity, minimizes cost,
and avoids large-scale synchronization complexity.

The system automatically generates action items:

Implement Service Workers
Add IndexedDB caching
Build unified CI/CD pipeline
Audit client-side storage security
Design scalable backend APIs

Everything is written directly into the Notion page.

What Happens When AI Cannot Decide?

Some engineering problems don't have a clear answer.

Instead of pretending certainty, The Council can declare a deadlock.

The Notion page shows:


⚖️ THE COUNCIL IS DEADLOCKED

Cast your deciding vote:

⚔️ SENTINEL — prioritize security
⚡ MERCURY — prioritize speed
💰 MIDAS — prioritize cost
🌍 ATLAS — prioritize scale

The engineer reads the debate and votes using the Vote property in Notion.

This creates a human-in-the-loop decision system.

AI prepares the analysis.

Humans make the final call when needed.

Video Demo

This demo shows the full workflow:

1️⃣ Create a Notion page

2️⃣ Set Status = pending

3️⃣ The Council begins debating

4️⃣ Agents write arguments live

5️⃣ The Arbiter publishes a final decision

Show us the code

GitHub repository:

TheCoderAdi / the-council

The Council — Multi-Agent AI Debate Arena (Notion MCP)

A Multi-Agent debate system that runs inside Notion using the Model Context Protocol (MCP) Four agents with distinct personas debate a technical question on a Notion page; an arbiter then writes a final decision, reasoning, and action items back to the page. Everything is done via MCP tools—no direct REST calls to Notion.

Quick summary

Input: a Notion database page with the Question title and Status: pending.
Process: watcher detects pending pages → opens MCP connection → runs 3 rounds (based on your choice) of parallel agent debates → arbiter writes decision.
Output: Notion page updated with debate callouts, Decision rich text, Status set to completed

Agents: ⚔️ SENTINEL (security), ⚡ MERCURY (performance), 💰 MIDAS (cost), 🌍 ATLAS (scale).

What you'll find in this repo

api/ — Express server and SSE endpoints for streaming debates to the dashboard.
src/core/mcpClient.js —…

View on GitHub

Run locally:

git clone https://github.com/TheCoderAdi/the-council
cd the-council
npm install
cp .env.example .env
npm run dev

Example .env configuration:

NOTION_API_KEY=secret_xxx
NOTION_DATABASE_ID=xxx

GEMINI_API_KEY=xxx
GROQ_API_KEY=xxx

LLM_MAX_CONCURRENCY=2
LLM_MIN_DELAY_MS=150

How I Used Notion MCP

This project is built entirely around Notion MCP (Model Context Protocol).

Traditional integrations use the Notion REST API, where external code pushes data into Notion.

MCP changes the model completely.

With MCP, AI agents can use Notion as native workspace tools.

Agents can:

• read page content
• write blocks
• update properties
• query databases

Example MCP usage:

const context = await mcp.callTool(
  "API-get-block-children",
  { block_id: pageId }
);

Writing an argument block:

await mcp.callTool("API-patch-block-children", {
  block_id: pageId,
  children: [
    {
      type: "callout",
      callout: {
        rich_text: [{ text: { content: response } }],
        icon: { emoji: "⚔️" }
      }
    }
  ]
});

The agents operate inside the Notion workspace just like human collaborators.

Architecture

Notion Database
        │
        ▼
Notion Watcher
(detects pending debates)
        │
        ▼
Council Orchestrator
        │
        ├── SENTINEL
        ├── MERCURY
        ├── MIDAS
        └── ATLAS
        │
        ▼
Arbiter
        │
        ▼
Decision written to Notion

A real-time dashboard streams debate progress using Server-Sent Events.

Technical Stack

Layer	Technology
MCP Server	@notionhq/notion-mcp-server
MCP SDK	@modelcontextprotocol/sdk
Primary LLM	Gemini 2.0 Flash
Fallback LLM	Groq
Backend	Node.js + Express
Streaming	Server-Sent Events
Frontend	Vanilla JavaScript

Why This Matters

Most technical decisions disappear into Slack threads and meetings.

The Council turns engineering debates into structured, searchable knowledge.

Future engineers can see exactly:

• what arguments were made
• which tradeoffs were considered
• why the final decision was chosen

Instead of repeating the same debate every year, teams build decision history.

Try It

Drop a technical question in the comments.

I'll run it through The Council and share the full debate output.

Built for the Notion MCP Challenge

🚀 Stop Typing Long Terminal Commands. Use Aliases Instead

Aditya — Mon, 02 Mar 2026 07:09:33 +0000

As developers, we optimize APIs, databases, and smart contracts.

But we rarely optimize our own workflow.

I realized I was typing the same commands every single day:

npm run dev
git add .
git commit -m "message"
git push
docker compose up --build
npx hardhat test
forge build

It seems small.

But friction compounds.

So I reduced it.

🧠 What Are Shell Aliases?

Aliases are shortcuts you define in your shell (bash or zsh) that map short commands to longer ones.

Instead of typing:

npm run dev

You type:

nd

Same result. Less friction.

🛠 Step 1: Open Your Shell Config

If you’re using:

Zsh (Mac / Linux default nowadays)

nano ~/.zshrc

Bash

nano ~/.bashrc

✍ Step 2: Add Aliases

Here are some practical ones for Full-Stack + Web3 developers:

# 📦 NPM
alias nd="npm run dev"
alias nb="npm run build"
alias ni="npm install"

# 🌿 Git
alias gs="git status"
alias ga="git add ."
alias gc="git commit -m"
alias gp="git push"
alias gpl="git pull"
alias gcb="git checkout -b"
alias gl="git log --oneline"

# 🐳 Docker
alias dcu="docker compose up"
alias dcub="docker compose up --build"
alias dcd="docker compose down"
alias dps="docker ps"

# 🔐 Hardhat
alias hhc="npx hardhat compile"
alias hht="npx hardhat test"
alias hhn="npx hardhat node"

# ⚒ Forge
alias fb="forge build"
alias ft="forge test"

Save the file.

Then reload:

source ~/.zshrc

(Or source ~/.bashrc)

Done.

🔥 Real Before vs After

Before

git add .
git commit -m "fix: JWT verification bug"
git push

After

ga
gc "fix: JWT verification bug"
gp

Before

docker compose up --build

After

dcub

Before

git checkout -b feature/jwt-auth

After

gcb feature/jwt-auth

⚡ Level 2: Combine Commands

You can even chain commands:

alias gacp="git add . && git commit -m"

Now:

gacp "feat: add middleware"
gp

One step closer to flow state.

🎯 Why This Matters

This isn’t about saving 3 seconds.

It’s about reducing cognitive load.

When friction decreases:

You stay in flow longer
You ship faster
You feel less drained

Most developers try to optimize performance.

Few optimize themselves.

🧩 Bonus: Modern Git Alternative

Instead of:

git checkout -b feature/auth

You can use:

git switch -c feature/auth

And alias it:

alias gsw="git switch -c"

💭 Final Thought

Productivity isn’t about working more hours.

It’s about removing unnecessary resistance from your system.

If you’re a developer:

What’s one shortcut you can’t live without?

🏏 CrickSquad — The App That Replaced 50 WhatsApp Messages for My Cricket Group

Aditya — Sun, 01 Mar 2026 17:42:36 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

I'm part of a weekend cricket group of 25 people. Every Sunday at 7 AM, we play cricket at a local turf ground. It's been going on for 3 years now — rain or shine.

But here's the thing nobody talks about: organizing a casual cricket match is harder than playing it.

Every single week, the same chaos unfolds:

🔴 WhatsApp Hell

"Who's coming this Sunday?"
50+ messages later... still no clear count.

🔴 Team Selection Drama

"Last time teams were unfair!"
"Why am I always bowling first?"
Every. Single. Week.

🔴 Money Collection Nightmare

"Bro, you haven't paid for the last 3 matches"
"I paid! Check the chat"
scrolls through 500 messages

🔴 No Memory of Performance

"How many runs did I score last month?"
Nobody knows. No records. No stats.

🔴 Zero Recognition

Score 50 runs on Sunday. By Monday, nobody remembers.
Attendance drops because people feel "it doesn't matter."

I know millions of weekend sports groups around the world face the same problems. So this weekend, I decided to fix it.

What I Built

🏏 CrickSquad — Less WhatsApp. More Cricket.

An all-in-one web app for weekend cricket groups that handles everything from RSVP to AI-powered match reports.

One app to replace 50 WhatsApp messages every weekend.

Core Features:

🎯 One-Tap RSVP
No more "who's coming?" chaos. Open the app, tap Yes/No/Maybe. Done. Everyone sees the count in real-time with a countdown to the deadline.

⚖️ Smart Team Balancer
Every player has skill ratings (batting, bowling, fielding). The algorithm creates the most balanced 2 teams possible. No more "unfair teams" complaints. Ever.

🤖 AI-Powered Features (Gemini)
This is where it gets fun:

AI Team Analysis — Gemini explains why the team split is balanced
AI Match Reports — Commentary-style match summaries after every game
AI Player Insights — "You're the Virat Kohli of your group!" with actual improvement tips
AI POTM Suggestions — Top 3 Player of Match candidates with reasoning
Smart Reminders — Personalized nudge messages for pending RSVPs
Season Analytics — Trends, fun facts, predictions

💰 Expense Splitter
Set ground cost → auto-split among players → track who paid → send reminders. Running balances across multiple matches so you always know who owes what.

📊 Scorecards & Leaderboards
Enter batting/bowling stats after each match. Auto-calculated averages, strike rates, economy rates. Season leaderboards with medals 🥇🥈🥉

🎲 Digital Toss
Animated coin flip. No more "my coin, my call" disputes.

📢 Polls & Announcements
"Should we play Saturday instead?" — Quick polls with deadlines. Important announcements that don't get buried in chat.

📸 Match Gallery
Upload and share photos from every match. Organized per game day.

🏟️ Venue Management
Save venues with address, Google Maps link, facilities, pricing. One-tap directions.

🔥 Mail System
When admin creates poll, announcement, pay notifications, new match alert.

Demo

🔗 Github Code: https://github.com/TheCoderAdi/cricksquad

Screenshots:

Project Haul

Excalidraw Whiteboard

Excalidraw is a virtual collaborative whiteboard tool that lets you easily sketch diagrams that have a hand-drawn feel to them.

excalidraw.com

Landing Page

Dashboard — Upcoming Match + RSVP

Team Balancer — AI-Powered Fair Teams

Leaderboard — Season Stats

AI Match Report

Expense Tracker

Scorecard

Profile + AI Player Insights

Venue Page

Match Gallery

Key Algorithms

Team Balancer Algorithm:

const balanceTeams = (players) => {
  // Sort by overall rating (descending)
  const sorted = [...players].sort((a, b) => b.overallRating - a.overallRating);

  let teamA = [], teamB = [];
  let ratingA = 0, ratingB = 0;

  // Greedy assignment: add to weaker team
  for (const player of sorted) {
    if (ratingA <= ratingB) {
      teamA.push(player);
      ratingA += player.overallRating;
    } else {
      teamB.push(player);
      ratingB += player.overallRating;
    }
  }

  // Role balancing pass (ensure bowlers are distributed)
  // ... swap players to balance roles without hurting ratings

  return { teamA, teamB };
};

Skill Rating System:

// Weighted by player role
const weights = {
  batsman:    { batting: 0.5, bowling: 0.2, fielding: 0.3 },
  bowler:     { batting: 0.2, bowling: 0.5, fielding: 0.3 },
  allrounder: { batting: 0.35, bowling: 0.35, fielding: 0.3 },
  keeper:     { batting: 0.4, bowling: 0.1, fielding: 0.5 }
};

overallRating = batting * w.batting + bowling * w.bowling + fielding * w.fielding;

Gemini AI Integration:

const { GoogleGenerativeAI } = require('@google/generative-ai');
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

const generateMatchSummary = async (matchData) => {
  const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' });
  const prompt = `You are a cricket commentator. Write a fun match report...`;
  const result = await model.generateContent(prompt);
  return result.response.text();
};

How I Built It

Tech Stack

Layer	Technology	Why
Frontend	React + Vite	Fast dev experience, instant HMR
Styling	Tailwind CSS	Rapid UI development
State	Zustand	Lightweight, no boilerplate
Data Fetching	React Query + Axios	Caching, loading states
Animations	Framer Motion	Smooth page transitions
Backend	Node.js + Express	Fast REST API development
Database	MongoDB + Mongoose	Flexible schema for cricket data
AI	Google Gemini	Fast, accurate, free tier
Image Storage	Cloudinary	Auto-compression, CDN delivery
Auth	JWT + bcrypt	Secure, stateless authentication

Architecture

React → Axios → Express API → MongoDB Atlas
                                    ↓
                              Gemini AI API
                              Cloudinary CDN

Development Timeline

When	What	Hours
Friday Evening	Project setup, DB models, Express config	3h
Saturday Morning	Auth, Groups, Matches, RSVP APIs	5h
Saturday Afternoon	Teams, Expenses, Scorecard, Leaderboard APIs	5h
Saturday Evening	Frontend: Auth, Dashboard, RSVP pages	4h
Sunday Morning	Frontend: Teams, Expenses, Scorecard, Leaderboard	5h
Sunday Afternoon	Gemini AI integration, Polls, Gallery	5h
Sunday Evening	Polish & write this post	3h
Total		~30h

Challenges & Learnings

1. Team Balancing is NP-hard 😅
Turns out, perfectly splitting teams is a partition problem. The greedy algorithm works surprisingly well for groups under 30. Adding a role-balancing second pass made it even better.

2. Gemini AI JSON Responses
Getting Gemini to consistently return valid JSON was tricky. I added replace(/`json\n?/g, '') cleanup and wrapped everything in try-catch with user-friendly fallbacks.

3. Real-Time Feel Without WebSockets
Instead of adding Socket.io complexity, I used React Query's refetchInterval for the RSVP page. Feels real-time, fraction of the complexity.

4. Mobile-First is Non-Negotiable
Cricket groups use WhatsApp on phones. If this app isn't phone-friendly, nobody will use it. Every component was designed thumb-first.

What's Next

If the cricket group likes it (they will 😎), here's what I'd add next:

📱 React Native mobile app with push notifications
💬 WhatsApp API integration for automated reminders
🏏 Ball-by-ball live scoring
📊 Season playoffs & tournament mode
🎥 AI-generated highlight reels from uploaded videos
💳 UPI payment integration (India-specific)

The Real Test

I shared this with my cricket group yesterday. Within 10 minutes:

22 out of 25 members had joined
18 RSVPs for this Sunday
Zero WhatsApp messages about "who's coming?"

That's the real demo. 🏏

Built with ❤️ and way too much coffee during the DEV Weekend Challenge.

If you play weekend cricket (or any weekend sport), drop a comment — I'd love to hear about the chaos in YOUR group! 😄

Holistic Webdev: Office Space

Aditya — Sat, 26 Jul 2025 16:52:40 +0000

🌐 This is a submission for Frontend Challenge: Office Edition sponsored by Axero, Holistic Webdev: Office Space

🛠️ What I Built

OrbitSpace is a futuristic, glassmorphism-inspired intranet homepage designed to bring elegance, clarity, and functionality to digital office environments.

I envisioned a modern digital workspace that merges essential internal tools with an aesthetic that inspires creativity. The layout includes:

✨ Hero section with office branding
🚀 Quick links for essential tools
👥 Team spotlight to highlight members
📅 Upcoming events area
📊 Metrics dashboard
📚 Knowledge base
🧭 Navigation bar with smooth UX

The UI uses glassmorphism layered with TailwindCSS and ShadCN UI components for responsiveness, theme consistency, and accessibility. Every card is softly frosted with transparency, letting the gradient background shine through.

🎥 Demo

🔗 Live URL: Preview
📁 Source Code: GitHub Repo

🛣️ Journey

I started this project with the idea of redefining how office intranets feel — moving away from outdated, cluttered dashboards into something that feels alive, light, and forward-thinking.

Some things I'm proud of:

Using glassmorphism with care to avoid readability issues
Seamless integration of ShadCN components with Tailwind
A fully modular component structure (HeroSection, Navigation, TeamSpotlight, etc.)
Layout that adapts beautifully to different screen sizes
Subtle hover interactions and gradients that enhance UX

Throughout this build, I focused on component reusability and aesthetic balance, ensuring each section contributes to a cohesive whole.

👤 Author

Made by @aditya_007
Available for collaborations and open-source opportunities 🚀

📝 License

MIT License — free to use with credit.

Office Desk - CSS Art Edition

Aditya — Sun, 20 Jul 2025 07:47:10 +0000

🎨 CSS Art: "Hacker's Haven" — Office Culture Redefined

This is a submission for Frontend Challenge: Office Edition sponsored by Axero, CSS Art: Office Culture.

🧠 Inspiration

When you think of a modern digital workspace, what's more iconic than a dual-monitor setup, a mechanical keyboard, and a cozy desk filled with gadgets? For this CSS art challenge, I wanted to create a "Hacker-style home office" scene — a space that feels alive with glowing monitors, RGB keys, and small but intentional details like a water bottle, headphones, mouse, and pyramid-shaped wall art.

This is a tribute to those of us who spend countless hours building, coding, designing, and dreaming — in our own digital caves.

🚀 Demo

Here's the final output of my CSS office setup:

👉 Live Demo: https://thecoderadi.github.io/Hacker-s-Haven/
👉 Code: https://github.com/TheCoderAdi/Hacker-s-Haven

🔨 Journey

The scene was built using only HTML and CSS — no external images or JavaScript. Here’s a breakdown of the process:

Perspective & 3D Feel: I used transform, perspective, and rotateX/Y to give depth to the desk and devices.
Monitor Effects: Each monitor has a unique content block — one with glowing terminal-style text, and another with animated green bars.
Glassmorphism: The container div uses backdrop blur and soft borders to simulate a futuristic glass wall.
Accessories: Everything from the bottle to the headphones was hand-crafted using only CSS box-model elements and a lot of tweaking.
Keyboard Glow: A custom RGB-like animation simulates key lighting, giving it a cyberpunk vibe.
Robot Wall Art: A minimalist robot drawing mounted on the wall just for fun (and to add personality)!

I learned a ton about layering, keyframe animations, and perspective transforms — and just how expressive pure CSS can be.

💡 What’s Next

I’d love to:

Add a toggle for day/night mode
Animate the terminal text typing line-by-line
Make the scene partially interactive with small JS additions after the challenge ends

👥 Credits

This was a solo submission.
If you found this fun or inspiring, feel free to fork it or remix it for your own virtual office!

🏷 License

MIT License — feel free to use or adapt with attribution.

Thanks to DEV and Axero for this amazing challenge! 🙌
Let’s continue making the web more expressive and fun — one div at a time!

🚀 Startup Scout Agent: Find the Hottest New Startups with One AI Prompt | Runner H Challenge

Aditya — Sat, 28 Jun 2025 09:19:09 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

👋 Meet Startup Scout Agent — your weekly AI researcher that finds new startups, fills your spreadsheet, and sends it to your inbox. Built entirely with one prompt, using Runner H.

What I Built

I built Startup Scout Agent, an autonomous AI agent powered by Runner H that scans the web for newly launched startups every week and sends a neatly formatted report to my inbox.

It’s designed for:

Investors who want early access to rising startups
Job seekers exploring new, fast-growing companies
Startup community builders curating newsletters and communities

This project completely automates what normally takes hours of research — all with a single Runner H prompt.

Demo

📽️ Watch the full demo here:

🖼️ Screenshots:

✅ Sample Google Sheet: “Weekly Startup Radar”

✅ Confirmation Email

How I Used Runner H

I used Runner H’s autonomous agent system with this one prompt:

Every Sunday evening, find 10–15 recently launched startups in AI, HealthTech, or FinTech from sites like TechCrunch, Crunchbase, Product Hunt, or LinkedIn.

For each startup, extract the following:
- Startup name
- Description (what they do)
- Industry or category
- Funding stage (e.g., seed, Series A)
- Location
- Founders' names
- Public founder email (if available)

Add this data to a Google Sheet titled “Weekly Startup Radar”.

Once the sheet is updated, email it to me at [your-email@example.com] with the subject: “Your Weekly Startup Report is Ready 🚀”.

Repeat this task automatically every Sunday at 6:00 PM IST.

I also connected:

Google Sheets (to store the data)
Gmail (to send me the weekly email)

This prompt runs autonomously every Sunday, so I wake up to a fresh, curated startup list in my inbox.

Use Case & Impact

🔍 Real-world use cases:

VC analysts tracking fresh startups in specific sectors
Newsletter writers curating early-stage startup coverage
Job seekers or students exploring fast-moving companies
Accelerators and incubators scouting leads

⏱️ Impact:

Saves 4–5 hours/week of manual research
No scraping, no APIs, no code — just prompt + Runner H
Runs 100% hands-free

Social Love ❤️

✨ Shared on Twitter: View Tweet

Let me know what you think — and feel free to fork the prompt for your own industry! Thanks to @hcompany_ai and @thepracticaldev for making this challenge happen!