DEV Community: mohd ibrahim

Hackathon Project: How I built an AI Recommender System for SMEs

mohd ibrahim — Sat, 11 Apr 2026 06:10:05 +0000

The Inspiration 💡

We’ve all been there: you add five things to a cart, get distracted by a notification, and never look back. For small e-commerce businesses, that "lost cart" is a major hit to the bottom line. I wanted to build a tool that doesn't just track data, but actually predicts who is about to leave and what might make them stay.

What is SmartCart AI? 🛒

SmartCart AI is a predictive analytics dashboard designed for e-commerce managers. It takes massive transaction datasets and turns them into three actionable insights:

Churn Prediction: Who is "at-risk" of never coming back?
Customer Health: Visualizing the purchase "pulse" of every user.
Smart Recommendations: What should we offer them next?

The Tech Stack 🛠️

Building this required a mix of data engineering and machine learning:

Language: Python 3.12
Frontend: Streamlit (for that snappy, interactive UI)
Data Processing: Pandas & NumPy
Machine Learning: Scikit-Learn
Random Forest Classifier for churn risk.
Collaborative Filtering for the recommendation engine.
Visuals: Plotly for the behavioral timelines.

The "Aha!" Moment: Solving the Cold Start ❄️

One of the biggest hurdles was the Cold Start problem—how do you recommend products to a brand-new user with no history? I solved this by implementing a "Popularity Fallback" logic: if the AI doesn't know you yet, it shows you what everyone else is loving until it learns your patterns.

Under the Hood: How it Works 🧠

The system uses RFM Analysis (Recency, Frequency, Monetary) to score customers. We then feed these features into a Random Forest model.

# Quick snippet of the Churn Classification logic
from sklearn.ensemble import RandomForestClassifier

# Training the model on RFM features
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Predicting the probability of churn
churn_probability = model.predict_proba(user_data)[:, 1]

Key Challenges 🚧

Data Cleaning: Handling 500k+ rows of retail data was a lesson in patience. Cleaning up cancelled invoices and missing IDs was 70% of the work!
Memory Management: Learning to optimize similarity matrices so the app doesn't crash on a standard laptop.

What’s Next? 🚀

This is just the MVP. My roadmap for SmartCart AI includes:

Integrating directly with Shopify via API.
Adding "Sentiment Analysis" on product reviews to refine recommendations.
Deploying the model to the cloud for real-time streaming data.

Check it out!

GitHub Repo: https://github.com/mobrahi/hackathon-smartcart-ai
Demo Video: https://youtu.be/0tyZ6bO2QiQ

I’d love to hear your thoughts! How are you handling churn in your data projects? Let's discuss in the comments! 👇

😅 5 Beginner Mistakes I Made Learning Python (So You Don’t Have To)

mohd ibrahim — Fri, 27 Feb 2026 15:58:26 +0000

When I started learning Python (with Machine Learning as the long-term goal), I thought the hardest part would be syntax.

Plot twist:

It wasn’t syntax.

It was me.

Here are 5 beginner mistakes I made in my first weeks learning Python — and what I’d do differently now.

1️⃣ Trying to Jump Into Machine Learning Too Fast

I started learning Python because I wanted to build ML systems.

So naturally, after learning some basics, I thought:

“Okay cool… time to train models.”

Yeah… not quite.

I quickly realized:

I didn’t fully understand loops
My logic was shaky
Debugging took forever

🔎 Lesson learned:
Strong Python fundamentals make Machine Learning 10x less painful. Don’t skip the boring stuff.

2️⃣ Underestimating `if / else` Logic

I thought conditionals were simple.

Then I wrote programs where:

Conditions never triggered
Conditions always triggered
Nested logic confused even me

Python ran the code…
It just didn’t behave the way I expected.

🔎 Lesson learned:
Programming is precise thinking. Small logic mistakes create big confusion.

3️⃣ Ignoring Error Messages (At First 😬)

Whenever I saw a big red error message, my brain did this:

“Nope.”

I used to:

Re-run the code without reading the error
Change random lines hoping it would magically work
Copy-paste the entire error into Google

Eventually I realized something important:

Error messages are not enemies.
They’re clues.

