DEV Community: Aditya

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!

🚀 Building an AI-Powered Backend with Node.js + Groq for IdeaLens

Aditya — Sat, 12 Apr 2025 04:10:33 +0000

Welcome! 👋
In this tutorial, we’ll build a modular, production-ready Node.js backend for IdeaLens — an AI assistant that helps creators brainstorm, summarize, caption, and ideate content. We’ll also integrate Groq to access blazing-fast LLMs like LLaMA 3.

📦 Prerequisites

Make sure you have the following:

Node.js (v16+)
npm or yarn
MongoDB Atlas or local
A Groq API Key
REST client (Postman, Thunder Client, etc.)

📁 Folder Structure

backend/
├── controllers/
│   └── summary.controller.js
├── routes/
│   └── summary.route.js
├── utils/
│   └── groqClient.js  <-- ✨ Groq integration
├── app.js
├── server.js
└── .env

📦 Install Dependencies

npm install express cors cookie-parser dotenv mongoose axios

We’ll use axios to call the Groq API.

🧠 Integrating Groq: Ultra-fast Open-Source LLMs

Create utils/groqClient.js:

const axios = require("axios");

const GROQ_API_KEY = process.env.GROQ_API_KEY;

const groq = axios.create({
  baseURL: "https://api.groq.com/openai/v1/chat/completions",
  headers: {
    "Authorization": `Bearer ${GROQ_API_KEY}`,
    "Content-Type": "application/json"
  }
});

async function chatWithGroq(messages, model = "llama-3.3-70b-versatile") {
  try {
    const response = await groq.post("/chat/completions", {
      model,
      messages,
      temperature: 0.7
    });

    return response.data.choices[0].message.content;
  } catch (err) {
    console.error("Groq Error:", err.response?.data || err.message);
    throw new Error("Groq API failed");
  }
}

module.exports = { chatWithGroq };

You can now easily switch between llama-3.3-70b-versatileor others.

🔁 Using Groq in a Controller

In controllers/summary.controller.js:

const { chatWithGroq } = require("../utils/groqClient");

const generateSummary = async (req, res) => {
  const { idea } = req.body;

  const messages = [
    {
      role: "system",
      content: "You're a creative assistant helping generate content ideas."
    },
    {
      role: "user",
      content: `Summarize the following content idea: "${idea}". Include mood, genre, platform suggestions, hooks, and short video direction.`
    }
  ];

  try {
    const aiResponse = await chatWithGroq(messages);
    res.json({ summary: aiResponse });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

module.exports = { generateSummary };

📌 Example Route: `/api/summary`

In routes/summary.route.js:

const express = require("express");
const router = express.Router();
const { generateSummary } = require("../controllers/summary.controller");

router.post("/", generateSummary);

module.exports = router;

🔐 Environment Variables

In .env:

PORT=5000
CLIENT_URL=http://localhost:3000
MONGO_URI=your_mongo_url
GROQ_API_KEY=your_groq_api_key

🛠️ Bootstrapping the App

In app.js:

const express = require("express");
const cors = require("cors");
const cookieParser = require("cookie-parser");
const summaryRoutes = require("./routes/summary.route");

const app = express();

app.use(cors({ origin: process.env.CLIENT_URL, credentials: true }));
app.use(express.json());
app.use(cookieParser());

app.use("/api/summary", summaryRoutes);

app.get("/", (req, res) => {
  res.send("IdeaLens backend is up 🚀");
});

module.exports = app;

In server.js:

const app = require("./app");
const mongoose = require("mongoose");
require("dotenv").config();

const PORT = process.env.PORT || 5000;

mongoose.connect(process.env.MONGO_URI)
  .then(() => {
    app.listen(PORT, () =>
      console.log(`Server running at http://localhost:${PORT}`)
    );
  })
  .catch((err) => console.error("MongoDB connection failed", err));

📌 Route Overview

Endpoint	Method	Description
`/api/summary`	POST	Generate structured summary with Groq
`/api/analyze`	POST	Content analysis
`/api/captions`	POST	Generate captions + hashtags
`/api/songs`	POST	Suggest music tracks
`/api/chat`	POST	General AI chat
`/api/refine`	POST	Refine based on user feedback
`/api/upload-media`	POST	Upload audio/video for analysis
`/api/auth`	POST	Auth with JWT & cookies

All powered by modular routes and AI controller functions.

🎯 Done! Your Groq-Powered Node.js Backend🚀

You’ve now got a fully working Express backend with Groq integrated — giving you high-performance LLM workflows for idea summarization, creative chatting, and content generation in your IdeaLens platform.

Discord Image Generation Bot with Daytona

Aditya — Sat, 28 Dec 2024 07:31:30 +0000

This project demonstrates how to build a Discord bot that generates images from text prompts using the Prodia API, while utilizing Daytona for an optimized and scalable development environment. With Daytona's devcontainers, the bot ensures a standardized, fast, and efficient setup process.

🚀 Getting Started
✨ Features
💬 How to Use
📜 License
📚 Learn More

🚀 Getting Started

1. Install Daytona

First, make sure you have Daytona installed. You can follow the installation guide from the Daytona documentation.
Start the server

   daytona serve;

2. Clone the Repository

Clone this repository to your local machine:

   git clone https://github.com/TheCoderAdi/discord-bot.git
   cd discord-bot

3. Create a Daytona Workspace

Create a development workspace using Daytona:

   daytona create https://github.com/TheCoderAdi/discord-bot

4. Install Dependencies

Once you have set up your workspace, ensure all dependencies are installed by running:

   pip install -r requirements.txt

5. Configure the Bot

Create a .env file in the root directory of the project and add your Discord bot token and Prodia API key as follows:

   DISCORD_TOKEN=your_discord_bot_token
   PRODIA_API_KEY=your_prodia_api_key

6. Run the Bot

After configuring the bot, you can start it by running:

   python bot.py

This will start the bot, which will listen to messages on your Discord server and respond with generated images based on text prompts.

✨ Features

Integration with Daytona:

Daytona ensures a consistent, reproducible development environment with devcontainers for easy setup and scaling.
Modular Python Bot Framework:

The bot is designed to be modular and extendable. You can easily add new features or commands.
Discord API Integration:

Uses the Discord API to handle real-time message interaction in the server.
Image Generation with Prodia API:

Generates images based on text prompts, utilizing the Prodia API to create AI-driven images.

💬 How to Use

Once the bot is up and running, you can interact with it directly in any Discord channel where the bot is present.

1. Text Prompt Command

To generate an image, use the command !generate followed by the text prompt. For example:

   !generate A sunset over a mountain range

The bot will process your request and return the generated image. The output will be displayed in the channel like so:

Output Image:

The bot will send back the image in the Discord channel once the image generation is completed.

📜 License

This repository is licensed under the MIT License. See the LICENSE file for more details.

📚 Learn More

For more information on Daytona, visit the official Daytona documentation.
For more on Discord bot development, check out the Discord.py documentation.