DEV Community: MakendranG

🐾 PawSense AI — Your Dog’s AI Companion & Canine Translator

MakendranG — Sat, 15 Aug 2026 16:29:30 +0000

This is a submission for Weekend Challenge: Dog Days Edition

What I Built

PawSense AI is an interactive, full-stack AI application designed to celebrate the unique bond between humans and their dogs. By simply uploading a photo, capturing a live webcam shot, or picking from a curated pack of sample pups, Google Gemini’s multimodal vision transforms that single image into an entertaining, comprehensive canine profile.

PawSense AI delivers:

🧬 Multimodal Breed & Lineage Analysis: Identifies primary breed matches with confidence scoring and estimated mixed-breed lineage percentages.
🔍 Morphology & Physical Traits: Analyzes coat patterns, ear and eye structure, distinguishing markings, and estimates life stages (Puppy, Young Adult, Adult, Senior) using observable visual cues.
🎭 Playful Personality Archetypes & Radar Stats: Assigns custom canine archetypes (e.g., "The Velveteen Snuggle Monster", "Chief Operations Zoomer"), calculates energy scores (1–10), superpowers, kryptonite nemesis, spirit elements, love languages, and funny quirks.
💭 Canine Brainwave Translator ("Dog Thoughts"): Translates what the dog is thinking in real time—with hilarious stances on humans, mail carriers, and cheese wrappers—featuring Web Speech text-to-speech audio playback.
📅 Personalized Daily Routine & Enrichment Schedule: Generates a 5-part daily schedule (Morning, Midday, Afternoon, Evening, Bedtime) with checkable care milestones and breed-tailored mental/physical games.
🪪 Collectible PawPort™ ID Card: Generates an official Canine Registry Passport and trading card with rarity tiers and high-resolution PNG export for instant downloading and sharing.
💬 Interactive "Chat with Your Dog": Real-time conversational interface where Gemini adopts your dog's exact personality, complete with voice recognition input, cute simulated canine actions (tail wags frantically), and spoken audio replies.

The goal was to build far more than a basic breed classifier — to create a delightful, deeply personal AI experience centered around the joy of dog companionship.

Demo

🚀 Live Web Application:
https://aistudio.google.com/apps/7c426e35-1292-4dc9-93d5-06117d4b365c?showPreview=true&project=gen-lang-client-0556648492&showAssistant=true&fullscreenApplet=true

🔗 Google AI Studio App Workspace:
https://ai.studio/apps/7c426e35-1292-4dc9-93d5-06117d4b365c

Code

The application is built as a production-ready full-stack application:

Frontend: React 19, TypeScript, Tailwind CSS, Motion animations, Lucide Icons, Canvas Confetti, and native Web Audio / Speech Synthesis APIs.
Backend API: Node.js & Express server with @google/genai SDK.
Persistence: Browser IndexedDB (PawSenseDB) with client-side image compression for fast, persistent storage of scanned dog packs without storage quota limits.
Resilience: Automatic retry with exponential backoff and a model fallback chain (gemini-3.7-flash ➔ gemini-flash-latest ➔ gemini-2.5-flash) to ensure continuous uptime during high-demand traffic spikes.

How I Built It

1. Central Multimodal Gemini Intelligence

Google Gemini is the core engine powering the entire experience:

When a photo is uploaded, the image is sent securely to the backend /api/analyze-dog endpoint.
Gemini evaluates the photo using multimodal vision understanding, extracting breed taxonomy, morphological characteristics, life stage clues, personality archetypes, and routine suggestions.
The response is strictly validated against a typed JSON schema (responseMimeType: "application/json", responseSchema), guaranteeing clean, structured data for the frontend in a single pass.

2. Conversational Dog Persona Engine

The /api/chat-dog endpoint injects the generated breed traits, quirks, fears, and relationship dynamics into the model's system instructions. Gemini assumes the dog's first-person perspective, reacting with authentic dog logic (obsessions with treats, squeaky toys, belly scritches, and naps) alongside expressive action markers.

3. Interactive Web Audio & Canvas Exporting

Sound Effects: Synthesized using the Web Audio API (happy yips, tail thumps, camera clicks) and Web Speech API for voice playback.
PawPort Card Generator: Renders high-definition collectible trading cards dynamically onto HTML5 Canvas with custom badges, QR verification stamps, and direct image download support.

4. Robust Local Persistence with IndexedDB

To handle multiple dog photo uploads without exceeding standard browser storage limits, the app employs an asynchronous IndexedDB storage layer (PawSenseDB) alongside client-side image optimization.

Prize Categories

🏆 Best Use of Google AI

PawSense AI is submitted for the Best Use of Google AI category.

Rather than using AI as a simple chatbot widget, Google Gemini powers the foundational architecture of the application:

Multimodal Image Analysis: Deep morphological visual understanding of dog breeds, age cues, and physical traits.
Structured Schema Synthesis: Generating structured JSON profiles spanning genetics, behavioral traits, and custom care routines.
Roleplay & Dynamic Chat: Conversational AI grounded in each dog's unique persona.
Spontaneous Creative Generation: Real-time translation of canine inner monologues and thoughts.

🐕 Built for dogs. Powered by Gemini. Inspired by the bond between humans and their best friends.

🍽️ Masala Dosa House — A Taste of Home

MakendranG — Sat, 15 Aug 2026 15:44:11 +0000

This is a submission for Frontend Challenge - Comfort Food Edition, Perfect Landing

What I Built

For the Perfect Landing prompt, I built Masala Dosa House, a warm and modern landing page inspired by one of my favorite comfort foods — South Indian Masala Dosa. 🇮🇳

