Every ML Model You'll Ever Build Follows the Same Three Moves

I spent years jumping between algorithms without seeing the pattern underneath them.
Linear regression. Logistic regression. Gradient boosting. Neural networks. Each one felt like a separate discipline with its own math, its own intuition, its own debugging headaches.
Then one day it clicked: they're all the same three-step architecture wearing different clothes.

Hypothesis → Loss → Optimization

That's it. That's the whole skeleton.
Hypothesis answers one question: what shape do you think the answer takes?

For linear regression, your hypothesis is a straight line: y = wx + b. For a decision tree, it's a series of splits. For a neural network, it's a composition of nonlinear functions stacked in layers. Different shapes, same job — propose a function that maps inputs to outputs.

Loss answers a different question: how wrong is the hypothesis right now?

Squared error for regression. Cross-entropy for classification. Hinge loss for SVMs. You can even design your own custom loss function if your business problem demands it. The loss function is just a formalized way of saying "here's how much this prediction hurts."

Optimization answers the last question: how do we get less wrong?

Gradient descent is the most common answer, but it's not the only one. Some problems have closed-form solutions you can solve directly with linear algebra. Some use evolutionary algorithms. Some literally use trial and error at small scale. The optimizer's job is just to nudge the hypothesis toward lower loss, however that nudging gets implemented.

Why this reframe matters

Once I stopped asking "what algorithm should I use?" and started asking "what's my hypothesis, what's my loss, what's my optimization?", model selection got a lot less mysterious.
It also made debugging faster. If a model isn't learning, I no longer guess randomly. I check each step in order: Is the hypothesis class expressive enough to capture the pattern? Is the loss function actually penalizing the errors that matter for this business problem? Is the optimizer converging, or is it stuck, oscillating, or diverging?
Most "my model isn't working" bugs live in exactly one of those three buckets. Naming the bucket cuts debugging time dramatically.

The pattern goes beyond ML

I've noticed this same three-step logic shows up outside of pure modeling too. Any time a team builds a scoring system — fraud detection, lead scoring, churn prediction — they're implicitly defining a hypothesis (what signals matter), a loss (what counts as a costly mistake), and an optimization process (how the system improves over time).
The vocabulary changes by domain. The underlying architecture doesn't.
The takeaway

Algorithms aren't really different species. They're different instantiations of the same three questions, asked in the same order, every time.
Once you see the skeleton, the muscle is just implementation detail.