Forem: Dickson Kanyingi

EcoOS Intelligence: Reimagining Sustainability with AI

Dickson Kanyingi — Mon, 20 Apr 2026 03:21:21 +0000

This is a submission for Weekend Challenge: Earth Day Edition

What I Built

What if every daily decision showed its carbon cost before you made it?

Built for the DEV Earth Day Challenge, EcoOS Intelligence is a real-time, AI-powered system that transforms sustainability from abstract awareness into clear, measurable action.

Instead of static calculators, EcoOS acts as a behavioral operating system for climate action—helping users understand, simulate, and improve their impact across everyday life.

⚡ What Makes This Different?

Most climate tools tell you what happened.

EcoOS shows you what will happen before you act.

🧠 AI reasoning engine → breaks down lifestyle into real CO₂ impact
🎯 What-if simulator → test decisions before committing
💬 Personal AI coach → adapts to your behavior over time
♻️ Image-based waste analysis → classify real-world waste instantly
🏆 Gamified system → turns sustainability into daily action

👉 This is not a tracker. It's a decision-making system.

🧩 The Problem

People care about sustainability—but don't act consistently.

Why?

Data is complex and hard to interpret
Tools are passive (no feedback loop)
Advice is generic and not personalized
Impact is invisible in daily decisions

👉 The gap isn't awareness—it's actionability.

💡 The Solution: EcoOS Intelligence

EcoOS is a modular ecosystem focused on turning intention into action across the most impactful areas of personal sustainability:

🌱 Carbon Mirror — The Intelligence Engine

Describe your lifestyle in plain English. Gemini performs multi-step reasoning:

Decomposition — Parse activities into discrete categories
Category Scoring — Estimate CO₂ using established emission factors
Synthesis — Compute confidence-weighted totals
Recommendations — Generate prioritized, quantified action plans
JSON Schema Validation — 6 custom validators ensure structured, type-safe responses
Multi-Platform Sharing — Share results to X/Twitter, Facebook, LinkedIn, or copy for Instagram & TikTok

🎯 What-If Simulator — The "Wow" Feature

Ask "What if I stop using Uber for a month?" and get:

Timeline projections (1 month, 6 months, 1 year)
Money saved alongside CO₂ saved
Tangible equivalences (trees, flights, driving distance)
Community scale — "If 10,000 people did this..."

💬 Carbon Coach — Your AI Advisor

A conversational AI that remembers your history:

Knows your eco-score, past analyses, completed quests
Gives realistic, specific advice — not generic platitudes
Persists conversations across sessions
Adjusts your eco-score based on engagement

🏆 Eco-Quest — The Behavior Engine

AI-generated daily challenges that adapt to what you've already done:

Never repeats previously completed quests
Every mission includes quantified impact metrics
Points system feeds into your overall sustainability grade

♻️ WasteWise Vision (The "WOW" Multi-Modal Feature)

Image-based waste classification powered by Gemini 2.0 Flash's visual reasoning.

Upload or drag-and-drop a photo of your waste.
Gemini visually decomposes the materials, checks for contamination, and provides the exact disposal category.

🚗 EcoRoute

Transport optimization comparing 9 modes (Car, EV, Motorcycle, Bus, Train, Bike, Walk, Plane, Boat) with annual projections and community scale impact.

Demo

Live Demo: EcoOS.vercel.app

📸 Visual Walkthrough

Feature	Screenshot
🌱 Carbon Mirror — AI analyzes your lifestyle
🎯 What-If Simulator — See impact before you act
♻️ WasteWise — Image-based classification
🚗 EcoRoute — 9-mode transport comparison
💬 Carbon Coach — Personalized AI advisor
📊 Dashboard — Your sustainability command center

🎥 Quick Demo Flow (2 minutes)

Carbon Mirror → Describe your lifestyle → watch real-time breakdown
What-If Simulator → "What if I stop using Uber for a month?" → see yearly impact
Carbon Coach → Ask anything → get personalized advice
WasteWise → Upload an image → get disposal guidance
Dashboard → See your eco-score evolve

👉 Full flow takes under 2 minutes.

Code

GitHub: github.com/kanyingidickson-dev/EcoOS