🔎 Lesson learned:
Slow down. Read the error. It usually tells you exactly what went wrong.

4️⃣ Watching Too Many Tutorials

I fell into tutorial mode.

Watch.
Follow along.
Feel productive.
Forget everything the next day.

I wasn’t building anything independently.

🔎 Lesson learned:
After every tutorial, build something small without copying.

Even a simple calculator or number guessing game helps more than 3 extra videos.

5️⃣ Comparing My Progress to Everyone Else

This one hit the hardest.

I’d see:

People building ML projects
Fancy dashboards
AI demos everywhere

Meanwhile, I was fighting with basic input() statements.

It’s easy to feel behind.

But here’s what I realized:

Everyone posts their highlights.
Nobody posts their broken if statements.

🔎 Lesson learned:
Compare yourself to yesterday-you. Not to the internet.

🎯 What I’m Doing Differently Now

Instead of rushing, I’m:

✅ Focusing on logic first
✅ Writing small but complete programs
✅ Reading error messages properly
✅ Building more, consuming less

Machine Learning is still the goal.

But I’m choosing progress over ego.

💬 If You’re Learning Python Too…

What beginner mistake slowed you down the most?

Or which one are you currently fixing?

Let’s compare notes — I’m still learning too.

Introducing Repo-Pulse: Stop Repo Rot Before It Starts

mohd ibrahim — Sun, 15 Feb 2026 03:40:22 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built Repo-Pulse, a high-speed repository health diagnostic tool that calculates an "Overall Health Score" based on documentation, git history, and project hygiene.

The goal of this project was to solve "Project Debt"—that common situation where a repository is functional but lacks the professional "finishing touches" (like a proper license, a clean .gitignore, or a readable README) that make it open-source ready. Repo-Pulse provides a 30-second "vibe check," generating a weighted health score and offering an automated --fix engine to generate missing boilerplate files instantly.

Demo

The tool is designed for easy testing. No credentials required.

GitHub Repository: https://github.com/mobrahi/repo-pulse

How to test it:

git clone https://github.com/mobrahi/repo-pulse.git
pip install -e .
Run repo-pulse to see your current score.
Delete your LICENSE and run repo-pulse --fix to see the auto-remediation engine in action!

My Experience with GitHub Copilot CLI

I treated GitHub Copilot (leveraging the Claude 4.5 Haiku model) as my Lead Architect rather than just a code generator.

How it impacted my development:

Enforcing Quality Gates: Right from the start, I prompted the CLI to maintain strict type-hinting and PEP 8 standards. This turned a "quick hack" into a professional-grade package.
Intelligent Filtering: When building the file-counting logic, Copilot correctly identified that we needed to exclude "noise" directories (like .venv, pycache, and node_modules) to give an accurate project size reading.
Zero-Friction Pivoting: When I decided to add the --fix feature mid-build, the AI seamlessly adapted the existing argparse structure to include the new logic, demonstrating the agility of AI-pair programming.
Error Resilience: Copilot proactively suggested try/except blocks for the Git subprocess calls, ensuring the tool doesn't crash if run in a directory without a Git history.

Using the Copilot CLI allowed me to focus 100% on the intent and ux of the tool, while the AI handled the boilerplate and technical edge cases. It turned what would have been a few hours of documentation-diving into a 30-minute creative sprint.

🔄 Loops in Python: Why My Brain Kept Going in Circles

mohd ibrahim — Fri, 13 Feb 2026 11:39:56 +0000

🌀 The "Infinite" Struggle: Making Loops Click

If you thought if/else was tricky, let me introduce you to the Loop.

When I first started, I understood the definition of a loop, but when it came to actually writing one? My brain just stalled. I either created a loop that never stopped (RIP my computer fans) or a loop that didn't run at all.

🤖 For vs. While: The Identity Crisis

I used to stare at the screen wondering: "Which one do I pick?" Here is how I finally broke them down in my head:

1. The `for` loop: The "List Follower"

I think of a for loop like a waiter at a table. It knows exactly how many people (items) are there, and it visits each one until the job is done.

The Breakthrough: Understanding that the variable (like i or item) changes automatically every time. You don't have to tell it to move to the next item; it just knows.

2. The `while` loop: The "Security Guard"

