How Apps Know What You Want Next?

Step 4 is where the personality lives.

The filtering strategy you pick is what makes one recommender feel psychic and another feel like it's just showing you the same hoodie you already bought.

The three classic approaches

Collaborative filtering: "people like you also liked..."

Collaborative filtering ignores what the items actually are and looks purely at behavior.

The core assumption: if you and I have agreed on a hundred things, we'll probably agree on the hundred-and-first.

It comes in two main styles:

• 
  Memory-based systems treat everything as one giant user–item matrix and look for nearest neighbors, basically k-NN with a fancier hat.
  User-based filtering compares rows (you vs. other users); item-based filtering compares columns (this item vs. other items, based on who interacted with them).


• 
  Model-based systems train an actual predictive model on that matrix.
  The most famous trick here is matrix factorization: take a huge, empty user–item matrix and decompose it into two skinny matrices
  one describing users
  one describing items across a handful of hidden dimensions.
  Multiply them back together and you've predicted the blanks.
  Those blanks are your recommendations.

Hold onto that matrix factorization idea.

Those "hidden dimensions" are embeddings wearing a trench coat, and we'll come back to them.

Collaborative filtering is powerful and doesn't need anyone to describe the items.

Its kryptonite is the cold start problem: a brand-new user or a brand-new item has no history, so the system has nothing to compare.

Spotify and Amazon both lean heavily on this approach.

Like Die Hard? The engine reaches for Mad Max, not The Notebook not because anyone hand-coded that rule, but because the vectors landed close together.

In a real system you wouldn't pick those four numbers by hand.

A model learns them from data: matrix factorization derives them from the user–item matrix, neural networks learn richer ones, and for text or images you'd hand things to a pretrained embedding model and get hundreds of dimensions back.

Same principle, just more dimensions than a human can picture.

This is also why embeddings are such a big deal beyond recommendations.

The exact trick, represent meaning as vectors, compare by proximity and it is what powers semantic search, retrieval-augmented generation, clustering, and a good chunk of modern AI tooling. Learn it once, reuse it everywhere.

The parts nobody puts on the landing page

Building a recommender that works is a different sport from building one that demos well.

A few things that may bite teams in production:

• 
  Scale and speed. You're serving real-time suggestions to potentially millions of people at once. Cosine similarity across four movies is trivial; doing it across ten million items with sub-100ms latency is its own engineering discipline (hello, approximate nearest neighbor search).


• 
  The wrong metric trap. Optimize for the wrong thing and you'll just keep surfacing whatever's already popular, burying new or niche items in a feedback loop. The most-clicked item isn't always the one the user actually wants.


• 
  Bias. Models happily absorb whatever bias lives in the training data. If your history is skewed, your recommendations will be too and that's a product and ethics problem, not just a math one.


• 
  Privacy and compliance. All of this runs on user data, and users increasingly opt out, while regulators increasingly pay attention. "Collect everything" is no longer a free strategy.


• 
  Cost. Hybrid systems and deep models are hungry. Sometimes a simpler approach that's 90% as good and a tenth of the cost is the right engineering call.

Where this shows up

Once you start looking, recommenders are everywhere: e-commerce ("frequently bought together"), media and streaming (the next episode, the next track), travel ("hotels for your budget and dates"), and marketing (which case study to email which lead).

They've even moved into AIOps, where they suggest fixes to IT teams during incidents and a recommendation engine for "your server is on fire, try this."

The takeaway

Strip away the branding and a recommendation engine is doing something pretty intuitive: it turns users and items into vectors, then measures who's close to whom.

Collaborative filtering learns those vectors from behavior, content-based filtering builds them from features, hybrids do both, and embeddings are the common language underneath it all.

If you're going to learn one concept from this, make it embeddings.

The "represent meaning as numbers, compare by distance" idea is the same move behind recommendations, search, and most of the AI stack you'll touch this decade.

Get comfortable with it now, and a surprising amount of modern ML stops looking like magic and starts looking like geometry.

Now go build something that knows what people want before they do.

Disclaimer: This article was written by me; AI was used to fix grammar and improve readability.

/ | | | | | |

GenAI today is a race car without brakes. It accelerates fast -- you describe something, and large blocks of code appear instantly. But AI agents silently break things: they remove logic, relax constraints, introduce expensive cloud calls, leak credentials, and change behavior -- without telling you. You often find out in production.

git-lrc is your braking system. It hooks into git commit and runs an AI review on every diff before it lands. 60-second setup. Completely free.

In short, git-lrc helps Prevent Outages, Breaches, and Technical Debt Before They Happen

At a glance: · every commit…