The idea was to create a fictional restaurant website that feels like stepping into a familiar neighborhood dosa spot.

The landing page focuses on:

🍽️ Hero section featuring Masala Dosa
🥞 Signature dishes
🥥 Chutneys and sambar
🌿 Traditional South Indian food experience
❤️ A warm, welcoming visual design
📱 Responsive layout for desktop and mobile
✨ Smooth interactions and animations
🎨 Food-inspired colors, typography, and visual elements
📍 Restaurant-style call-to-action sections

Rather than creating a generic restaurant landing page, I wanted the entire experience to communicate the feeling behind comfort food — warmth, familiarity, and home.

Demo

🍽️ Live Project: Masala Dosa House — A Taste of Home

View the Masala Dosa House project on CodePen

Journey

I started by thinking about what makes a food website feel different from a regular landing page.

For me, comfort food isn't only about the food itself. It's about the experience around it — the aroma, the warmth, the familiar presentation, and the feeling of sitting down for a meal that you already know you'll enjoy.

That became the design direction for Masala Dosa House.

I used a warm visual palette inspired by dosa, banana leaves, spices, chutneys, and traditional South Indian dining. The layout was designed to keep the food as the main focus while making the page easy to navigate.

Building the experience

I structured the landing page around a simple restaurant journey:

Discover → Explore → Choose → Visit

The hero section introduces the restaurant and immediately establishes the comfort-food theme.

The menu section highlights signature dishes, while supporting sections provide more context about the restaurant and its food.

I also focused on making the interface feel responsive and interactive rather than just presenting a static collection of cards.

What I learned

This project gave me an opportunity to think beyond individual UI components and focus on the overall user experience.

Some of the areas I focused on were:

Creating a strong visual hierarchy
Designing clear calls to action
Maintaining readability against food-inspired backgrounds
Building responsive layouts
Using animation without distracting from the content
Creating a consistent visual identity across the page

What I'm proud of

I'm particularly proud of turning a simple idea — "a restaurant that serves comfort food" — into a complete visual experience.

The goal wasn't just to show a dosa.

It was to make the visitor feel:

"This looks like somewhere I'd love to eat."

That feeling became the main design principle behind the landing page.

Final Thoughts

The Comfort Food Edition challenge was a fun opportunity to combine frontend development with something deeply relatable — food.

With Masala Dosa House, I wanted to create a fictional restaurant that feels familiar, welcoming, and distinctly South Indian while still looking like a modern web experience.

Good food brings people together. Good design should do the same. 🍽️❤️

Project: Masala Dosa House — A Taste of Home
Built with: HTML, CSS, JavaScript
Platform: CodePen
Challenge: Frontend Challenge — Comfort Food Edition / Perfect Landing

CSS Masala Dosa — A Plate of Comfort 🍽️

MakendranG — Sat, 15 Aug 2026 15:41:39 +0000

This is a submission for Frontend Challenge - Comfort Food Edition, CSS Art.

Inspiration

For my CSS Art submission, I wanted to create something that represents comfort food from South India — Masala Dosa. 🇮🇳

A crispy, golden dosa served with potato masala, coconut chutney, tomato chutney, and a warm bowl of sambar is more than just a meal. It's one of those dishes that immediately feels familiar and comforting.

I decided to recreate the entire plate using HTML and CSS, without using food images or external graphics.

The goal was to turn a simple plate of masala dosa into a small CSS illustration while keeping the focus on CSS techniques such as:

CSS gradients
Radial and repeating gradients
Border-radius based shapes
Box shadows
Pseudo-elements
CSS animations
Responsive layouts
Layering and positioning

The project is called "CSS Masala Dosa — A Plate of Comfort".

Demo

🍽️ Live CodePen Project: CSS Masala Dosa — A Plate of Comfort

View the CSS Masala Dosa project on CodePen

Journey

I started with the idea of creating a single plate entirely from CSS.

Instead of using an image for the dosa, I built the main shape using layered gradients and rounded shapes. The different colors and textures help create the crispy, golden appearance of the dosa.

Then I added the individual elements of the meal:

🥞 Masala Dosa — built using multiple gradients, shadows, and layered shapes.

🥔 Potato Masala — represented using small CSS shapes for potato pieces, onions, and curry leaves.

🥥 Coconut Chutney — created using a circular CSS shape with subtle texture details.

🌶️ Tomato Chutney — another CSS-only circular element with layered gradients.

🥣 Sambar — built as a small bowl using nested circular elements and gradients.

🌿 Banana Leaf — created with gradients, shadows, and a CSS vein to give it a natural appearance.

♨️ Steam — animated using CSS @keyframes to give the dosa a freshly-served feeling.

One of the things I particularly enjoyed was creating the food textures without images. Radial gradients and repeating gradients made it possible to add subtle variations to the dosa instead of making it look like a simple flat shape.

I also added a small interaction: clicking the plate gives it a subtle animation, making the otherwise static CSS artwork feel a little more alive.

What I learned

This project was a great reminder that CSS can be used for much more than layouts and styling.

A combination of:

Gradients
+
Border Radius
+
Box Shadows
+
Pseudo Elements
+
Transforms
+
Animations

can create surprisingly detailed illustrations without requiring external image assets.

It was also a fun exercise in thinking about how to break a real-world object into simple geometric shapes and then reconstruct it using CSS.

What I'm proud of

I'm particularly happy that the complete food scene is created using HTML + CSS, with only a very small amount of JavaScript used for the click interaction.

The main visual elements — dosa, banana leaf, chutneys, sambar, masala, garnish, and steam — are all CSS-generated.

Final Thoughts

Masala dosa is one of those foods that feels like home, and that made it a perfect fit for the Comfort Food Edition challenge.