A while loop is like a security guard: "As long as this condition is true, keep doing the thing."

The Struggle: The dreaded Infinite Loop. If you forget to change the condition inside the loop, it stays true forever. My first while loop printed "Hello" 10,000 times before I figured out how to kill the terminal.

❌ The "Wrong" Way (The Infinite Loop)

This is what I did the first time. I set a condition, but I forgot to "change the world" inside the loop.

# Goal: Count to 5
counter = 1

while counter <= 5:
    print(f"Counting: {counter}")
    # Whoops! I forgot to add 1 to the counter.
    # This prints "Counting: 1" forever.

✅ The "Right" Way (The Fix)
The fix is simple, but it’s the logic that matters: you have to "update" the state so the condition eventually becomes False.

# Goal: Count to 5
counter = 1

while counter <= 5:
    print(f"Counting: {counter}")
    counter += 1  # The magic line that saves your CPU!

💡 The "Aha!" Moment
The biggest breakthrough for me was realizing:

Use for when you know how many times you need to repeat (or you have a list/range).

Use while when you don't know exactly when you’ll stop (like waiting for a user to type "quit").

🎯 My New Strategy
Instead of guessing, I now ask myself three questions before I type a single line of code:

The Start: Where am I beginning?

The Goal: When do I need to stop?

The Step: How am I getting closer to that goal in every round?

💬 Let’s Chat
If you’re learning Python: What was the first "infinite loop" mistake you made? And if you're a pro: What's the one thing you wish someone told you about loops when you started?

I'm still learning, so I'd love to hear your tips!

😅 What I Actually Did in My First Weeks Learning Python & Machine Learning

mohd ibrahim — Tue, 03 Feb 2026 03:14:58 +0000

😅 What I Actually Did in My First Weeks Learning Python & Machine Learning

You know the one: “A few tutorials, some practice… boom, AI engineer.”

Yeah… no.

Here’s what really happened in my first weeks learning Python and ML — no hype, just reality.

🤯 What I Thought Learning Python & ML Would Be Like

I honestly believed:

I’d jump straight into machine learning models
Python would feel “natural” after a few days
Tutorials would magically click
Progress would be fast and obvious

Instead, I mostly stared at my screen asking:

“Why is this not working?”

🧩 What I Actually Worked On

Spoiler: not machine learning.

My first weeks were all about Python basics (and struggling with them).

I spent most of my time on:

🧠 Variables, input, output
🔀 if / elif / else (my new enemies)
➕ Simple programs like calculators and BMI checkers
🐛 Breaking my code… then breaking it again
📖 Reading error messages I used to ignore

Not glamorous. Very necessary.

😲 The Biggest Surprise

Python didn’t surprise me with syntax.

It surprised me with how much thinking it demands.

Python forces you to:

Think step by step
Be painfully clear with logic
Admit when your thinking is wrong

I learned this pretty fast:

Coding isn’t about typing code — it’s about solving problems without lying to yourself.

😵 What Was Harder Than Expected

Logic.
Basic logic.

Things like:

❌ Why my if condition never runs
❌ Why my answer is always wrong
❌ Why my program works once and then refuses forever

Painful lesson:

Python will happily run your code even if your logic makes zero sense.

Debugging quickly became part of my daily routine.

🤖 How This Changed How I See Machine Learning

This phase gave me a reality check.

I now understand that:

Weak Python basics = suffering later in ML
Machine learning is just logic… but louder
Skipping fundamentals is a terrible idea

So instead of rushing into ML, I slowed down — even though it felt uncomfortable.

Turns out, slowing down is progress too.

🎯 What I’m Focusing on Next

Right now, I’m keeping it simple:

✅ Stronger Python fundamentals
✅ Small but complete programs
✅ Logic first, complexity later

Machine learning is still the goal.
I’m just choosing the less painful path.

🧠 One Small Lesson I’m Taking Forward

If I had to summarize my first weeks learning Python and Machine Learning in one sentence, it would be this:

Don’t rush toward “advanced” topics when the basics are still teaching you how to think.

Learning Python slowed me down in a good way.
It forced me to stop guessing and start reasoning.

I didn’t build anything impressive yet — but I built patience, debugging skills, and a better way to approach problems.

That feels like a solid foundation.

