Forem: Darlington Mbawike

Just shipped my project for the DEV Weekend Challenge — and I’d love your feedback!

Darlington Mbawike — Sun, 19 Apr 2026 19:35:15 +0000

🚨 I built something that might actually fix how we recycle…

🌍 DecoScan — AI Environmental Intelligence

Scan it. Understand it. Dispose it RIGHT.

Most people don’t recycle wrong on purpose…
They just don’t know what’s actually recyclable.

And that “guessing”?
It’s quietly breaking the entire recycling system.

So I built DecoScan.

🔥 What it does

Point your camera at any item…
And instantly get:

⚡ Material detection (plastic, glass, metal, etc.)
🧠 AI-powered explanation (not just labels)
🎯 EXACT disposal instructions
🧬 Personalized eco coaching (it learns your habits)
🎮 EcoScore + achievements to keep you hooked

🤯 The twist

It works even when you're offline.

Yep — no internet, no problem.

Behind the scenes:

On-device AI (TensorFlow Lite + CameraX)
Gemini AI for deep reasoning
A custom system that FIXES common AI mistakes (like “everything is plastic”)

So it’s not just fast… it’s actually accurate.

💡 Why this matters

Recycling isn’t broken because people don’t care.
It’s broken because people don’t have clarity.

DecoScan turns:
❌ Guesswork → ✅ Intelligence
❌ Confusion → ✅ Action
❌ Intent → ✅ Impact

