DEV Community: Temiloluwa Valentine

Every Time She Got Confused Online, She Called Me. I Got Tired of Answering. So I Built This.

Temiloluwa Valentine — Sun, 24 May 2026 06:57:39 +0000

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

My cousin has a learning disability.

Not the kind people notice immediately. She holds a conversation fine. She laughs at the right moments. She is sharp in ways that matter.

But put her in front of a dense webpage, a medical article, a GitHub README, a LinkedIn thread and something shifts. The words blur. The structure overwhelms. She closes the tab and calls me.

For two years, I was her human filter for the internet.

The Problem Nobody Talks About

The internet assumes you can:

Read fast
Parse dense structure
Context-switch without losing the thread
Understand jargon on sight

A lot of people cannot. And nobody is building for them.

My cousin is not alone. People with dyslexia, ADHD, processing disorders, low digital literacy, and non-native English speakers all hit the same wall every day. They just hit it quietly.

I got tired of being the workaround. So I built Aura.

What Aura Is

Aura is a Chrome extension that puts Gemma 4 directly on every webpage.

No tab switching. No copy-pasting into ChatGPT. No context lost.

You click the floating orb. A panel slides in. You pick what you need:

Summarize Page — get the key points in seconds
Explain Code — understand what it does and why
Draft Reply — reply to LinkedIn messages that match the tone of the conversation
Create Post — turn any article into LinkedIn post ideas
Highlight & Ask — select any text on the page and ask Aura anything about it

The AI lives on the page with you. You never leave.

The Demo

Why I Migrated from Llama to Gemma 4

I originally built Aura with Llama 3.1 8B via Cloudflare Workers AI.

It worked. Responses came back. Features ran.

But when I swapped to Gemma 4 31B, I felt the difference in the first response.

Llama told me what the code did. Gemma 4 told me why it was written that way.

Llama drafted a generic professional reply. Gemma 4 read the tone of the conversation and matched it.

For a general tool, that gap is a nice-to-have. For a tool built for people who struggle with comprehension that gap is everything.

Why Gemma 4 31B Specifically

Gemma 4 comes in three variants. I did not pick 31B by default. I picked it deliberately.

Model	Why I didn't pick it
2B / 4B	Too shallow for the reasoning depth Aura needs across wildly different content types
26B MoE	Great for edge inference but Aura needs consistent quality across all content types, not specialized routing
31B Dense	✅ Full parameter activation. Maximum reasoning quality. Consistent across every content type.

Here is why dense architecture matters for Aura specifically:

MoE models route tokens through specialized subnetworks they activate only some parameters depending on the input. That is efficient. But Aura handles a GitHub README, a LinkedIn thread, a medical article, and a Stack Overflow answer sometimes in the same session.

Dense models activate all parameters for every token. Gemma 4 31B does not guess which expert to wake up. It brings everything it knows to every single interaction.

For a tool where the content changes every tab and the user cannot afford an inconsistent experience that consistency is not optional.

The Technical Implementation

Aura is plain HTML, CSS, and JavaScript. No framework. No backend. No server.

The Gemma 4 API call lives directly in the content script:

const GEMMA_API_URL = 'https://generativelanguage.googleapis.com/v1beta/models/gemma-4-31b-it:generateContent';