How I Built It

🧠 Best Use of Google Gemini: Built for Reliability

For a tool like EcoOS, speed and reliability are everything. We built a production-grade AI reasoning engine with multi-layered resilience — not just a chat wrapper.

1. Structured JSON Mode

Every response uses responseMimeType: "application/json" for 100% reliable UI rendering:

{
  "estimate": 245,
  "confidence": "medium",
  "breakdown": [
    { "category": "Transport", "value": 120, "detail": "Daily 20km commute" },
    { "category": "Food", "value": 75, "detail": "Occasional meat consumption" }
  ],
  "suggestions": [
    "Switch to public transit 3 days/week — saves ~48kg CO2/month",
    "Adopt plant-based meals on weekdays — saves ~35kg CO2/month"
  ]
}

2. Multi-Step Reasoning (Chain-of-Thought)

Every prompt follows a structured pipeline, not a simple "input → output":

STEP 1 — DECOMPOSITION: Parse input into categories
STEP 2 — SCORING: Estimate using emission factors
STEP 3 — SYNTHESIS: Confidence-weighted totals
STEP 4 — RECOMMENDATIONS: Prioritized by impact

3. Response Validation & Reliability

6 custom validators ensure every response has correct structure
Numeric sanitization prevents NaN/undefined from reaching the UI
Retry with exponential backoff before graceful mock fallback
12-second timeout prevents UI hangs on slow networks

4. Personalization Engine

The system adapts over time:

Stores carbon history, waste scans, quest completions, coach topics
Injects user context into every AI prompt
Quest generator explicitly avoids repeating past challenges
Coach references your previous analyses in conversation

5. Model Cascade with Automatic Failover

Production resilience through tiered fallback when quotas are hit:

Gemini 2.5-flash (primary) → Gemini 2.0-flash (fallback) → Intelligent Mock (offline)

6. Request Optimization

Performance optimizations for scale and cost-efficiency:

In-memory caching: 5-minute TTL eliminates redundant API calls for identical inputs
Token usage logging: Cost monitoring for every API call

7. Circuit Breaker Pattern

Quota protection prevents cascade failures:

Automatic detection of rate limit (429) errors
5-minute cooldown after 2+ quota errors
Graceful degradation to intelligent mock responses without user interruption

8. Mock Fallback System

Even without an API key, the entire app remains functional with intelligent mock data that matches the exact JSON schema — perfect for offline demos and development.

🧪 Built for Real-World Constraints

EcoOS is designed to work even under API limits:

Works without an API key (intelligent fallback system)
Handles rate limits gracefully (circuit breaker)
Prevents UI failures with strict JSON validation
Optimized for low-cost, high-efficiency AI usage

👉 This ensures reliability in real-world conditions—not just ideal demos.

🧪 Testing & Quality Assurance

10 test files with 51+ tests covering validators, sanitization, and UI components
Response validation tests ensure Gemini JSON schema compliance
Mock fallback tests verify 100% offline functionality
Vitest + React Testing Library for fast, reliable test execution

🎨 Design Strategy: Premium Sustainability

We avoided the "clinical" look of traditional carbon tools. Instead, we built a high-end, dark-mode experience:

Animated SVG Ring Score — real-time eco-grade with glow effects
Glassmorphism — translucent cards with backdrop blur
Framer Motion — spring animations, staggered reveals, page transitions
Custom Slider — gradient thumb with glow shadow
Micro-Interactions — points popup, toast notifications, pulsing badges
Outfit + Inter fonts — modern, premium typography

🎥 Demo Flow

Dashboard → See the animated ring score and live community feed
Carbon Mirror → Describe your lifestyle → Watch the breakdown animate
What-If → Try "What if I go vegetarian?" → See yearly projections
Coach → Notice it says "I already know your history" → Get personalized advice
Dashboard → Your eco-score has increased ✨

🌍 Impact

Metric	Per User	At Scale (10K users)
CO₂ Awareness	Instant footprint visibility	245,000 kg CO₂ analyzed/month
Behavior Change	Personalized action plans	10,000+ daily eco-quests
Decision Support	What-if before you commit	Collective behavior shift