🎥 Demo: [https://youtube.com/@darlingtonmbawike-b9s?si=jBlJ1KjngXdJm8zd ]
💻 Code: [ https://github.com/darchumsone-collab/DecoScan ]

If this idea clicks with you, I’d love:
🔥 your honest feedback
🔥 what you’d improve
🔥 or even wild ideas to push this further

Let’s build tech that actually matters 🌱

🌍 DecoScan: AI Environmental Intelligence

Darlington Mbawike — Sun, 19 Apr 2026 13:20:38 +0000

*This is a submission for [Weekend Challenge:]

🌍 DecoScan: AI Environmental Intelligence

Scan Smart. Dispose Right. Empowered by Gemini AI.

💡 The Problem

In the global fight against waste, the biggest hurdle isn't the will to recycle—it’s uncertainty. Users struggle to know if an item is truly recyclable, often defaulting to "wish-cycling" which contaminates waste streams. Existing solutions are either too slow, require constant internet, or provide generic, non-actionable advice.

🚀 Our Solution: DecoScan

DecoScan is a production-grade, offline-first environmental intelligence system. It doesn’t just label waste; it understands the context. By merging high-speed on-device ML with the reasoning power of Google Gemini, DecoScan provides an instant, personalized sustainability roadmap for every item you hold.

✨ Key "Wow" Features

1. 🧠 Smart Eco Coach (Gemini AI Driven)

Our 3-Stage Intelligence Pipeline uses Gemini 1.5 Flash to perform a real-time environmental audit:

Analysis: Multi-object material detection (Plastic, Glass, Metal, Wood, Fabric, Ceramic, Stone, Paper).
Correction: A safety layer that uses AI reasoning to fix common classification biases (e.g., distinguishing metallic polymers from pure metals).
Personalized Coaching: Actionable advice based on the user's specific Eco Level, EcoScore, and Behavioral History.

2. 🧬 Contextual Memory System

DecoScan learns from you. Using a lightweight behavioral engine built on Jetpack DataStore, the app tracks your last 10 scans to identify patterns. If the system notices you excel at recycling glass but struggle with plastic, the Smart Eco Coach adapts its tips to encourage improvement in your weak areas.

3. 🛡️ Mission-Critical "Offline First"

Core functionality never fails. Using CameraX and a custom-optimized TensorFlow Lite model, the app identifies materials instantly without a signal. We even engineered an Advanced HSV Heuristics Engine that analyzes physical light properties to ensure 100% accuracy even when the cloud is out of reach.

4. 🎮 Gamified Impact Tracking

We turned sustainability into a mission:

EcoScore: A dynamic scoring system that rewards difficult material sorting.
CO2 Impact Helper: Translates abstract grams into real-world wins (e.g., "You've saved enough CO2 to power a LED bulb for 5 hours").
Eco Achievements: A sleek badge collection system (🌱 First Step, 🌊 Ocean Friend, 🌲 Nature Lover) that rewards consistent habits.

🛠️ The Tech Stack

UI: 100% Jetpack Compose (Material 3) with premium micro-interactions and animated state transitions.
AI/ML: Google Gemini Pro (LLM Reasoning), TensorFlow Lite (On-device Vision).
Vision Verification: Custom HSV Heuristics Engine for classification bias correction.
Persistence: Jetpack DataStore for Behavioral Memory, Last-Known Insights, and Secure Auth.
Architecture: Clean Architecture + MVVM (Strict separation of Data, Domain, and Presentation).
Networking: OkHttp with resilient 2-second timeout and JSON-parsing failsafes.

🏗️ Technical Challenges & Solutions

The "Everything is Plastic" Bug: Neural networks often over-classify objects as plastic in low light. I solved this by building a Vision Verification Pipeline that cross-references ML results with physical color theory data (Hue, Saturation, Value) before finalizing the result.
Cloud Latency: To keep the app snappy, we implemented a Non-Blocking Enhancement Pattern. The result is shown instantly via local ML, while the Gemini Coach "thinks" in the background, updating the UI with "Live Intelligence" only when ready.

🏆 Final Impact

DecoScan transforms a mundane chore into an engaging, educational experience. It demonstrates that the future of AI isn't just in the cloud—it's in the seamless bridge between on-device reliability and cloud-based reasoning.

Build the Future. Scan Smart. Dispose Right.
DecoScan by Darchums AI
arth Day Edition](https://dev.to/challenges/weekend-2026-04-16)*

What I Built

Demo

https://youtube.com/shorts/ioq2UvH3dTo?si=XdQXXOC1u4Egfl46

Code

https://github.com/darchumsone-collab/DecoScan

How I Built It

I designed DecoScan using a hybrid AI architecture that combines fast on-device processing with cloud-based reasoning for deeper intelligence.

🔍 1. On-Device Vision System

To ensure speed and reliability, I implemented real-time material detection using:

TensorFlow Lite for lightweight, optimized inference
CameraX for seamless camera integration

This enables instant material classification, even without internet connectivity.

🧠 2. Vision Verification Pipeline (Key Innovation)

A major challenge was the tendency of models to over-classify objects as “plastic,” especially in low-light conditions.

To address this, I built a custom HSV Heuristics Engine:

Analyzes Hue, Saturation, and Value (HSV) from the camera feed
Cross-references ML predictions with physical color properties
Adjusts outputs to improve real-world accuracy

This acts as a second validation layer, significantly increasing prediction reliability.

🤖 3. Gemini-Powered Smart Eco Coach

For advanced reasoning and user guidance, I integrated Google Gemini (1.5 Flash).

Gemini is responsible for:

Interpreting detected materials in context
Generating clear, actionable recycling instructions
Delivering personalized coaching based on user behavior

To maintain a smooth UX, I implemented a non-blocking enhancement pattern:

Local ML results appear instantly
Gemini processes insights asynchronously
UI updates dynamically with refined intelligence

🧬 4. Contextual Memory System

To personalize the experience, I built a behavioral memory system using Jetpack DataStore:

Stores the user’s last 10 scans
Identifies recycling patterns and weak areas
Feeds behavioral context into Gemini for adaptive coaching

This transforms DecoScan into a learning system that evolves with the user.

🎮 5. Gamification Layer

To drive engagement and retention, I implemented:

EcoScore system based on recycling difficulty and accuracy
CO₂ impact estimation, translated into real-world equivalents
Achievement badges to reward consistency and progress

This encourages long-term behavioral change.

🏛️ 6. Architecture & UI

The application follows Clean Architecture with MVVM:

Clear separation between data, domain, and presentation layers
Improved scalability and maintainability

UI was built using:

Jetpack Compose (Material 3)
Smooth animations and micro-interactions for a premium feel

⚡ 7. Performance & Reliability

Offline-first design ensures core features always work
OkHttp networking layer with timeouts and fail-safes
Lightweight local storage for fast state persistence

🔚 Summary

By combining on-device ML, AI reasoning, and behavioral intelligence, I built a system that is fast, adaptive, and reliable in real-world conditions — not just in ideal environments.

Prize Categories

🏆 Prize Categories

🧠 Best Use of Google Gemini

DecoScan leverages Google Gemini (1.5 Flash) as the core reasoning engine behind its Smart Eco Coach.

Rather than using Gemini for simple text generation, it is deeply integrated into a 3-stage intelligence pipeline:

Interprets real-world material detection results
Corrects classification ambiguity using contextual reasoning
Generates personalized, actionable recycling guidance

Gemini operates within a non-blocking enhancement architecture, where:

On-device ML delivers instant results
Gemini refines insights asynchronously
The UI updates dynamically with “live intelligence”

Additionally, Gemini is enhanced with behavioral context (via Jetpack DataStore), allowing it to adapt recommendations based on the user’s recycling habits and history.

This transforms Gemini from a generic assistant into a personalized environmental intelligence engine.

💻 Best Use of GitHub Copilot (Optional, if applicable)

GitHub Copilot was used to accelerate development across:

Jetpack Compose UI components
MVVM architecture scaffolding
Networking and data handling layers

This enabled rapid prototyping while maintaining clean, production-level code quality.

🌍 Overall Impact

DecoScan showcases a powerful hybrid model where:

On-device AI ensures speed and reliability
Gemini provides deep reasoning and personalization

This creates a seamless, real-world AI experience that is fast, intelligent, and impactful.

Built solo by @darlington_mbawike_9a7a87

I Built a Personal AI Assistant with OpenClaw

Darlington Mbawike — Fri, 17 Apr 2026 17:41:37 +0000

I Built a Personal AI Assistant with OpenClaw — Architecture, Code, and What Actually Works

Introduction

Most conversations about personal AI focus on capability:

smarter models
better reasoning
human-like conversations

But after building a working system with OpenClaw, I realized something different:

Personal AI isn’t about sounding intelligent — it’s about being useful under real-life conditions.

This post walks through:

The architecture I built
Real code examples
What worked (and what failed)
Practical lessons for building your own

System Overview

I designed a minimal but extensible system with 4 core layers:

[ Input Layer ] → [ Processing Layer ] → [ Memory Layer ] → [ Action Layer ]

1. Input Layer

Handles messy, real-world input:

text notes
reminders
unstructured thoughts

2. Processing Layer

extracts intent
classifies tasks
assigns priority

3. Memory Layer

stores tasks
tracks history
enables context

4. Action Layer

reminders
summaries
nudges

⚙️ Core Implementation

🧩 1. Task Extraction Engine

The first challenge: turning messy input into structured tasks.

import re
from datetime import datetime

def extract_tasks(user_input):
    tasks = []

    patterns = [
        r"(buy|call|send|finish|complete)\s(.+)",
        r"remember to\s(.+)",
        r"don't forget to\s(.+)"
    ]

    for pattern in patterns:
        matches = re.findall(pattern, user_input.lower())
        for match in matches:
            task = " ".join(match) if isinstance(match, tuple) else match
            tasks.append({
                "task": task,
                "created_at": datetime.now(),
                "priority": "medium",
                "status": "pending"
            })

    return tasks

👉 This simple parser worked surprisingly well for real-life inputs.

🧠 2. Priority Scoring System

Instead of “AI magic,” I used a rule-based scoring system:

def prioritize_task(task):
    score = 0

    urgent_keywords = ["urgent", "asap", "now", "today"]
    social_keywords = ["call", "reply", "message"]

    for word in urgent_keywords:
        if word in task["task"]:
            score += 3

    for word in social_keywords:
        if word in task["task"]:
            score += 2

    # Time-based boost
    age = (datetime.now() - task["created_at"]).seconds / 3600
    if age > 24:
        score += 2

    if score >= 5:
        return "high"
    elif score >= 3:
        return "medium"
    return "low"

👉 Insight:
Simple heuristics outperformed complex logic for everyday use.

🗂️ 3. Memory Layer (Lightweight Storage)

I used a simple in-memory structure (can be replaced with DB):

class Memory:
    def __init__(self):
        self.tasks = []

    def add_tasks(self, new_tasks):
        for task in new_tasks:
            task["priority"] = prioritize_task(task)
            self.tasks.append(task)

    def get_pending(self):
        return [t for t in self.tasks if t["status"] == "pending"]

    def get_overdue(self):
        return [
            t for t in self.tasks 
            if (datetime.now() - t["created_at"]).seconds > 86400
        ]

🔔 4. Action Engine (Reminders & Nudges)

def generate_nudges(memory):
    nudges = []

    overdue = memory.get_overdue()

    for task in overdue:
        nudges.append(f"You’ve been postponing: {task['task']}")

    high_priority = [
        t for t in memory.get_pending() 
        if t["priority"] == "high"
    ]

    for task in high_priority:
        nudges.append(f"Important: {task['task']}")

    return nudges

🔄 5. Putting It Together

def run_agent(user_input, memory):
    tasks = extract_tasks(user_input)
    memory.add_tasks(tasks)

    nudges = generate_nudges(memory)

    return {
        "tasks_added": tasks,
        "nudges": nudges
    }

🧪 Example Interaction

Input:

"Don't forget to call John and finish the report today"

Output:

Tasks:
- call john (high priority)
- finish the report today (high priority)

Nudges:
- Important: call john
- Important: finish the report today

🔍 What Actually Worked

✅ 1. Simplicity scales better than complexity

The system became more reliable when I:

reduced dependencies
simplified logic
focused on core functionality

✅ 2. Messy input is the real challenge

Handling:

incomplete thoughts
vague reminders
inconsistent language

…was more valuable than improving model intelligence.

✅ 3. Prioritization is everything

Users don’t need more information.

They need:

clarity on what matters now

⚠️ What Didn’t Work

❌ Over-engineering the system

Adding:

too many integrations
advanced NLP pipelines
complex routing

…reduced usability.

❌ Fully autonomous behavior

The system worked best when:

it suggested
not decided

🚀 Extending This System with OpenClaw

Here’s where OpenClaw becomes powerful:

🔗 Skill-based extensions

Email parsing skill
Calendar integration
Voice note processing

🔄 Composability

Each module can become a reusable skill:

Task Parser → Priority Engine → Notification Skill

💡 Key Insight

After everything, one thing became clear:

The best personal AI is not the smartest system — it’s the most consistent one.

🏁 Final Thoughts

This wasn’t a massive AI system.

It didn’t:

write essays
simulate emotions
replace human thinking

But it did something more important:

It worked.

It handled real-life chaos:

forgotten tasks
delayed responses
mental overload

And that’s where personal AI becomes meaningful.

📌 If You’re Building with OpenClaw

Start here:

Capture messy input
Build simple logic
Add memory
Layer intelligence gradually

Don’t chase perfection.

Build something that helps — even a little.

Because in real life, that’s more than enough.

Your Next To-Do App Is Dead — I Replaced Mine with an OpenClaw AI

Darlington Mbawike — Fri, 17 Apr 2026 17:33:41 +0000