This challenge pushed me to look at CSS not just as a styling language, but as a tool for creating illustrations and experiences.

A little CSS, a little creativity, and a lot of dosa. 🍽️❤️

Project: CSS Masala Dosa — A Plate of Comfort
Built with: HTML, CSS, JavaScript
Platform: CodePen
Challenge: Frontend Challenge — Comfort Food Edition / CSS Art

Solstice Runner — A Browser Game Tribute to Alan Turing

MakendranG — Sat, 13 Jun 2026 16:49:06 +0000

This is a submission for the June Solstice Game Jam

What I Built

Solstice Runner is a browser-based endless runner where you play as a ray of sunlight racing across the June solstice sky — the longest day of the year. Your goal: jump over creeping shadow obstacles and survive as long as possible.

As you play, the world transforms around you. The sky slowly shifts from warm midsummer gold to deep solstice night — a dawn-to-dusk progression tied to your score. Stars emerge, the moon rises, and the obstacles grow faster and taller. The game ends when shadow swallows you.

Alan Turing tribute: the shadow obstacles are etched with binary code — fragments of the ASCII encoding of "ALAN" and bits from the binary patterns of early computing. As you play, facts about Turing appear at the bottom of the screen, reminding you whose birthday falls just after this solstice. He was a man whose brilliant light the world tried to extinguish. In this game, you fight to keep the light alive.

Video Demo

Code

MakendranG / solstice-runner

A June Solstice browser game — tribute to Alan Turing

solstice-runner

A June Solstice browser game — tribute to Alan Turing

View on GitHub

The full game is a single HTML file — no frameworks, no build tools, just vanilla Canvas 2D.

Key files:

index.html — the entire game (canvas, game loop, rendering, input handling)

How I Built It

The game is built entirely with the HTML5 Canvas API and vanilla JavaScript — no libraries, no frameworks. Everything runs in a single <canvas> element.

Game loop: A standard requestAnimationFrame loop handles both update and draw each frame, keeping physics and rendering in sync.

Physics: The player has a simple gravity accumulator (vy += 0.58 per frame) with a ground clamp. Jumping applies an instant upward velocity (vy = -12.5). It's minimal but feels satisfying because the gravity is tuned to feel snappy rather than floaty.

Sky progression: Instead of a timer, the sky phase is derived directly from the player's score — skyPhase = score / 280. This means the longer you survive, the deeper into night you go. Colors are linearly interpolated between hex values for dawn and dusk, so the sky transitions feel smooth without any keyframe animation system.

Obstacle spawning: Spawn interval shortens as the score rises (interval = max(38, 88 - score * 0.38)), creating a natural difficulty curve. Tall obstacles (60–84px) appear once your score passes 8, requiring better-timed jumps.