💬 Let’s Compare Notes

If you’re learning Python or ML right now:

What part confused you the most at the beginning?

Or what do you wish you had slowed down on?

I’d love to learn from your experience.

👋 If you’re learning Python too, what confused you the most at the beginning?

SENTINEL.EXE | AI-Powered Firewall Defense

mohd ibrahim — Sat, 31 Jan 2026 15:27:37 +0000

About Me

I am Mohd Ibrahim, a Bootcamp Student and AI Explorer. As I head into 2026, I am focusing on bridging the gap between traditional software development and generative AI. With this portfolio project, I wanted to express that AI isn't just a "chatbot" interface—it can be a core engine for creativity, world-building, and dynamic systems in gaming.

Portfolio

🎮 Play SENTINEL.EXE Live Here

Note: For the best experience, please use a Desktop browser.

How I Built It

SENTINEL.EXE is a cyber-noir Tower Defense game where the player defends a "Human History Core" from sentient logic bombs.

Players take on the role of the last active security protocol in a dying supercomputer. Your mission is to deploy experimental subroutines (towers) to prevent sentient logic bombs (viruses) from reaching the "Human History Core."

"In a world of collapsing data, you are the last line of defense."

The Tech Stack

Engine: Python 3.12 (Pygame-ce)
AI: Google Gemini 2.0 Flash (via google-genai SDK)
Web Tech: WebAssembly (WASM), Pygbag, Flask
Cloud: Google Cloud Run, Docker, Google Artifact Registry

Google AI Integration

I treated Gemini 2.0 Flash as a critical system component rather than a gimmick:

Procedural Lore: Gemini handles the world-building, generating unique backstories for the supercomputer environment.
Event-Driven Architecture: To keep the game at a smooth 60 FPS, I implemented an asynchronous pattern where AI calls are offloaded to background threads during "Pre-Wave" states.
Responsible AI & Robustness: I built a Fail-Safe Architecture. If the API hits a rate limit or a network error occurs, the system gracefully falls back to a "Local Lore" subroutine, ensuring the game remains fully functional and immersive even offline.

What I'm Most Proud Of

I am most proud of the Robustness Logic and the Thread-Safe AI Integration. Offloading Gemini API calls to a background thread allowed me to keep the gameplay smooth while generating dynamic content in real-time.
Integrating a cloud-based LLM into a real-time game loop presents significant latency challenges. Successfully implementing a background thread system that allows the game to render while waiting for Gemini's response—combined with a "Tactical Cooldown" to respect Free Tier rate limits—felt like a major engineering win. It demonstrates that AI-powered games can be both high-concept and technically stable.
I'm particularly proud of the Environment-Aware Logic. The game automatically detects if it's running in a browser or on a PC. It switches from a full AI-powered tactical advisor on desktop to a high-performance, local-fallback mode on the web, providing a seamless experience regardless of the platform.

Technical Hurdles

1. The Async Transition (Desktop vs. WebAssembly)

The Problem: Pygame is traditionally a synchronous, blocking library designed for desktop CPUs. When I first tried to port the game to the web using Pygbag, the browser tab would completely freeze. The Solution: I had to refactor the entire core engine to use asyncio. By implementing await asyncio.sleep(0) inside the main loop, I allowed the browser’s JavaScript engine to "breathe," handling events and rendering frames without locking up the user's interface.

2. Managing the AI Bottleneck

The Problem: Calling the Gemini API is a "heavy" I/O operation. If I called the AI directly inside the game loop, the game would "hitch" or pause for 1–2 seconds while waiting for the network response, killing the "real-time" feel of a tower defense game. The Solution: I implemented a multi-threaded/asynchronous approach. I moved the API calls to background threads and used asyncio.to_thread for the lore generation. This ensured that while Gemini was "thinking" of a gritty virus taunt, the towers were still firing and the viruses were still moving at a smooth 60 FPS.

3. Containerizing a Hybrid App

The Problem: Running a Pygbag-built static site inside a Python Flask server on Google Cloud Run required a specific folder architecture that differed from my local development environment. I initially ran into ModuleNotFoundError because of how Python handles sub-directory imports. The Solution: I reorganized the project into a strict game/ and app/ structure. I used a custom Dockerfile to serve the Wasm-compiled assets via Flask, ensuring that Google Cloud Run could scale the game infinitely while maintaining the correct MIME types for the .wasm and .js files.