🚀 Future Vision

City-level integrations — aggregate neighborhood sustainability data
Carbon credit marketplace — earn real credits from verified behavior changes
Smart home integration — automated energy tracking via IoT
Corporate partnerships — employee sustainability programs

Built with 💚 for the planet.

Prize Categories

Best use of Google Gemini
- Why Gemini 2.5 Flash? It's fast, cost-effective, and perfect for real-time interactions. The AI Magic behind the scenes makes it feel alive and responsive.

#devchallenge #earthday #gemini #sustainability #nextjs #ai

# The Useless Machine™ 🫖 - A Premium Enterprise SaaS That Solves Absolutely Nothing

Dickson Kanyingi — Sat, 04 Apr 2026 17:09:32 +0000

This is a submission for the DEV April Fools Challenge

What I Built

The Useless Machine™ is a satirical, high-fidelity, and intentionally dysfunctional web application that presents itself as a premium, hyper-optimized enterprise SaaS dashboard. But every single feature is a carefully engineered betrayal of user experience.

With 22 interconnected sub-apps and the Premium Chaos v3.0 engine, it scales its dysfunction across four distinct phases (chaos engines):

Phase	Name	Behavior
1	Pristine	Perfect Glassmorphism. Smooth animations. Looks enterprise-ready.
2	Suspicious	Subtle UI wobbles. Fake AI sentience alerts. "The Watcher" starts staring harder.
3	Unstable	Evasive buttons activate. Flashbangs happen. Teapots rain from the sky.
4	Meltdown	Screen flips 180°. Rage-click triggers Panic screens, elements teleport. Full BSOD simulated.

Key "Features"

🧠 AI Code Surgery — Reviews your code and "fixes" it by adding useless complexity and renaming every variable to teapot

🎭 Watcher v3 (3D) — A Three.js mascot with eyeballs that track your cursor and jitter nervously in chaos mode

🫖 Larry Mode — Type larry anywhere to activate a global MutationObserver that replaces ALL text with 418: I'm a teapot

☕ Teapot Server — An interactive console that violently refuses coffee requests and redirects all traffic to /dev/null

🎯 Evasive Buttons — High-stakes buttons (like "Delete Account") use spring physics to physically jump away from your cursor

🎊 Tea Rain — Type tea to trigger a canvas-confetti storm of boba and teapots

Demo

👉 Live App: The Useless Machine: https://useless-machine.vercel.app
(Warning: May cause existential debugging and high-pitched ringing)

Code

All the terrible decisions are open source: repo@github/useless-machine.git

How I Built It

Tech Stack (Over-Engineered for Nothing)

Vite + React 19 — For that "fast but useless" developer experience
Framer Motion 12.38 — Gesture-driven chaos, evasive buttons, shared layout transitions with spring physics
React Three Fiber 9.5 + @react-three/drei 10.7 — 3D cursor-tracking mascot with WebGL
Three.js 0.183 — The 3D engine powering The Watcher eyeballs
Canvas Confetti 1.9.4 — High-performance "Tea Rain" particle physics
Web Audio API — Synthesizes dramatic buzzes, panic drones, and 17+ MP3 sound effects
Vanilla CSS — Premium glassmorphism aesthetic for maximum betrayal

Animation Architecture

The chaos system uses a phased approach based on user interaction count:

// Phase detection in App.jsx
const [phase, setPhase] = useState(1);
const [interactionCount, setInteractionCount] = useState(0);

useEffect(() => {
  const newPhase = Math.min(4, Math.floor(interactionCount / 15) + 1);
  setPhase(newPhase);
}, [interactionCount]);

Phase 1 (Pristine): Clean animations, no chaos
Phase 2 (Suspicious): Subtle glitches, text wobbles
Phase 3 (Unstable): Evasive buttons activate, flashbangs trigger
Phase 4 (Meltdown): Screen rotation, UI melting effects

Key Technical Achievements

Evasive Buttons: Spring physics calculation to calculate "escape" vectors from cursor position
3D Eye Tracking: Mouse position mapped to Three.js spherical rotations in real-time
Global Larry Mode: MutationObserver intercepts ALL DOM text node changes and replaces content
Panic Mode: Click velocity detection (>10 clicks/second) triggers meltdown sequence
Tea Rain: Hardware-accelerated canvas particles with emoji sprites
MP3 Audio System: 17 royalty-free sound effects with AudioContext management