The Turing layer: Every shadow obstacle has a ~55% chance of displaying a binary string down its face — fragments of ASCII "ALAN", "10" (binary for 2, Turing's birthday month), and "T". These are purely decorative but reward players who notice them. Additionally, a fact about Alan Turing surfaces every ~420 frames, surfacing quietly below the game without interrupting play.

Celestial bodies: The sun tracks across the sky and fades as skyPhase rises. The moon fades in after skyPhase > 0.35 and gently bobs using a sine offset, giving the night sky a living quality.

Particles: Jump particles are emitted from the player's base on each jump — 8 small circles that arc outward and fade over ~22 frames. They reinforce the feel of launching a burst of light.

Prize Category

Best Ode to Alan Turing

Alan Turing was born on June 23 — two days after the solstice this game is built around. He was one of the greatest minds of the 20th century: the father of modern computing, the codebreaker who helped end World War II, and the man who first asked whether machines could think. He was also persecuted by the British government for being gay and died at 41.

This game honors him in several ways:

The shadow obstacles carry binary — the shadow in this game isn't random noise; it's encoded. Binary fragments of "ALAN" and early computing symbols are etched into each shadow pillar. The thing trying to stop you isn't mindless — it has structure, like the ciphers Turing spent his life breaking.
The player is light — Turing's work was about illuminating problems that seemed unsolvable. Playing as a sunbeam fighting off darkness felt like the right metaphor.
Turing facts surface during play — players learn about his work and his life without it feeling like a lecture. A new fact appears every ~40 seconds, quietly, below the game.
The solstice timing — June 23 is two days after June 21. The jam ends on the solstice. This game is set on that exact day. The connection felt too meaningful to ignore.

The mechanics, the visual language, and the narrative are all built around one idea: light persists, even when the world tries to extinguish it.

Built during the June Solstice Game Jam, June 2026.

How I Ran a Local AI Assistant on AWS Cloud9 Using OpenClaw — A Complete Getting Started Guide

MakendranG — Sun, 26 Apr 2026 16:34:20 +0000

This is a submission for the OpenClaw Writing Challenge

Personal AI should belong to you. Not a subscription. Not a third-party server. Not someone else's cloud. Just your machine, your model, your data.

That's exactly what OpenClaw makes possible — and in this guide, I'll walk you through how I set it up from scratch on AWS Cloud9, the challenges I ran into, and what I learned along the way.

What is OpenClaw?

OpenClaw is an open-source personal AI assistant platform that you self-host. Think of it as your own private AI that runs on your hardware, uses open-source language models, and never sends your data anywhere you don't control.

What makes it powerful:

🔒 Privacy-first — everything runs locally
🧩 Hackable — build custom skills and integrations
🆓 Free — no API costs, no subscriptions
🌐 Deployable anywhere — your laptop, a Raspberry Pi, or a cloud VM

Why AWS Cloud9?

Cloud9 is AWS's browser-based IDE that comes with a full EC2 instance behind it. It's perfect for OpenClaw because:

You get a real Linux environment instantly
No local setup required — works from any browser
Easy to scale storage and compute as needed
Always online — your OpenClaw instance keeps running

Step 1: Set Up Your EC2 Instance

Before anything else, make sure your EC2 instance has enough storage. AI models are large — LLaMA 3.2 alone is about 2GB.

Expand your EBS volume to at least 30GB:

AWS Console → EC2 → Volumes
Select your volume → Actions → Modify Volume
Change size to 30GB → Modify

Then resize the filesystem inside Cloud9:

sudo growpart /dev/nvme0n1 1
sudo xfs_growfs -d /
df -h  # verify the new size

Step 2: Install Ollama

Ollama is the engine that runs open-source language models locally. Installing it on EC2 takes one command:

curl -fsSL https://ollama.com/install.sh | sh

Verify it's running:

ollama --version
curl http://127.0.0.1:11434

Step 3: Pull a Language Model

I recommend starting with LLaMA 3.2 (3B) — it's fast enough on CPU and produces quality responses:

ollama pull llama3.2

Test it immediately:

ollama run llama3.2 "What is OpenClaw in one sentence?"

💡 Tip: Avoid llama3.2:1b for production use — the 1B model gives inconsistent, low-quality responses. The 3B model is worth the extra 1.5GB.

Step 4: Build the OpenClaw Agent

Create your project folder:

mkdir ~/environment/openclaw-demo
cd ~/environment/openclaw-demo
python3 -m venv venv
source venv/bin/activate
pip install flask requests

Create the agent file openclaw_agent.py:

from flask import Flask, request, jsonify
import json, os, subprocess
from datetime import datetime

app = Flask(__name__)
TASKS_FILE = "tasks.json"

def load_tasks():
    if os.path.exists(TASKS_FILE):
        with open(TASKS_FILE) as f:
            return json.load(f)
    return []

def save_tasks(tasks):
    with open(TASKS_FILE, "w") as f:
        json.dump(tasks, f, indent=2)

def ask_ollama(prompt):
    try:
        result = subprocess.run(
            ["ollama", "run", "llama3.2", prompt],
            capture_output=True, text=True, timeout=60
        )
        return result.stdout.strip()
    except Exception as e:
        return f"Error: {str(e)}"

@app.route("/task", methods=["POST"])
def add_task():
    data = request.get_json()
    if not data or "text" not in data:
        return jsonify({"error": "Missing text field"}), 400
    text = data["text"]
    ai_summary = ask_ollama(
        f"In one short sentence, rewrite this as a clear task: {text}. Reply with only the task sentence."
    )
    task = {
        "id": len(load_tasks()) + 1,
        "text": text,
        "ai_summary": ai_summary,
        "done": False,
        "created_at": datetime.now().isoformat()
    }
    tasks = load_tasks()
    tasks.append(task)
    save_tasks(tasks)
    return jsonify({"status": "added", "task": task})

@app.route("/tasks", methods=["GET"])
def get_tasks():
    return jsonify(load_tasks())

@app.route("/health", methods=["GET"])
def health():
    return jsonify({"status": "ok"})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=3000, debug=False)

Step 5: Run the Agent

Terminal 1:

cd ~/environment/openclaw-demo
source venv/bin/activate
python openclaw_agent.py

You should see:

* Running on http://0.0.0.0:3000

Terminal 2 — Test it:

curl -s -X POST http://127.0.0.1:3000/task \
  -H "Content-Type: application/json" \
  -d '{"text": "Review pull requests before standup"}' | python -m json.tool

Expected response:

{
  "status": "added",
  "task": {
    "id": 1,
    "text": "Review pull requests before standup",
    "ai_summary": "Review all open pull requests prior to the standup meeting.",
    "done": false,
    "created_at": "2026-04-26T10:00:00.000000"
  }
}

Step 6: Check the Health Endpoint

curl -s http://127.0.0.1:3000/health

{"status": "ok"}

Common Issues & Fixes

Problem	Fix
`Port 3000 already in use`	Run `sudo fuser -k 3000/tcp`
`disk full` error	Expand EBS volume + run `xfs_growfs`
`venv/bin/activate not found`	Run `python3 -m venv venv` first
Empty JSON response	Restart agent, check Ollama is running
Slow AI responses	Normal on CPU-only EC2 — upgrade instance type for speed

What OpenClaw Gets Right

After building with OpenClaw, here is what stands out:

1. The privacy model is genuine. Nothing leaves your instance. No telemetry, no API calls to external services, no usage data. For anyone building tools that handle personal or sensitive information, this is a game changer.

2. The architecture is composable. Every skill is just an endpoint. Adding a new capability means adding a new route. This is the right level of abstraction — simple enough for beginners, flexible enough for complex workflows.

3. It works on modest hardware. No GPU required. A standard EC2 t3.medium instance runs LLaMA 3.2 perfectly well for personal use. The barrier to entry is genuinely low.

What's Next

Now that the foundation is running, here is what I plan to build on top of it:

📅 /reminder endpoint — schedule tasks with time-based alerts
🏷️ /prioritize endpoint — AI ranks your task list by urgency
🌐 Web UI — a simple HTML frontend instead of CLI
📊 /summary endpoint — daily digest of pending tasks

The beauty of OpenClaw is that each of these is just another Flask route + an Ollama prompt. The pattern scales naturally.

Final Thoughts

If you've been waiting for a reason to try self-hosted AI, OpenClaw is it. The setup is approachable, the architecture is clean, and the results are genuinely useful. You don't need a GPU, a paid API, or a powerful local machine — just an EC2 instance and curiosity.