async function callNova(prompt) {
  const systemTurn = {
    role: 'user',
    parts: [{ text: `You are Aura, a helpful AI assistant in a browser extension. 
    The user is on: ${window.location.href}. 
    Page context:\n\n${currentPageContent}\n\n
    Respond concisely and directly. Never introduce yourself. 
    Never mention you are an AI. Output only the final answer.` }]
  };

  const systemAck = {
    role: 'model',
    parts: [{ text: 'Understood.' }]
  };

  const response = await fetch(`${GEMMA_API_URL}?key=${GEMMA_API_KEY}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      contents: [systemTurn, systemAck, ...history, ...messages],
      generationConfig: { temperature: 0.7 },
      thinkingConfig: { thinkingBudget: 0 }
    }),
  });

  const data = await response.json();
  return data.candidates?.[0]?.content?.parts?.[0]?.text || 'No response.';
}

A few things worth noting:

The system turn pattern — Gemma 4's API does not have a native system role. I simulate it by injecting a user turn with the system context, followed by a model acknowledgment. This grounds the model before the actual conversation starts.

thinkingBudget: 0 — Gemma 4 31B is a reasoning model. Left unconstrained, it outputs its full reasoning trace — tasks, constraints, drafts, self-checks — before the final answer. Setting thinkingBudget: 0 suppresses that and returns only the final output to the user.

Page content extraction — Aura reads the page using a priority selector chain before falling back to document.body.innerText, capped at 4000 characters to stay within context limits.

Conversation history — Follow-up chat is supported. Every user and model turn is stored in conversationHistory and injected into the next request, giving Aura memory within a session.

What Changed When I Migrated

Feature	Llama 3.1 8B	Gemma 4 31B
Page summarization	✅ Decent bullets	✅ Structured, context-aware
Code explanation	✅ Describes what code does	✅ Explains why it was written that way
Reply drafting	⚠️ Generic professional tone	✅ Matches the tone of the actual conversation
LinkedIn post creation	⚠️ Template-like output	✅ Distinct voice per post
Highlight & Ask	✅ Works	✅ Deeper reasoning on complex selections

The migration took under 10 minutes. One endpoint. One model string. The quality difference was not subtle.

Who This Is Actually For

People with dyslexia who need content restructured instantly
People with ADHD who lose the thread switching tabs
Non-native English speakers navigating professional content
Elderly users overwhelmed by dense web pages
Anyone the internet was not designed for

My cousin does not need a faster browser. She needs the information to come to her in a form she can hold.

Aura does that. Gemma 4 31B makes it good enough to actually help.

What Is Next

The next version adds multimodal support sending a page screenshot alongside the text so Gemma 4 can reason about charts, diagrams, and images, not just words.

My cousin once sent me a screenshot of a medical form she could not understand. I read it to her over the phone.

Aura will eventually do that too.

Links

🔗 GitHub: https://github.com/Valentinetemi/Aura

Aura was originally built for the Airia AI Agents Hackathon. The Gemma 4 migration was done for this challenge and honestly, it should have been Gemma from the start.

My Dad Got an Electricity Bill He Couldn't Understand. Google I/O 2026 Just Made That Problem Solvable.

Temiloluwa Valentine — Sat, 23 May 2026 17:06:12 +0000

This is a submission for the Google I/O Writing Challenge

The Moment That Started Everything

Last year my dad got our electricity bill and just stared at it.

He couldn't understand why it was so high. He had no idea which device was the problem. Was it the iron my mum uses every morning? The old fridge that runs all night? The TV nobody turns off?

He just paid it. Like he always does. Because there was no easy way to find out.

That moment stayed with me. So I built something about it, an app where you point your camera at any appliance, pinch your fingers, and instantly see what that device costs you per month in your local currency, what it does to your CO₂ footprint, and one simple habit to cut the cost immediately.

The heart of it was Gemini's vision capability. You point. Gemini looks. Gemini understands. No typing. No forms. Just a camera and a pinch gesture.

It worked. But building it taught me exactly where the limits were.

And then Google I/O 2026 happened.

What I Was Actually Asking Gemini to Do

When you point a camera at an appliance, you are not giving Gemini a clean, labelled image. You are giving it a live camera frame, often at an angle, often in bad lighting, often partially obscured by a cable or a counter.

Gemini 2.0 Flash handled it remarkably well. It could identify an iron, a refrigerator, a standing fan, a microwave, even when the image was not perfect. It returned structured data: what the device is, how many watts it typically consumes, and what that costs per month in Nigeria, Ghana, or Kenya.

But there were moments where it hesitated. Older appliances with no visible branding. Devices that looked similar from certain angles. Situations where the model was confident but slightly wrong, calling a dehumidifier an air purifier, for instance, which changes the wattage estimate significantly.

Those were not failures. They were the edges of what vision AI could do at the time.

What Gemini 3.5 Flash Changes

Gemini 3.5 Flash improves both multimodal reasoning and response speed, which matters enormously for real-time camera experiences.

For a real-time camera application, that speed difference is not a convenience. it is the difference between an experience that feels instant and one that makes the user wait.

But the multimodal improvement matters more than the speed. Gemini 3.5 Flash is better at understanding what it is actually looking at in complex, real-world visual contexts. Not studio images. Not clean product photos. Real environments with bad lighting, odd angles, and ambiguous objects.

That is exactly the problem I was trying to solve.

An old Nigerian refrigerator from the 1990s does not look like the refrigerators in most training datasets. A locally assembled electric cooker does not have a recognizable brand logo. The visual diversity of household appliances across Africa, India, Ghana, and Kenya is enormous, and the gap between what a model trained on Western product images knows and what actually exists in these homes is real.

Gemini 3.5 Flash's improved multimodal understanding closes that gap. Not completely. But meaningfully.

What Gemini Omni Opens Up

Gemini Omni is a new series of models that combines Gemini's reasoning capabilities with creation, accepting image, audio, video, and text input and outputting video grounded in real-world knowledge.

This one stopped me.

Imagine pointing your camera at your kitchen and instead of scanning one appliance at a time, the model watches a short video of your kitchen, identifies every device it sees, and generates a complete energy audit, total monthly cost, total CO₂ footprint, priority recommendations, all in one pass.

That is not a feature I could have built before. That is a feature I could build now.

The pinch-to-scan interaction I built works well for focused, one-device-at-a-time scanning. But the real problem my dad had was not "tell me about this one device." It was "Tell me why this whole bill is so high." Video input that generates grounded output is the architecture that answers the actual question.

The Announcement That Surprised Me Most

Google announced Antigravity 2.0 with new capabilities to orchestrate and build agents, transitioning from AI that simply assists to agents that can independently navigate complex tasks.

When I built my energy scanning app, every interaction was stateless. You scan a device, you get a result. If you scan another device, you get another result. The dashboard accumulated data, but the model had no memory of what it had already seen.

An agent that can remember that knows you scanned the fridge last week, that it already recommended you switch to a more efficient model, that it is now tracking whether your bill actually went down, that is a fundamentally different product.

That is not a scanning tool. That is an energy advisor that lives on your phone and actually follows up.

What This Means For Developers Building in Africa

I want to say something that the Google I/O coverage mostly missed.

Gemini 3.5 Flash delivers frontier-level capabilities at less than half the price of comparable frontier models.

For developers building in Nigeria, Ghana, Kenya, India, where margins are thin, where users cannot pay Western subscription prices, where the business model has to work at a completely different cost structure, that pricing difference is not a footnote. It is the difference between a viable product and one that cannot sustain itself.

Most of the Google I/O coverage talked about what these models can do. The more important story for developers outside Silicon Valley is what these models now cost to run. Frontier vision capability at accessible pricing means the gap between what developers in Lagos can build and what developers in San Francisco can build just got smaller.

That is the announcement I cared about most.

What I Am Building Next

My dad still checks his electricity bill every month and wonders where the money went.

With Gemini 3.5 Flash's improved multimodal understanding, Gemini Omni's video input, and Antigravity 2.0's agentic memory. I have everything I need to build the version of this tool that completely solves his problem.

Do not scan one appliance at a time. Walk through the house. Let the agent watch. Get the full picture. Follow up next month.

Google I/O 2026 did not just announce new models. For developers who are building real tools for real people in the places the tech industry usually forgets, it has moved the frontier to where we actually are.

The appliance scanning app referenced in this post was built independently for the DEV Earth Day Weekend Challenge. All Google I/O 2026 details are from official Google announcements.

My Dad Got an Electricity Bill He Couldn't Understand. Google I/O 2026 Just Made That Problem Solvable.

Temiloluwa Valentine — Sat, 23 May 2026 17:06:12 +0000

This is a submission for the Google I/O Writing Challenge

The Moment That Started Everything

Last year my dad got our electricity bill and just stared at it.

He couldn't understand why it was so high. He had no idea which device was the problem. Was it the iron my mum uses every morning? The old fridge that runs all night? The TV nobody turns off?

He just paid it. Like he always does. Because there was no easy way to find out.

The heart of it was Gemini's vision capability. You point. Gemini looks. Gemini understands. No typing. No forms. Just a camera and a pinch gesture.

It worked. But building it taught me exactly where the limits were.

And then Google I/O 2026 happened.

What I Was Actually Asking Gemini to Do

Those were not failures. They were the edges of what vision AI could do at the time.

What Gemini 3.5 Flash Changes

Gemini 3.5 Flash improves both multimodal reasoning and response speed, which matters enormously for real-time camera experiences. DEV Community

For a real-time camera application, that speed difference is not a convenience. it is the difference between an experience that feels instant and one that makes the user wait.

That is exactly the problem I was trying to solve.

An old Nigerian refrigerator from the 1990s does not look like the refrigerators in most training datasets. A locally assembled electric cooker does not have a recognisable brand logo. The visual diversity of household appliances across Africa, India, Ghana, and Kenya is enormous and the gap between what a model trained on Western product images knows and what actually exists in these homes is real.

Gemini 3.5 Flash's improved multimodal understanding closes that gap. Not completely. But meaningfully.

What Gemini Omni Opens Up

Gemini Omni is a new series of models that combines Gemini's reasoning capabilities with creation, accepting image, audio, video, and text input and outputting video grounded in real-world knowledge. DEV Community

This one stopped me.

That is not a feature I could have built before. That is a feature I could build now.

The Announcement That Surprised Me Most

Google announced Antigravity 2.0 with new capabilities to orchestrate and build agents, transitioning from AI that simply assists to agents that can independently navigate complex tasks.

That is not a scanning tool. That is an energy advisor that lives on your phone and actually follows up.

What This Means For Developers Building in Africa

I want to say something that the Google I/O coverage mostly missed.

Gemini 3.5 Flash delivers frontier-level capabilities at less than half the price of comparable frontier models. LinkedIn

That is the announcement I cared about most.

What I Am Building Next

My dad still checks his electricity bill every month and wonders where the money went.

Do not scan one appliance at a time. Walk through the house. Let the agent watch. Get the full picture. Follow up next month.

The appliance scanning app referenced in this post was built independently for the DEV Earth Day Weekend Challenge. All Google I/O 2026 details are from official Google announcements.

Which Gemma 4 Model Should You Actually Use? I Tested All of Them, So You Don't Have To

Temiloluwa Valentine — Tue, 19 May 2026 22:58:50 +0000

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

Which Gemma 4 Model Should You Actually Use? I Tested All of them, building a Healthcare AI for African Patients

Most model comparison posts are written by people who read the documentation. This one is written by someone who burned through tokens, hit OOM errors, watched Gemini miss clinical signals it should have caught, and eventually landed on the right answer, but only after eliminating everything else first.

I was building Fisibel, a multimodal African synthetic health data platform. The task: upload a real Nigerian hospital record image, extract clinical signals, and generate privacy-safe synthetic datasets grounded in WHO and World Bank statistics. The model had to read handwritten and printed medical documents, understand African-specific clinical patterns, and generate coherent synthetic data at scale.

Here is what I learned by testing every Gemma 4 option available.

Model	Parameters	Architecture	Best For
Gemma 4 E2B	2B effective	Dense	On-device, mobile, offline
Gemma 4 26B MoE	26B total, 4B active	Mixture-of-Experts	Edge inference, deep reasoning
Gemma 4 31B	31B total	Dense	Maximum quality, unconstrained compute

The architectural difference matters more than the number. Let me explain why.

What Mixture-of-Experts Actually Means in Practice
Most explanations of MoE are theoretical. Here is the practical version.
A dense model activates all its parameters for every token it processes. A 31B dense model is doing 31B parameters of work on every single token — whether that token is "the" or "malaria strain variant specific to Lagos State."
A MoE model routes each token through specialized subnetworks called experts. Only a subset activates per token. Gemma 4 26B MoE has 26B total parameters but activates only ~4B per forward pass.
What this means for you:

Inference speed: closer to a 4B model
Knowledge depth: closer to a 26B model
For specialized tasks: the right experts activate for the right content

That last point is the one that changed my project. When processing clinical documents, MoE routes medical terminology, geographic identifiers, and symptom patterns through subnetworks shaped by that kind of content. A dense model processes a Nigerian hospital record exactly the same way it processes a recipe.

Why I Started With Ollama and Had to Stop
The original Fisibel architecture was local inference via Ollama. If the platform handles real hospital record images, keeping inference local meant zero data leaving the machine. Maximum privacy. No transmission risk.
It did not survive contact with reality.
Downloading Gemma 4 locally through Ollama required pulling a model that was simply too large. In Nigeria, where data costs real money, the download cost alone made the pipeline economically unviable. African healthcare researchers operating in bandwidth-constrained environments cannot build on infrastructure that demands gigabytes just to get started.
Lesson: Local inference is the right privacy instinct. But in bandwidth-constrained environments, the data cost of the initial model download is a real barrier, not an abstract one. If you are building for users outside fibre-connected cities, factor this in before you architect around Ollama.
This pushed the pipeline to Google Cloud — not by preference, but by the economic reality of what local inference actually costs when you are not building from San Francisco.

Why I Rejected Gemma 4 31B
Once on cloud inference, the natural assumption was that bigger meant better. Gemma 4 31B was tested first.
It was not better. It was more expensive for the same output.
For clinical signal extraction specifically — reading a hospital record and pulling out diagnoses, symptoms, treatment patterns, geographic identifiers — the 31B model burned tokens significantly faster without producing meaningfully deeper clinical signals than 26B MoE.
The task does not reward raw parameter count. It rewards specialized reasoning over structured medical text. Paying more tokens for marginal returns on a pipeline that needs to run at scale across African health datasets is not a tradeoff worth making.
When to use 31B: Maximum quality tasks where compute cost is not a constraint. Long-form generation. Complex reasoning chains where you need every parameter engaged. Research environments, not production pipelines running at scale.
When not to use 31B: Specialized extraction tasks. Scale-sensitive pipelines. Anything where you will run the model hundreds or thousands of times.

Why I Tested Gemini and What the Results Actually Showed
Gemini was the obvious alternative. Same multimodal capability, faster inference, Google infrastructure. I tested it directly against Gemma 4 26B MoE on the same Lagos hospital record image.
Gemini was faster. On clinical depth, it lost.
The table below shows clinical signals extracted from the same input document across both models:

Clinical Signal Extracted	Gemma 4 26B MoE	Gemini
Primary diagnosis	✅	✅
Comorbidity pattern	✅	✅
Malaria strain variant	✅	❌
LGA-specific risk factor	✅	❌
Regional treatment protocol	✅	❌
Symptom progression timeline	✅	✅
Geographic disease indicator	✅	❌
Age-adjusted risk signal	✅	✅
Local drug resistance pattern	✅	❌
Nutritional comorbidity flag	✅	❌

Gemini caught the general signals. Gemma 4 26B MoE caught the African-specific ones.
No other model in this size class caught all 6 African-specific signals.
This is not a criticism of Gemini. It is a demonstration of what MoE routing does on specialized content. The signals Gemini missed are not obscure — LGA-specific risk factors and regional treatment protocols are standard clinical identifiers in Nigerian medical documents. The difference is in how each model processes domain-specific terminology.
Speed is not always the metric. For specialized extraction tasks, coverage is.
| Use Case | Recommended Model |
| Mobile / on-device / offline | Gemma 4 E2B |
| Specialized domain extraction at scale | Gemma 4 26B MoE |
| Maximum quality, unconstrained compute | Gemma 4 31B |
| Bandwidth-constrained environments | Gemma 4 26B MoE via cloud |
| Research and fine-tuning experiments | Gemma 4 31B |
| Production pipelines with token cost sensitivity | Gemma 4 26B MoE |

Choose Gemma 4 E2B if:

You are building for mobile or on-device
Your users have bandwidth or storage constraints
You need offline capability after the first setup
Your task is classification, routing, or simple generation
You are targeting Android phones under $200

Choose Gemma 4 26B MoE if:

You need reasoning depth at edge-level inference speed
Your task involves specialized domain content — medical, legal, scientific, and regional
You are running at scale, and token cost matters
You need the best quality-to-cost ratio in production
You want MoE expert routing to work in your favour on specialized inputs

Choose Gemma 4 31B if:

Compute cost is not a constraint
You need maximum quality on complex generation tasks
You are doing research, fine-tuning experiments, or one-off analysis
Latency is less important than output quality

The One Thing Nobody Tells You About Thinking Mode
Gemma 4 supports thinking traces. I assumed more thinking meant better answers everywhere. That assumption broke two features before I understood what was actually happening.
Thinking mode helps when the model needs to route across multiple options — tool selection, complex reasoning, and ambiguous queries. It hurts when the task is pure structured output composition. With thinking enabled on a structured generation path, the model spends its entire token budget on internal reasoning traces and produces empty or malformed output.
The rule I now follow: thinking ON for routing, thinking OFF for composition. They are different tasks and the model treats them differently.

What This Means for Open Source AI
Gemma 4 26B MoE running on Google Cloud infrastructure, with no proprietary lock-in, matching or exceeding closed models on specialized domain tasks — that is not a minor footnote. That is the story.
For developers building in bandwidth-constrained environments, for researchers working on underrepresented populations, for anyone who needs frontier-level reasoning without frontier-level costs, the gap between open and closed models just got significantly smaller.
The model I needed to see African clinical signals clearly was not the biggest one. It was not the fastest one. It was the one built to route specialized knowledge to the right place.
That turns out to matter more than size.

I built this while developing Fisibel, a multimodal African synthetic health data platform. The clinical signals table above came from real tests on a Lagos hospital record. All findings are from production pipeline decisions, not benchmarks run for this post.

# ⚡ EcoScan— See Which Device is Drinking Your Money

Temiloluwa Valentine — Sun, 19 Apr 2026 17:42:27 +0000

_This is a submission for Weekend Challenge: Earth Day Edition

What I Built

Last month, my dad got our electricity bill and just stared at it.

He couldn't understand why it was so high. Was it the iron my mum uses every morning? The old fridge that runs all night? The TV nobody ever turns off? He had no idea. So he just paid it. Like he always does.

That moment stayed with me.

Millions of families across Nigeria, India, Ghana, Kenya and across the entire world pay electricity bills they don't understand. Not because they're careless. But because nobody ever made it simple enough to see where the money is actually going.

So I built EcoScan for Earth Day.

EcoScan is an AI-powered energy auditor that works with just a gesture.

Point your camera at any electrical appliance in your home, your iron, your fridge, your phone charger, your TV. Pinch your thumb and index finger together. In seconds, you see exactly what that device costs you per month in your local currency, how much CO₂ it produces, and what you can do about it.

No typing. No forms. No complicated settings. Just point and pinch.

Demo

In the demo you can see:

Real-time hand tracking detecting the pinch gesture
Gemini identifying a clothing iron, phone charger and smartphone
The live dashboard updating instantly with monthly costs in local currency
CO₂ impact, efficiency scores and energy-saving tips for each device

Code

Valentinetemi / EcoScan

⚡ EcoScan— See Which Device is Drinking Your Money

Point your camera at any appliance. Pinch your fingers. Know instantly what it costs you and the planet.

🌍 The Story Behind This

Last month, my dad got our electricity bill and just stared at it.

He couldn't understand why it was so high. He had no idea which device was the problem. Was it the iron my mum uses every morning? The old fridge that runs all night? The TV nobody turns off?

He just paid it. Like he always does. Because there was no easy way to find out.

That moment stayed with me.

Millions of families across Nigeria, India, Ghana, Kenya, across the entire world pay electricity bills they don't understand. Not because they're careless. But because nobody ever made it simple enough to see where the money is actually going.

So I built EcoScan for Earth Day.

…

View on GitHub

How I Built It

The Gesture Engine — MediaPipe in the Browser

The pinch detection runs entirely in the browser using MediaPipe HandLandmarker via WebAssembly. No backend needed for hand tracking.

Every frame, it calculates the Euclidean distance between Landmark 4 (thumb tip) and Landmark 8 (index finger tip). When the distance drops below 0.055 in normalized space, that's a pinch. It triggers once, captures the frame, and sends it to Gemini.

const dx = points[4].x - points[8].x;
const dy = points[4].y - points[8].y;
const dz = points[4].z - points[8].z;
const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
const pinching = dist < 0.055;

A cooldown ref prevents double-triggering during the async Gemini call.

The AI Brain - Gemini 2.0 Flash Latest

When a pinch is detected, the current video frame is captured as a base64 JPEG and sent to a Next.js API route, which calls Gemini 2.0 Flash Latest.

The prompt instructs Gemini to return structured JSON:

{
  "appliance": "Electric Iron",
  "category": "laundry",
  "wattageMin": 1000,
  "wattageMax": 2400,
  "dailyHours": 2,
  "efficiencyScore": 4,
  "co2PerYear": 47,
  "costPerYear": 12,
  "habitChange": "Iron clothes in batches instead of one item at a time",
  "alternative": "Steam generator iron with auto shut-off",
  "funFact": "An iron left on for 1 hour uses the same energy as charging your phone 50 times"
}

The API key never touches the browser, all Gemini calls go through Next.js API routes server-side.

Local Electricity Pricing - 20 Countries

The biggest insight: annual cost numbers mean nothing to most people. Monthly cost does.

EcoScan supports 20 countries with real electricity rates, from Nigeria to Germany. Users select their country from a dropdown and all costs recalculate instantly in their local currency.

The Live Dashboard

As devices are scanned, a live dashboard builds up using Recharts wattage by device, CO₂ impact, monthly cost, eco grade, trees needed to offset, and equivalent flights per year. Everything is stored in localStorage so it persists between sessions.

Tech Stack

Technology	Purpose
Next.js 14	Framework + server-side API routes
Google Gemini 2.0 Flash Latest	Vision AI — appliance identification
MediaPipe HandLandmarker	Pinch gesture detection (WebAssembly)
Framer Motion	Animations
Recharts	Live dashboard charts

Prize Categories

Best use of Google Gemini

Gemini 2.0 Flash Latest is the entire brain of EcoScan. Without it, the app is just a camera. With it, a single pinch gesture turns any appliance into a complete energy audit wattage, CO₂, cost, efficiency score, habit tips and eco alternatives, all adapted to the user's country and local electricity rate.

The prompt is carefully engineered to always return clean structured JSON so the UI can render results instantly. Gemini makes something that would normally require a database of thousands of appliances work with zero setup, it just knows.

My dad still doesn't know which appliance was draining our electricity bill.
Now he can find out in seconds.
That's why I built EcoScan. 🌍

By @temiloluwavalentine_

Predict House Prices with Python: A Beginner’s Machine Learning Guide

Temiloluwa Valentine — Wed, 04 Mar 2026 01:34:30 +0000

In the last article, “Getting Started with AI,” we covered the fundamentals—what machine learning is, the types of problems it solves, and the tools you need.

Theory is important. But it only matters when you build something real.

So let’s build.

In this article, you’ll learn how to predict house prices using machine learning.

Not a toy example. A real regression problem that real estate companies, investors, and data scientists solve every day.

You’ll understand:

How to structure data for a model
How to train a machine learning system
How to test if it actually works
How to make predictions on new data

By the end, you’ll have built your first machine learning model. And more importantly, you’ll understand the process, because this same process works for predicting stock prices, weather, customer churn, or anything else.

Let’s go.

Step 1: Get Your Data

Machine learning starts with data. You need examples to learn from.

For this project, we’re using the Housing Prices dataset from Kaggle, which is a free dataset with real house data: size, number of bedrooms, bathrooms, parking, e.t.c and most importantly, the price.

This is your training material. The model will learn the relationship between house features (size, bedrooms) and price.

How to get the data:

Go to Kaggle

Search “Housing Prices Dataset” or just click this link (https://www.kaggle.com/datasets/yasserh/housing-prices-dataset)
Download the CSV file
Upload to Google Colab

Load the data:

import pandas as pd

Load the dataset

df = pd.read_csv(f"{path}/Housing.csv ")
print(df)

Look at the first few rows

print(df.head())

You now have your data loaded. Next step: prepare it for the model.

Step 2: Prepare Your Data

Raw data isn’t ready for machine learning. You need to organize it.

Your dataset has features (inputs) and a target (output). Features are what you know: size, bedrooms, bathrooms, e.t.c. Target is what you want to predict: price.

The model learns the relationship between features and target. So you need to separate them.

Separate features and target:

Target (what we want to predict)

y = df['price']

Features (drop price column)

X = df.drop('price', axis=1)

Convert yes/no columns to 1/0
This is to convert the text to numbers because machine learning only understands numbers, not text, so we convert the "yes" to 1 and the "no" to 0.

binary_columns = [
‘mainroad’, ‘guestroom’, ‘basement’,
‘hotwaterheating’, ‘airconditioning’, ‘prefarea’
]
for col in binary_columns:
X[col] = X[col].map({'yes': 1, 'no': 0})
We will handle furnishingstatus because some are furnished, semi-furnished, and unfurnished

X = pd.get_dummies(X, columns=[‘furnishingstatus’], drop_first=True)

Split into training and testing:

Here’s the critical part: you can’t test on the same data you trained on. The model will memorize the answers instead of learning.

So split your data:

80% for training (the model learns)
20% for testing (we check if it actually works)

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
What random_state means:
Scikit-learn randomly selects:
80% of the data for training

20% for testing

If you don’t set random_state, the split will be different every time you run the code.

That means:

Your training data changes

Your test data changes

Your accuracy changes

That’s not good for debugging or comparing models.

Why this matters:

Training data teaches the model. Test data proves it works on new data it’s never seen.

Without this split, you’ll think your model is perfect. But it will fail when it meets real, unseen data.

Now your data is ready. Time to train.

Step 3: Train the Model

Now comes the magic. You’re going to teach a machine to predict house prices.

Create the model:

from sklearn.linear_model import LinearRegression
model = LinearRegression()
That’s it. You’ve created an empty machine learning model. It knows nothing yet.

Train it:

Train on your data

model.fit(X_train, y_train)
This is where learning happens. The model analyzes your training data to identify the mathematical relationship between features (size, bedrooms, e.t.c) and price.

It’s asking, "What pattern connects these house features to their prices?”

What’s happening behind the scenes:

The model is drawing a line (or curve) through your data. It’s trying to find the best line that fits all the houses, where features predict price most accurately.

This process is called “fitting” or “training.”

In a few seconds, your model learned from hundreds of house examples. That’s machine learning.

Step 4: Test the Model

Your model is trained. But does it work?

Time to test it on data it’s never seen before.

Make predictions:

Predict on test data

predictions = model.predict(X_test)
print(predictions[:5])
The model now looks at houses in the test set and predicts their prices. It’s guessing based on what it learned.

Comparison
We compare the actual price with the predicted price

comparison = pd.DataFrame({
“Actual Price”: y_test.values[:5],
“Predicted Price”: predictions[:5]
})
print(comparison)
Check how accurate it is:

from sklearn.metrics import mean_squared_error, r2_score

Calculate error

print("R²:", r2_score(y_test, predictions))
print("MAE:", mean_absolute_error(y_test, predictions))

After training and testing our linear regression model, we can see how well it predicts house prices:

R² Score: 0.65

Mean Absolute Error (MAE): ₦970,000

What this means:

R² Score (0–1): Measures how much of the variation in house prices the model can explain.

0.65 means our model explains about 65% of the differences in house prices.

The closer to 1, the better the model is at capturing patterns.

Mean Absolute Error (MAE): Shows the average amount our predictions are off.

₦970,000 means, on average, the predicted price is roughly ₦970k higher or lower than the actual price.

Lower is better, but for a first beginner model, this is acceptable.

Even though the model isn’t perfect, it successfully learns patterns from the data. This is exactly what beginners need to understand: how to go from raw data to predictions using machine learning.

With this foundation, you can now experiment with more features, larger datasets, or advanced models in the future.

Conclusion: You’re Now a Machine Learning Engineer

You just built a real machine learning system.

Not in theory. In practice. With code. With data. With real predictions.

What you learned:

Data is everything—garbage in, garbage out
Splitting data prevents lying to yourself
Training finds patterns automatically
Testing proves it actually works
Predictions are just applying what you learned

Why this matters:

This exact process solves real problems:

Predicting stock prices
Detecting diseases in medical images
Recommending products
Forecasting demand
Detecting fraud

Every machine learning project follows this same pipeline. Master it, and you can build anything.

What’s next:

Now that you understand the process, you can:

Try different algorithms (Random Forest, SVM, Neural Networks)
Use bigger datasets
Add more features
Build on real problems in your own life

The tools are free. The knowledge is available. The only limit is how much you’re willing to build.

Keep building.

Use this process on a problem you care about.

That’s where real learning happens.

Temiloluwa Valentine

AI #MachineLearning #BuildingInPublic

Getting Started with AI: A Practical Guide for Everyone

Temiloluwa Valentine — Fri, 27 Feb 2026 12:58:25 +0000

You've heard the word AI everywhere. ChatGPT, image generators, and recommendation systems on Netflix.

But here's what you're probably thinking: "AI is complicated. I'm not smart enough for this. I need a PhD in mathematics."

That's not true.

AI sounds mysterious because people make it sound mysterious. But underneath all the hype, it's just:

Data (examples)
Math (finding patterns)
Code (making it work)

If you can learn to code, you can learn AI.

This guide breaks down what AI actually is, how it works, and how you can start building it, whether you're a CS student, a curious developer, or someone completely new to programming.

No PhD required. Just curiosity and willingness to learn.

Let's go.

What Is AI, Actually?

You hear three words thrown around: AI, Machine Learning, Deep Learning.

People use them interchangeably. But they're not the same thing.

AI (Artificial Intelligence) = The big umbrella.
Any system that can perform tasks that normally require human intelligence.
Example: A chess program, a chatbot, a recommendation system.

Machine Learning = a subset of AI.
Instead of you telling the computer exactly what to do, you show it examples and let it figure out the pattern.
Example: Show the system 1000 photos of cats and dogs. It learns to tell them apart without you writing specific rules.

Deep Learning = A subset of Machine Learning.
Uses neural networks (inspired by how brains work) to find complex patterns.
Example: ChatGPT, image generators, self-driving cars.

Think of it like this:

AI is the whole pizza
Machine Learning is a slice
Deep Learning is a bit of that slice

Why does this matter?

Because you don't need deep learning to start. Most real-world problems are solved with machine learning.

You can predict house prices, classify emails as spam, and recommend products, all with machine learning, not deep learning.

Start simple. Go deep only when you need to.

The Types of Machine Learning

Machine learning breaks down into three main types. Understanding the difference is crucial because it changes how you approach problems.

1. Supervised Learning

You have data with answers.

The computer learns from examples where you've already labeled the correct answer. It's like learning with a teacher who shows you the right answer after each question.

Examples:

Email spam detection: "This email is spam" (labeled)
House price prediction: "This house costs ₦50 million" (labeled)
Image recognition: "This is a cat" (labeled)

How it works:

You give the system labeled examples
It finds patterns between the input and the label
When new data comes, it predicts the label

Most real-world problems use supervised learning.

2. Unsupervised Learning

You have data with no answers.

The computer finds patterns on its own. No teacher. No labels. Just raw data.

Examples:

Customer segmentation: Group customers by behavior (they don't know the groups beforehand)
Recommendation systems: Find users with similar tastes
Clustering documents: Group similar articles together

How it works:

You give the system unlabeled data
It finds hidden patterns
You discover insights you didn't know existed

3. Reinforcement Learning

The computer learns by doing and getting feedback.

Like training a dog: good behavior = reward. Bad behavior = no reward.

Examples:

Self-driving cars learning to navigate
Game AI learning to win
Robots learning to walk

How it works:

The agent (AI) takes an action
It gets feedback (reward or penalty)
It learns to maximize rewards

Which one do you need?

Start with supervised learning. 90% of real problems can be solved this way.

Most beginners should focus here.

Your Tools: Languages and Libraries

Okay, so you understand the theory. Now what do you actually use to build AI?

The Language: Python

Python dominates AI for one reason: it's simple.

You can focus on AI concepts, not syntax. Other languages (Java, C++) require more boilerplate code.

If you don't know Python yet, learn it first. It's easy and widely used in the AI community.

The Libraries: What You Need

Think of libraries as toolkits. Each one solves different problems.

Scikit-learn

Best for: Beginners, traditional machine learning
What it does: Classification, regression, clustering
When to use: Predicting prices, spam detection, customer segmentation
Difficulty: Easiest

TensorFlow

Best for: Deep learning, production systems
What it does: Neural networks, large-scale models
When to use: Image recognition, NLP, complex problems
Difficulty: Medium-Hard

PyTorch

Best for: Research, rapid prototyping
What it does: Neural networks, flexible design
When to use: Building custom models, research projects
Difficulty: Medium

The Honest Truth:

Start with scikit-learn. It's simple, powerful, and teaches you ML fundamentals without the complexity.

Once you understand how machine learning actually works, move to TensorFlow or PyTorch.

Don't jump to deep learning frameworks as a beginner. You'll get lost in the complexity and miss the fundamentals.

Where to Code:

Google Colab (free): Write Python in your browser, no installation needed
Jupyter Notebooks (free): Write code locally with explanations
VS Code (free): Full IDE if you want to get serious

Start with Google Colab. Seriously. No setup, just write code.

Your First Steps:

Learn Python basics (loops, functions, data structures)
Learn pandas (data manipulation)
Learn scikit-learn (machine learning)
Build a project

That's it. Don't skip steps.

You Now Know:

What AI, Machine Learning, and Deep Learning are
The three types of machine learning
The tools you need to get started
Where to write your first code

Next step? Build something.

In the next article, we'll walk through a real project - predicting house prices - and you'll see how all this theory actually works in practice.

See you there.

— Temiloluwa Valentine