I spent the first four months of learning ML thinking I understood it. Read the Wikipedia article. Nodded along to three-hour YouTube tutorials. Could recite the official definition without blinking. Then my manager asked me to explain it to a non-technical colleague in a meeting, and I completely fell apart — because what I’d memorized wasn’t understanding, it was vocabulary.
That’s the trap most beginner resources set for you. They hand you the words. They don’t give you the picture.
So here’s my attempt at the picture.
Definition
Machine learning is a way of building software that figures things out from examples instead of explicit instructions. Rather than a programmer writing rules for every situation, the system studies patterns in past data and uses those patterns to handle new situations it has never seen. It doesn’t think. But it gets surprisingly good at specific, well-defined tasks.
Why the Standard Definition Falls Short
Here’s what bothers me about how machine learning usually gets introduced.
Most explanations — and I’ve read dozens of them at this point — lead with some version of “computers learn from data.” That’s true. It’s also about as useful as saying “cooking involves heat.” Technically accurate. Tells you basically nothing about what’s actually happening or why it’s hard.
The thing that clicked for me wasn’t a definition. It was thinking about spam filters.
A traditional spam filter works by rules: if the subject line contains “FREE MONEY” from an unknown sender, flag it. Clean. Predictable. Also completely gameable — the moment spammers learned the rulebook, they started writing “Fr33 M0ney” and the filter went blind. Update the rules. They adapt. Eternal, exhausting cat-and-mouse.
A machine-learning spam filter doesn’t use rules. You feed it ten thousand emails already labeled spam or not spam, and it figures out on its own what separates them — not just keywords, but sender reputation, timing patterns, link structures, the ratio of images to text, a hundred things you’d never think to hard-code explicitly. When new spam arrives dressed in new clothes, the system already knows what dressed-up spam looks like. It’s learned the concept, not just the costume.
That’s the real thing machine learning does. It learns concepts from examples, not rules from programmers.
How a Model Actually Gets Built
The word “model” gets thrown around constantly in ML, and I think it confuses people more than it helps. Let me use a different word: map.
When you train an ML model, you’re building a map from inputs to outputs. Feed in an email — get out a spam probability. Feed in a photo — get out “cat” or “not cat.” Feed in a patient’s vitals — get out a risk score. The training process is the messy, iterative work of drawing that map accurately enough to be useful.
Here’s the three-step version:
Step one: Gather labeled examples. These are your inputs paired with correct outputs. The quality of these labels matters enormously — more on that in a moment.
Step two: The algorithm hunts for the pattern. This is the part people imagine as magical. It’s not; it’s optimization. The algorithm makes a prediction, checks how wrong it was, adjusts its internal parameters slightly to be less wrong next time, and repeats this tens of thousands of times. Gradient descent — the mathematical engine under nearly every ML system you’ve ever heard of — is just this loop running at scale.
Step three: Test on data the model has never seen. A system that performs brilliantly on its training data might be completely useless on anything new. It might have memorized the examples instead of learning the pattern. Testing on held-out data is how you find out whether you’ve built something real or something that’s very good at cheating.
That’s it. The rest of the field — all the architectures, the frameworks, the papers, the math — is people trying to do those three steps better.
The Three Flavors (And Which One Actually Dominates)
You’ll see this breakdown everywhere. I want to give you the version that tells you something, not just the names.
Supervised Learning
The workhorse. You have labeled data — inputs and their correct answers — and the model learns the relationship. Fraud detection, image classification, loan approval, medical diagnosis. Most of the ML running in production environments right now is supervised learning wearing different clothes. A 2026 Kaggle State of Data Science report found roughly 79% of real-world ML deployments use some form of it. Everything else is niche by comparison.
Unsupervised Learning
People describe this as “finding hidden structure” — which sounds profound and is usually confusing. Cleaner version: you have data with no labels, and you want the algorithm to organize it. Cluster your customers into segments. Detect anomalous network events. Compress images by identifying what information is redundant. Useful. Also genuinely harder to evaluate, because without labels, how do you know if the structure your algorithm found is real or just noise? That question — honestly — doesn’t have a fully satisfying answer. I’ve asked people smarter than me. They shrug too.
Reinforcement Learning
The one that gets the flashiest press. An agent acts in an environment, receives rewards or penalties, and gradually learns to maximize reward. AlphaGo. Game-playing AI. The robot that learns to walk by falling over eight thousand times before getting it right. Impressive. Also overkill for 97% of the problems you’ll actually encounter. Learn it eventually — but only after supervised learning is genuinely solid.
The Part Tutorials Quietly Skip
Right. This is the section I wish had existed when I was starting out.
Machine learning is not a magic button. The field has a phrase for it — “garbage in, garbage out” — but even that undersells the problem, because the garbage is usually invisible. Biased labels. Missing demographic groups. Historical data that bakes in historical discrimination. Training examples that look representative but quietly aren’t.
I ran into this face-first early on. I built a model to classify customer complaints by urgency for a small project. Tested great. Deployed it. Three weeks later someone pointed out it was systematically rating complaints from customers in certain regions as lower priority — not because of anything about the complaints themselves, but because those regions had fewer records in our training data, so the system had learned less about them. My “working” model had a blind spot baked right into it, and I’d shipped it confidently.
No amount of architectural cleverness fixes that. None.
(Tangent worth flagging)
This is why I get frustrated when people treat ML as primarily a math problem. It’s at least as much a data problem — and data problems are human problems. They require judgment, domain knowledge, and an honest look at what your dataset is actually saying. The math is the easy part, relatively speaking. Nobody puts that in the brochure.
The other thing tutorials skip: most ML systems need ongoing care after deployment. A model trained on 2024 data doesn’t magically understand what changed in 2026. Customer behavior shifts. Fraud patterns evolve. The world moves, and a static model gradually becomes wrong — sometimes slowly, sometimes overnight. This is called data drift, and dealing with it is a huge, unglamorous chunk of actually running ML in production.
Ten Lines of Python — Because Theory Only Goes So Far
Here’s what machine learning looks like stripped to the bones. Logistic regression — not fancy, not deep learning, just a basic classifier — predicting spam based on two features: word count and exclamation mark count.
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import numpy as np
# [word_count, exclamation_marks] → label (1=spam, 0=not spam)
X = np.array([[50,0],[200,1],[30,5],[180,0],[20,8],[250,2],[15,9],[300,0]])
y = np.array([0, 0, 1, 0, 1, 0, 1, 0])
# Hold 30% back — the model never touches this during training
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42)
model = LogisticRegression()
model.fit(X_train, y_train)
# New email: 80 words, 7 exclamation marks
print(model.predict([[80, 7]])) # → [1] (spam)
print(f’Test accuracy: {model.score(X_test, y_test):.0%}’)
Eight training examples is absurdly small — don’t read anything into the accuracy number this produces. The structure is what matters: gather data, split it, train on part, evaluate on the rest. Every ML pipeline ever built is a more elaborate version of exactly this.
What I Still Don’t Know (And Neither Does Anyone, Fully)
I want to be straight with you about something.
There are parts of modern machine learning that even the researchers building it don’t completely understand. Why do neural networks generalize as well as they do, given that they’re theoretically complex enough to just memorize their training data? Why does making a model bigger often make it better in ways that don’t fit the math cleanly? These aren’t beginner questions I’m glossing over — they’re open research problems that some of the sharpest people in the field are actively arguing about in 2026.
I find that strangely reassuring. The fundamentals I can teach you. The edges are genuinely murky. That’s fine.
What This Post Didn’t Cover
📎 Honest scope note
We didn’t get into how gradient descent actually works — that’s a full post and a genuinely interesting one once you see the geometry. We skipped neural networks entirely (they deserve their own deep dive). We didn’t touch model evaluation beyond accuracy, which is more important than most intros admit. Each of those is coming in this series.
Frequently Asked Questions
What is machine learning in simple terms?
Machine learning is software that learns patterns from examples instead of following hand-written rules. You show it thousands of labeled inputs and their correct outputs, it finds the relationship, and then uses that relationship to handle new inputs it’s never seen before. The more examples — and the more those examples represent reality — the more useful it gets.
Is machine learning the same as artificial intelligence?
Not exactly. AI is the broad goal: machines that can do things requiring intelligence. Machine learning is one approach to reaching that goal — instead of programming intelligence directly, you let the system learn it from data. All machine learning is AI, but plenty of AI systems don’t use machine learning at all. The terms get used interchangeably in the press because “AI” sounds more exciting, not because they mean the same thing.
Do I need advanced math to start learning machine learning?
You need some math — linear algebra for understanding data as vectors, basic probability for interpreting what a model is actually predicting, and enough calculus to understand what “minimizing a loss function” means geometrically. But you don’t need to be a mathematician. Start with the concepts. Go deeper on the math when you hit a wall and actually need it, not before.
The honest version of machine learning isn’t the one where algorithms are magical and models always work. It’s messier than that — more human, more contingent, more dependent on the quality of the questions you ask before you write a single line of code. The practitioners getting real value out of this field in 2026 aren’t the ones who know the most algorithms. They’re the ones who know when to use them — and, just as importantly, when not to.
→ Next: Supervised vs. Unsupervised vs. Reinforcement Learning Explained