Start small. Build one skill. See what clicks. Then build another.

👉 Full source code: github.com/MakendranG/openclaw-task-manager

ClawCon Michigan

I didn't attend ClawCon Michigan in person, but following the community online made it clear why this event exists. The people building with OpenClaw aren't just tinkering — they're making a genuine case that personal AI should be private, local, and owned by the user. That idea is worth celebrating in person, and I hope to join the next one. 🦞

I Built an AI Task Manager on AWS Cloud9 with OpenClaw and LLaMA 3.2 — Fully Self-Hosted

MakendranG — Sun, 26 Apr 2026 16:30:19 +0000

This is a submission for the OpenClaw Challenge.

What I Built

I built OpenClaw Task Manager — an AI-powered personal task assistant that runs entirely on AWS Cloud9 with no external APIs and no data leaving your server.

The problem it solves is simple: most task managers are dumb. You type a task, it stores it. That's it. I wanted something smarter — where you type in plain English and an AI understands, summarizes, and organizes it for you automatically.

The stack:

🧠 LLaMA 3.2 (via Ollama) — local AI brain
⚙️ Flask — lightweight backend agent API
💻 Python CLI — simple terminal interface
☁️ AWS Cloud9 + EC2 — fully cloud-hosted deployment
📁 JSON — local task storage

👉 GitHub: MakendranG/openclaw-task-manager

How I Used OpenClaw

OpenClaw acts as the intelligent middleware between raw user input and structured task storage. Here is the full workflow I set up:

1. User Input (CLI)
The user types a task in plain natural language via app.py:

Enter command: add
Enter task: Remind me to deploy tomorrow at 10 AM

2. Agent Processing (Flask API)
app.py sends the task as a POST request to the OpenClaw agent running on port 3000:

res = requests.post("http://127.0.0.1:3000/task", json={"text": text})

3. AI Summarization (LLaMA 3.2 via Ollama)
The agent passes the task to LLaMA 3.2 with a focused prompt:

ask_ollama(f"In one short sentence, rewrite this as a clear task: {text}. Reply with only the task sentence, nothing else.")

4. Storage
The task is saved to tasks.json with full metadata — ID, original text, AI summary, timestamp, and completion status.

3 REST Endpoints Powering the App:

Method	Endpoint	Description
POST	`/task`	Add and AI-process a new task
GET	`/tasks`	Retrieve all stored tasks
GET	`/health`	Confirm agent is alive

Demo

Terminal 1 — AI Agent running:

* Serving Flask app 'openclaw_agent'
* Running on http://0.0.0.0:3000

Terminal 2 — Adding a task:

OpenClaw Task Manager
Commands: add, list, exit

Enter command: add
Enter task: Remind me to deploy tomorrow at 10 AM

Status code: 200
✅ Task added: {
  "id": 1,
  "text": "Remind me to deploy tomorrow at 10 AM",
  "ai_summary": "Deploy the application tomorrow at 10 AM.",
  "done": false,
  "created_at": "2026-04-26T15:44:45.014827"
}

Listing all tasks:

Enter command: list

📋 Current Tasks:
  1. ⏳ Remind me to deploy tomorrow at 10 AM

Health check:

curl -s http://127.0.0.1:3000/health
{"status": "ok"}

Direct API test:

curl -s -X POST http://127.0.0.1:3000/task \
  -H "Content-Type: application/json" \
  -d '{"text": "Finish the OpenClaw blog post"}' | python -m json.tool

{
  "status": "added",
  "task": {
    "ai_summary": "Complete the OpenClaw blog post.",
    "created_at": "2026-04-26T16:00:00.000000",
    "done": false,
    "id": 2,
    "text": "Finish the OpenClaw blog post"
  }
}

👉 Full source code: github.com/MakendranG/openclaw-task-manager

What I Learned

1. Ollama on EC2 is surprisingly easy
A single curl install script set up Ollama with a systemd service automatically. No GPU required — it runs fine in CPU-only mode on a standard EC2 instance. Slower, but functional.

2. Model size changes everything
I started with llama3.2:1b and got noisy, confused responses. Switching to the full llama3.2 (3B) made the AI summaries clean and accurate immediately. For production use, always test multiple model sizes before settling.

3. Port conflicts are a real gotcha on Cloud9
Cloud9 persists your environment between sessions, so old processes keep running on ports even after you close the browser. Always run:

sudo fuser -k 3000/tcp

before restarting your agent.

4. Disk space fills up fast with AI models
LLaMA 3.2 is about 2GB. My EC2 instance started at 10GB and hit 100% disk usage. I had to expand the EBS volume from 10GB to 500GB and run xfs_growfs to reclaim the space. Always size your storage generously before pulling models.

5. The architecture is genuinely hackable
Adding a new OpenClaw skill is just adding a new Flask route. I can already see how to extend this with /reminder, /prioritize, or a full web UI frontend. The pattern is clean and composable.

ClawCon Michigan

I didn't attend ClawCon Michigan in person, but the energy of the IRL OpenClaw community inspired this entire build. The core idea behind OpenClaw — that personal AI should run locally, on your own hardware, under your own control — really resonates with me as a developer.

This project is proof that you don't need cloud AI APIs or subscriptions to build something genuinely useful. A free EC2 instance, Ollama, and an open-source model is all it takes. That's the spirit of OpenClaw, and that's what I wanted to demonstrate with this build. 🦞

From Vertex AI to Agent Platform: Why Google's Rebrand Is Actually a Philosophical Shift

MakendranG — Sun, 26 Apr 2026 13:49:05 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