Prize Category

🫖 Best Ode to Larry Masinter (RFC 2324)

This project doesn't just reference teapots—it enforces them:

Global Teapot Mutation: The larry Easter egg trigger forces a system-wide "Teapot Only" state. A MutationObserver intercepts ALL DOM text updates and replaces them with 418: I'm a teapot.
Teapot Rain: A high-performance particle system (canvas-confetti) that rains teapots when "tea" is detected.
Bug Reports: Every Jira-style ticket is prefixed with TEA-4180.
418 Server: A dedicated terminal simulation that only returns teapot status codes.
Strict RFC 2324 Compliance: Every error is 418. Every API response is a teapot. The HTTP Server component only serves 418 I'm a teapot responses.
Hyper-Premium Hostility: The contrast between the beautiful glassmorphism UI and the aggressive dysfunction creates a unique UX comedy that honors the absurdity of HTCPCP.
The Watcher: A 3D mascot that judges your lack of productivity in real-time, staring at your cursor with judgmental red pupils.

The entire application is essentially a love letter to the most famous HTTP status code that should have been: 418 I'm a teapot.

Easter Eggs to Try

Konami Code: (↑ ↑ ↓ ↓ ← → ← → B A) — Activates "Useful Mode" only to immediately delete itself
Panic Alert: Click the background rapidly 10+ times to trigger meltdown
The Larry Truth: Type larry on your keyboard at any time
Tea Rain: Type tea anywhere to trigger confetti storm
Self-Destruct: Find the ☢️ button in the footer... if you can catch it

🧠 Best Google AI Usage