4. The 'Ghost Layer' Architecture: Bypassing Static Analysis

The Problem: The biggest hurdle was deploying a Python game with AI dependencies (Google GenAI) to the web. The Pygbag compiler normally crashes when it sees desktop-only libraries. I solved this by building a 'Ghost Layer' using importlib. This allowed me to dynamically load AI modules only on Desktop, effectively 'hiding' them from the web compiler and ensuring a stable WebAssembly build.

How to Play: Operation SENTINEL.EXE

Objective: Protect the Human History Core (the cyan square at the center) from incoming virus packets. If your system integrity hits 0%, the firewall is breached and the data is lost.

Deploying Defenses: Click anywhere on the grid to deploy a Firewall Node (Tower).
- Cost: 50 Ghz (CPU Cycles) per node.
CPU Cycles (Ghz): This is your primary resource. You gain 10 Ghz for every virus packet purged. Use them wisely—don't run out of "clock speed" when a big wave hits!
AI Tactical Advisor: Press [H] during gameplay to request a Tactical Sync. Gemini will analyze your current integrity and cycles to provide a one-sentence defense tip. (Note: Has a 15-second cooldown to prevent CPU throttling).

** Lore Initialization** : Press [SPACE] at the start menu to have Gemini generate the current wave's sector lore.

** System Reboot** : If the core is breached, press [R] to re-initialize the firewall and try a new strategy.

💡 Pro-Tips

Focus Fire: Place nodes near the center to maximize their coverage of the core.
Manage Latency: If playing on the web, look for the Local Fallback messages—they demonstrate the game's ability to remain playable even if the AI API is under heavy load.

DEV Community: mohd ibrahim

Hackathon Project: How I built an AI Recommender System for SMEs

The Inspiration 💡

What is SmartCart AI? 🛒

The Tech Stack 🛠️

The "Aha!" Moment: Solving the Cold Start ❄️

Under the Hood: How it Works 🧠

Key Challenges 🚧

What’s Next? 🚀

😅 5 Beginner Mistakes I Made Learning Python (So You Don’t Have To)

1️⃣ Trying to Jump Into Machine Learning Too Fast

2️⃣ Underestimating if / else Logic

3️⃣ Ignoring Error Messages (At First 😬)

4️⃣ Watching Too Many Tutorials

5️⃣ Comparing My Progress to Everyone Else

🎯 What I’m Doing Differently Now

💬 If You’re Learning Python Too…

Introducing Repo-Pulse: Stop Repo Rot Before It Starts

What I Built

Demo

My Experience with GitHub Copilot CLI

🔄 Loops in Python: Why My Brain Kept Going in Circles

🌀 The "Infinite" Struggle: Making Loops Click

🤖 For vs. While: The Identity Crisis

1. The for loop: The "List Follower"

2. The while loop: The "Security Guard"

❌ The "Wrong" Way (The Infinite Loop)

😅 What I Actually Did in My First Weeks Learning Python & Machine Learning

😅 What I Actually Did in My First Weeks Learning Python & Machine Learning

🤯 What I Thought Learning Python & ML Would Be Like

🧩 What I Actually Worked On

😲 The Biggest Surprise

😵 What Was Harder Than Expected

🤖 How This Changed How I See Machine Learning

🎯 What I’m Focusing on Next

🧠 One Small Lesson I’m Taking Forward

💬 Let’s Compare Notes

SENTINEL.EXE | AI-Powered Firewall Defense

About Me

Portfolio

🎮 Play SENTINEL.EXE Live Here

How I Built It

The Tech Stack

Google AI Integration

What I'm Most Proud Of

Technical Hurdles

1. The Async Transition (Desktop vs. WebAssembly)

2. Managing the AI Bottleneck

3. Containerizing a Hybrid App

4. The 'Ghost Layer' Architecture: Bypassing Static Analysis

How to Play: Operation SENTINEL.EXE

2️⃣ Underestimating `if / else` Logic

1. The `for` loop: The "List Follower"

2. The `while` loop: The "Security Guard"