When Google announced the renaming of Vertex AI to Gemini Enterprise Agent Platform at Cloud Next '26, the developer community's first instinct — including mine — was to roll their eyes. Oh great, another rebrand. Another product with a longer name, a fresh landing page, and the same underlying tech wearing a new suit.

But the more I dug into it, the more I realized this isn't a marketing exercise. It's a fundamental statement about how Google thinks AI development should work — and whether that bet pays off has real consequences for the millions of developers building on their platform.

What Actually Changed (Beyond the Name)

The core announcement is this: Vertex AI is no more. All future services, features, and roadmap investments will flow exclusively through the Agent Platform. That's not a small thing. Vertex AI has been the workhorse of enterprise ML on Google Cloud for years. Killing its independent identity signals that Google believes the standalone model API paradigm is over.

In its place, the Agent Platform is organized around four explicit pillars: Build, Scale, Govern, and Optimize. Each has real new substance:

Build gets a dramatically upgraded Agent Development Kit (ADK), now capable of organizing agents into networks of sub-agents using a graph-based framework. Over six trillion tokens are processed monthly through ADK — and the new architecture lets you define explicit, auditable logic for how agents collaborate. That's a significant shift from "prompt and pray."
Scale is handled by Agent Runtime, which promises sub-second cold starts and natively supports long-running agents that can operate in the background inside secure sandboxed environments.
Govern introduces Agent Identity — granular permissions for agents — and Agent Gateway, which enforces runtime policies, handles traffic governance, and integrates with Model Armor for prompt-injection protection. This is the layer that has been conspicuously missing from most agentic frameworks.
Optimize gives you Agent Observability, Agent Simulation, and Agent Evaluation. These aren't buzzwords. If you've ever tried to debug a multi-agent pipeline, you know that without proper observability, you're flying blind.

The Insight Google Is Actually Selling

Here's the provocative thesis embedded in everything Google announced: agents aren't AI features, they're software workloads.

The old model — call an API, get a response, maybe chain a few prompts — treats AI as a capability you bolt onto existing software. The Agent Platform treats agents as first-class distributed systems citizens, complete with identity, permissions, runtime environments, observability, and deployment pipelines.

As Thomas Kurian put it in the keynote: the era of the pilot is over. The era of the agent is here.

That framing has an important implication for developers. The skills you already have — designing stateful systems, managing service-to-service auth, observing distributed workloads — are now directly applicable to AI development. The Agent Platform is essentially saying: stop thinking of this as "AI stuff" and start thinking of it as software engineering.

Whether that resonates with you probably depends on what you've been building. If you've been frustrated by the gap between "AI demo" and "production system," this architecture starts to close it.

What I'm Most Excited About: The Model Garden Honesty

One detail that doesn't get enough attention: the Agent Platform's Model Garden now offers over 200 models, including third-party models like Anthropic's Claude family, Llama, DeepSeek, Mistral, and Grok — alongside Google's own Gemini 3.1 Pro, Gemini 3.1 Flash Image (Nano Banana 2), Lyria 3, and Veo 3.1.

This is a smart and somewhat gutsy call. Google is essentially saying: we're confident enough in our platform and infrastructure that we'll let you use a competitor's model on our cloud. The bet is that developer lock-in comes from the tooling, the data layer, and the runtime — not from forcing you onto a single model.

For builders, this is the right approach. The model landscape changes every few months. Tying your production architecture to a single provider's model is a liability. A platform that abstracts that choice and lets you swap models without rearchitecting everything is genuinely valuable.

The Honest Critique: This Is Complex by Default

There's a real risk buried in all this architectural ambition. The Agent Platform now has: Agent Studio, ADK, Agent Garden, Agent Runtime, Agent Gateway, Agent Identity, Agent Registry, Agent Observability, Agent Simulation, Agent Evaluation, Model Garden, RAG Engine, Vector Search, and Colab Enterprise Notebooks.

That is a lot of surface area.

For developers coming from simpler agentic frameworks — LangChain, CrewAI, bare API calls with a bit of orchestration logic — the on-ramp here is non-trivial. The low-code Agent Designer and Agent Studio help, but anyone building anything with real production requirements will quickly find themselves needing to understand the full stack.

The governance and security features that make this genuinely enterprise-grade are also the same features that add complexity for smaller teams. There's a real question of whether a three-person startup building an AI-powered product actually benefits from Agent Identity and Agent Gateway, or whether those layers just slow them down.

Where This Lands

Google Cloud Next '26 drew over 32,000 attendees, and the central message was clear: agentic AI is moving from experimentation to infrastructure. The Gemini Enterprise Agent Platform is Google's answer to what that infrastructure should look like.

I think they've gotten the architecture largely right. Treating agents as managed enterprise workloads — with identity, observability, evaluation, and runtime controls — is the correct mental model for production deployments. The multi-model openness is a genuine competitive differentiator.

The challenge is execution. A platform this broad needs excellent documentation, sensible defaults, and a clear decision tree for developers figuring out which component they actually need. The history of developer platforms is littered with comprehensive systems that became comprehensive obstacles.

If Google ships this with the developer experience it deserves, the Agent Platform could genuinely become the foundation of how enterprise AI gets built. If they treat completeness as a substitute for clarity, it'll be another sprawling cloud console that consultants bill hours navigating.

The bones are good. The proof is in the build.

What are you most interested in exploring from Cloud Next '26? Drop a comment — particularly curious if anyone has already gotten their hands on the new ADK graph-based framework.

EcoTrack — A Habit Tracker for the Planet 🌍

MakendranG — Sun, 19 Apr 2026 16:59:54 +0000

This is a submission for Weekend Challenge: Earth Day Edition