I built this entire project in collaboration with Antigravity (Google's agentic AI coding assistant). Leveraging an AI to build something intentionally "useless" turned out to be a masterclass in prompt-driven chaos. We also implemented a Simulated Gemini Hub that mimics the UI of modern AI assistants but delivers confidently wrong advice with absolute certainty.

If it breaks, that's intentional. If it works, that's a bug. Built with React and an unreasonable amount of setTimeout().

🫖 RFC 2324 Compliant | ⚠️ Not Production Ready | 🎯 Zero Purpose Achieved

Project Valkyrie: AI-Powered Crisis Logistics & Response Hub (Notion Workspace)

Dickson Kanyingi — Sat, 07 Mar 2026 17:07:35 +0000

This is a submission for the Notion MCP Challenge

What I Built

Valkyrie is an AI-powered crisis response and logistics command center that uses the Model Context Protocol (MCP) to turn Notion into a real-time operations hub.

In modern logistics, "latency kills." When a natural disaster or geopolitical event occurs, operators lose precious minutes switching between news feeds, weather maps, and internal databases. Valkyrie solves this by:

Bridging external threat data with internal asset data via MCP
Autonomously staging incident responses in Notion for human approval
Maintaining relational integrity between incidents and affected assets

Key Features

Feature	Description
🔍 Autonomous Threat Monitoring	Scans simulated global feeds for risks near tracked assets
📋 Instant Incident Staging	Creates Notion pages with threat analysis and mitigation steps
🔗 Relational Asset Resolver	Maps coordinates to Notion Page IDs for data integrity
👤 Human-in-the-Loop	AI proposes solutions; humans approve and execute

MCP Tools Exposed

analyze_global_threats  → Check asset for threats, stage incident if detected
scan_all_assets         → Batch scan all tracked assets
get_asset_details       → Retrieve full asset information
list_all_assets         → List assets with risk levels (🔴🟡🟢)
find_nearest_safe_asset → Find rerouting destination during crisis

Video Demo

[Demo video - showing threat detection, incident staging, and human approval workflow]

Demo Workflow:

Ask AI: "Valkyrie, scan all assets for threats"
AI detects tropical storm near Singapore Hub
Incident page created in Notion with status "Awaiting Approval"
Operator reviews, changes status to "In Progress"
Crisis Response Playbook triggered

[Data Flow & Human-in-the-Loop Sequence - From threat detection to human approval]

Show us the code

GitHub Repository: kanyingidickson-dev/valkyrie-mcp-server

Tech Stack

MCP Server: TypeScript with @modelcontextprotocol/sdk
Notion API: v2022-06-28 with direct HTTP queries for database operations
Threat Simulator: Python FastAPI generating realistic crisis scenarios
Deployment: Docker Compose + GitHub Actions CI/CD

Project Structure

valkyrie-mcp-server/
├── src/                              # MCP server source code
│   ├── index.ts                      # MCP server entry point
│   ├── config.ts                     # Configuration management
│   ├── lib/                          # Core libraries
│   │   ├── assets.ts                 # Asset data utilities
│   │   └── assets.d.ts               # Type definitions
│   ├── tools/                        # MCP tool implementations
│   │   ├── index.ts                  # Tool exports
│   │   ├── analyze-threats.ts        # analyze_global_threats tool
│   │   ├── scan-assets.ts            # scan_all_assets tool
│   │   ├── get-asset-details.ts      # get_asset_details tool
│   │   ├── list-assets.ts            # list_all_assets tool
│   │   └── find-nearest-safe.ts      # find_nearest_safe_asset tool
│   └── types/                        # Type definitions
├── mock-api/                         # Threat simulator API
│   ├── valkyrie_mock_api.py          # FastAPI threat simulator
│   ├── requirements.txt
│   └── Dockerfile
├── scripts/                          # Orchestration & utility scripts
│   ├── seed_assets.py                # Populate Notion logistics DB
│   ├── clean_duplicates.py           # Remove duplicate assets
│   ├── scan_and_stage.js             # Scan assets and stage incidents
│   ├── trigger_and_stage.js          # Trigger threats and stage incidents
│   ├── notion_watcher.js             # Poll Notion for status changes
│   ├── webhook_server.js             # Handle Slack actions
│   ├── scheduler.js                  # Periodic scan scheduler
│   ├── notify.js                     # Notification utilities
│   └── requirements.txt
├── tests/                            # Test files
├── docs/                             # Documentation assets
│   ├── logical-overview.png
│   ├── deployment-overview.png
│   └── demo-workflow.png
├── .github/                          # CI/CD workflows
│   └── workflows/
│       └── valkyrie-deploy.yml
├── .data/                            # Local data storage
├── .husky/                           # Git hooks
├── dist/                             # Compiled output
├── package.json                      # Dependencies & scripts
├── tsconfig.json                     # TypeScript config
├── jest.config.cjs                   # Jest test config
├── .eslintrc.json                    # ESLint config
├── .prettierrc                       # Prettier config
├── docker-compose.yml                # Docker orchestration
├── Dockerfile                        # MCP server container
├── .env.example                      # Environment template
├── MCP_INSTRUCTIONS.md               # MCP usage guide
├── LICENSE
└── README.md

Key Code: Relational Asset Resolver

From src/lib/assets.ts:

// Maps external telemetry coordinates to Notion Page IDs
export async function queryNotionDatabase(
  databaseId: string,
  filter?: Record<string, unknown>
): Promise<NotionPageObject[]> {
  const res = await fetch(`https://api.notion.com/v1/databases/${databaseId}/query`, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.NOTION_TOKEN}`,
      'Content-Type': 'application/json',
      'Notion-Version': '2022-06-28',
    },
    body: JSON.stringify(filter ? { filter } : {}),
  });
  const data = await res.json();
  return data.results || [];
}

Incident Staging with Human-in-the-Loop

From src/tools/analyze-threats.ts:

// Creates Notion page with "Awaiting Approval" status
async function createIncidentPage(params: {
  assetName: string;
  assetPageId: string | null;
  category: string;
  summary: string;
  threatLevel: number;
}): Promise<string> {
  const threatLevelText = params.threatLevel >= 8 ? 'Critical (Red)' : 'Elevated (Yellow)';

  const incidentPage = await notion.pages.create({
    parent: { database_id: DASHBOARD_DB_ID },
    properties: {
      'Incident Name': {
        title: [{ text: { content: `🚨 ALERT: ${params.category} - ${params.assetName}` } }],
      },
      Status: { status: { name: 'Awaiting Approval' } },
      'Threat Level': { select: { name: threatLevelText } },
      'Affected Assets': { relation: params.assetPageId ? [{ id: params.assetPageId }] : [] },
    },
  });
  return incidentPage.id;
}

How I Used Notion MCP

The Integration

Valkyrie uses the Model Context Protocol to give AI assistants (like Windsurf's Cascade) direct access to Notion databases as tools. This unlocks:

Autonomous Database Queries - AI can query assets without manual API calls
Intelligent Incident Creation - AI stages responses with proper relations
Contextual Awareness - AI understands asset locations and risk profiles

Notion Database Schema

Operations Dashboard (Incidents DB)

Property	Type	Description
Incident Name	Title	Auto-generated: `🚨 ALERT: {Category} - {Asset}`
Status	Status	`Draft` → `Awaiting Approval` → `In Progress` → `Resolved`
Threat Level	Select	`Critical (Red)` / `Elevated (Yellow)` / `Stable (Green)`
Affected Assets	Relation	Links to Logistics DB for relational integrity
AI Assessments	Rich Text	Threat summary from simulation engine

Global Assets & Logistics DB

Property	Type	Description
Asset Name	Title	Unique facility identifier
Coordinates	Text	Latitude, Longitude (e.g., `1.2902, 103.8519`)
Risk Sensitivity	Number	1-10 scale for prioritization
Status	Select	`Active` / `Inactive` / `Maintenance`
Facility Type	Select	`Distribution Hub` / `Transport Node` / `Data Center`
Primary Contact	Text	On-site lead name
Primary Phone	Phone	Emergency contact number
Primary Email	Email	Escalation contact
Facility Manager	Text	Responsible party
Last Audit	Date	Compliance tracking

What This Unlocks

Zero-context-switching: Operators see threats and assets in one Notion workspace
AI-assisted decisions: AI proposes actions, humans approve
Relational data integrity: Incidents automatically link to affected assets
Real-time monitoring: Continuous scanning with instant notification

[Technical Component Stack - Docker containers for MCP Server and Mock API]

Try It Yourself

# Clone and setup
git clone https://github.com/kanyingidickson-dev/valkyrie-mcp-server.git
cd valkyrie-mcp-server
npm install

# Configure Notion
cp .env.example .env
# Add your NOTION_TOKEN and database IDs

# Seed assets
pip install -r scripts/requirements.txt
python scripts/seed_assets.py

# Run mock API
python mock-api/valkyrie_mock_api.py

# Build and run MCP server
npm run build
npm start

# Run a one-off scan:
node scripts/scan_and_stage.js

# Optional scheduler:
node scripts/scheduler.js

Add to your MCP client config:

{
  "mcpServers": {
    "valkyrie": {
      "command": "node",
      "args": ["/path/to/valkyrie-mcp-server/dist/index.js"],
      "env": {
        "NOTION_TOKEN": "your-token",
        "DASHBOARD_DB_ID": "your-dashboard-id",
        "LOGISTICS_DB_ID": "your-logistics-id"
      }
    }
  }
}

Files of interest

src/index.ts — MCP server entry point and tool orchestration
src/lib/assets.ts — Relational Asset Resolver implementation
src/tools/analyze-threats.ts — Threat detection and incident staging
mock-api/valkyrie_mock_api.py — FastAPI threat simulator
scripts/seed_assets.py — Populate Notion databases with sample assets
scripts/scan_and_stage.js — Batch scan + incident staging
scripts/trigger_and_stage.js — Single-target trigger + staging
scripts/scheduler.js — Periodic scan runner
scripts/notion_watcher.js — Notion status change listener
scripts/notify.js — Slack and email notifications
scripts/webhook_server.js — Action link handler for approvals

Notes

The system is intentionally conservative: AI stages incidents as Awaiting Approval for human review.
The repo includes seeding and demo scripts to make the submission easy to reproduce.

Acknowledgments

Notion for the MCP SDK and API
Model Context Protocol for the integration framework
DEV Community for the challenge platform

Built for the Notion MCP Challenge 2026 🚀