What I Built

EcoTrack is a zero-dependency eco habit tracker that helps everyday people build and stick to planet-friendly habits — one small action at a time.

The idea is simple: most people want to live more sustainably but don't have a lightweight, friction-free way to stay accountable. EcoTrack makes it as easy as checking off a to-do list — but for the planet 🌍.

Key features:

Daily one-tap habit check-in with per-habit streak tracking
Progress ring showing today's completion at a glance
7-day weekly heatmap to visualize consistency
Cumulative impact dashboard — CO₂ saved, plastic avoided, energy and water conserved
Browser push notification reminders at your chosen time
Add custom habits beyond the defaults
Fully offline — all data stored in localStorage, no account needed

Default habits include: using a reusable bag, choosing public transport, eating plant-based meals, turning off unused lights, and carrying a reusable water bottle.

Demo

🔗 Live App: EcoTrack — Eco Habit Tracker

Code

🐙 GitHub Repository: github.com/makendrang/ecotrack

The entire app lives in a single index.html file — no build step, no dependencies, no framework. Clone it and open it directly in your browser.

ecotrack/
└── index.html   # Complete app — HTML + CSS + JS in one file
└── README.md

How I Built It

EcoTrack is built with pure vanilla HTML, CSS, and JavaScript — deliberately no frameworks or dependencies. The goal was to keep the app as lightweight and accessible as possible, something anyone could fork, modify, and host in minutes.

Technical highlights:

localStorage powers all persistence — habits, daily logs, streaks, and reminder settings all survive page reloads with no backend
Streak algorithm iterates backwards from today through the log to calculate per-habit and overall streaks
Impact calculations map each habit to an environmental category (carbon, plastic, energy, water) and compute cumulative totals across all logged days
Web Notifications API handles the reminder system — the app requests permission, then schedules a setTimeout to fire a browser notification at the user's chosen daily time
CSS-only animations drive the progress ring (SVG stroke-dashoffset transition) and impact bar reveals — no JS animation libraries needed

How GitHub Copilot helped:

GitHub Copilot was instrumental in keeping the build moving over a tight weekend window. Specific wins:

Generated the streak calculation logic from a plain English comment in seconds
Autocompleted repetitive localStorage get/set patterns without me writing boilerplate
Suggested the SVG stroke-dashoffset animation approach for the progress ring when I described what I wanted in a comment
Wrote the Web Notifications API scheduling logic — I just described "fire a notification at a user-chosen time daily" and Copilot filled in the setTimeout + Notification constructor code
Helped write the CSS dot-grid background texture and the radial gradient layering

What would have taken a full day of boilerplate and MDN lookups was compressed into a focused few hours, leaving more time to refine the UI and Earth Day theming.

Prize Categories

✅ Best Use of GitHub Copilot

GitHub Copilot wasn't just a convenience here — it was a core part of making this build possible within a weekend. From streak logic to notification scheduling to SVG animation, Copilot accelerated nearly every technical decision in the project. I used inline suggestions throughout the codebase and Copilot Chat to reason through the localStorage data model before writing a single line.

Chaos vs Calm: An Interactive Frontend Art Experience

MakendranG — Sat, 04 Apr 2026 12:18:26 +0000

This is a submission for the 2026 WeCoded Challenge: Frontend Art

Show us your Art

🔗 Live Demo: https://makendrang.github.io/frontend-art-chaos-calm/

This is an interactive frontend artwork where:

The left side represents calm
The right side represents chaos
Your mouse movement controls the balance between them

Move your mouse and experience the shift between stability and unpredictability.

Inspiration

This piece is inspired by the constant balance we experience in life:

Focus vs distraction
Calm vs chaos
Control vs randomness

Sometimes we feel completely in control, and sometimes everything feels chaotic.

This artwork visualizes that emotional and mental balance in a simple, interactive way.

My Code

💻 GitHub Repo: https://github.com/MakendranG/frontend-art-chaos-calm.git

Final Thoughts

Frontend development is not just about building applications.

It can also be a medium for expression.

This project explores how simple code can create an emotional and interactive experience.

From Curiosity to Confidence: My Journey Through Code, Community, and Consistency

MakendranG — Sat, 04 Apr 2026 12:04:11 +0000

This is a submission for the 2026 WeCoded Challenge: Echoes of Experience

When I first stepped into the world of tech, I didn’t have a grand plan.

No roadmap. No perfect strategy.

Just curiosity… and a lot of questions.

🌱 The Beginning: Learning Without a Clear Path

Like many others, I started by exploring different technologies—trying to understand what “fits.”

From cloud platforms to frontend development, from writing simple scripts to working on real-world projects, every step felt like:

👉 “Am I going in the right direction?”

There were moments of confusion:

Too many tools to learn
Too many opinions on what’s “best”
Too many comparisons with others

And yet, the only thing that kept me moving forward was:

👉 Consistency over clarity

🚧 The Challenges: Self-Doubt & Information Overload

One of the biggest challenges wasn’t technical—it was mental.

Seeing others move faster
Feeling like I needed to know everything
Questioning whether I was “good enough”

In tech, it's easy to feel like you're always behind.

But over time, I realized:

👉 Everyone is figuring things out as they go

Even the people we look up to.

🚀 The Turning Point: Building in Public

Things changed when I started:

Participating in challenges
Writing blogs
Sharing projects

Instead of waiting to be “perfect,” I started to ship and share.

That’s when I noticed:

People appreciated honesty over perfection
Learning became more structured
Confidence started building naturally

🏆 Small Wins That Matter

Some milestones that made a big difference:

Contributing to technical blogs
Participating in developer challenges
Getting recognition for my work

These weren’t just achievements—they were confidence boosters.

They proved:

👉 Progress is happening, even when it feels slow

🤝 The Power of Community

One of the most underrated aspects of this journey has been the community.

Developer platforms
Online challenges
Shared learning experiences

They create an environment where:

You can learn openly
You can fail safely
You can grow collectively

💡 Lessons I Learned

If I had to summarize my journey, it would be these:

1. You don’t need to know everything to start

Start small. Learn along the way.

2. Consistency beats intensity

Daily effort > occasional bursts

3. Build things—even if they’re imperfect

Projects teach more than tutorials ever can

4. Share your journey

Your story can help someone else

5. Comparison slows you down

Focus on your own path

🌍 To Anyone Feeling Unsure

If you’re someone who:

Feels lost in tech
Thinks you’re not “ready”
Wonders if you belong

Let me tell you:

👉 You do belong here

Your journey doesn’t need to look like anyone else’s.

✨ Final Thoughts

Looking back, I didn’t need:

The perfect plan
The perfect skills
The perfect timing

I just needed to:

👉 Start

👉 Continue

👉 Not give up

And that made all the difference.

If my journey resonates with you in any way, that’s already a win. 💙

🛑 Procrastination-as-a-Service (PaaS): Avoid Work Efficiently

MakendranG — Sat, 04 Apr 2026 11:39:59 +0000

This is a submission for the DEV April Fools Challenge

What I Built

🛑 Procrastination-as-a-Service (PaaS)

What if software helped you avoid work… efficiently?

I built a completely useless web app that:

Generates smart excuses
Distracts you with random websites
Simulates progress… backwards

Because productivity is overrated 😄

Demo

🔗 Live Demo: https://makendrang.github.io/paas-procrastination/

Code

💻 GitHub Repo: https://github.com/MakendranG/paas-procrastination.git

How I Built It

HTML, CSS, JavaScript
Randomized excuse engine
Reverse progress bar logic
Anti-UX interactions

The goal was simple:
👉 Build something functional

👉 But completely useless

Final Thoughts

If this app helped you avoid your work today…

👉 It worked perfectly 🚀

My Portfolio Explains Itself: Building an AI-Powered Architecture Visualizer with Gemini

MakendranG — Sun, 01 Feb 2026 11:52:36 +0000

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

About Me

I'm a cloud and AI-focused developer who enjoys building systems that are not just functional, but explainable. Over the years, I've worked with cloud-native architectures, DevOps workflows, and AI-powered applications, and I've noticed a recurring problem: great systems are often hard to understand at a glance.

With this portfolio, I wanted to go beyond a static showcase of projects. My goal was to create an interactive experience that reflects how I think as a developer — focused on clarity, scalability, and real-world impact — while also demonstrating how AI can make complex architectures easier to understand for everyone, not just engineers.

Portfolio

My portfolio is a live, deployed application that visualizes my app architecture and uses Gemini to explain how traffic flows through the system in real time.

It walks visitors through:

Entry points (user → Cloud Run)
API interactions
Data persistence layers
AI model interactions
End-to-end request flow

🚀 Live Demo

AI Studio Interactive Demo:

Launch Portfolio Visualizer →

GitHub Repository:

MakendranG/gemini-portfolio-visualizer →

This allows recruiters, engineers, and even non-technical visitors to understand what's happening under the hood without needing to read architecture diagrams or documentation.

How I Built It

Tech Stack

Frontend: Lightweight web UI for architecture visualization
Backend: Containerized service deployed on Google Cloud Run
AI: Gemini (via Google AI tools) for natural-language architecture explanations
Infrastructure: Google Cloud (Cloud Run, APIs, IAM)
Deployment: Container-based CI-friendly setup
Source Code: Available on GitHub

Google AI Tools Used

Gemini models to:
- Interpret architecture components
- Generate step-by-step traffic flow explanations
- Adapt explanations based on user-selected components
AI Studio for rapid prototyping and deployment
Gemini APIs to refine prompts and integrate intelligent explanations

Design Decisions

Kept the UI intentionally minimal so the architecture and explanations stay front and center
Focused on explainability, not just visuals
Designed prompts to explain the same architecture at different levels of depth, depending on the viewer
Made the entire project open source so other developers can learn from and build upon it

The entire app is stateless, fast to spin up, and well within the Google Cloud Free Tier, making it practical as well as production-aligned.

Development Process

Prototyped in AI Studio - Experimented with different Gemini prompts to find the best way to explain architecture concepts
Built the visualization layer - Created interactive components that respond to user clicks
Integrated Gemini API - Connected the frontend to Gemini for real-time explanations
Containerized & Deployed - Packaged everything for Cloud Run deployment
Open sourced - Published the complete source code on GitHub for the community

What I'm Most Proud Of

🧠 AI-powered explainability

Gemini doesn't just describe components — it explains why traffic flows the way it does.

☁️ Cloud-native by design

Fully containerized and deployed on Cloud Run, following real-world best practices.

🎯 Audience-aware explanations

The same architecture can be understood by a junior developer, a product manager, or a senior engineer.

🚀 A portfolio that does something

Instead of telling people I understand cloud architectures, this portfolio shows it.

💻 Open source contribution

The complete source code is available on GitHub, making it a learning resource for the developer community.

🎨 Built with Google AI Studio

Leveraged AI Studio's rapid prototyping capabilities to iterate quickly and deploy seamlessly.

🔗 Quick Links

Live Demo: AI Studio App
Source Code: GitHub Repository
Architecture Docs: See the README in the GitHub repo

Try it yourself: Click any component in the live demo and watch Gemini explain how your request travels through the system! 🎯