Tell a rule you write by hand apart from a pattern a model learns from examples, then label the features, target, and prediction in a real data table.

You can spot a junk email in half a second, but try writing the `if` statement that catches every one. Block the word "free" and you flag the shipping notice you wanted.

Sort a problem into supervised, unsupervised, or reinforcement learning by reading the data it holds, an answer column, no answers, or a reward earned by acting.

You have a spreadsheet of past loans, each row stamped `repaid` or `defaulted`; another file lists shoppers with nothing stamped on them, and a third is a game bot chasing points. Same goal, learn, but the data forces three paths.

Trace one pass of the training loop, guess, measure the error, nudge the weight, then explain why more passes stop helping and how the step size can wreck or rescue a run, all with zero math.

A brand-new model looks at a $400k house and predicts $1.2M, wildly wrong, because its dials were set at random. Nobody fixes it by hand; it fixes itself by guessing, checking the miss, and adjusting, again and again.

Decide whether a problem fits a hand-written rule or a trained model by running one four-condition test, then inventory the enough, labeled, representative data you'd need before any code.

A junior dev spends a week writing `if subject.contains('free')` rules to catch spam, and the spammers route around every one by Friday. The pattern was real, but no human could keep writing it down fast enough.

Spot tabular, image, text, and time-series data on sight, and match each shape to the kind of problem it feeds.

Four files land in your inbox: a spreadsheet, a photo, a chat log, and a year of `.csv` stock ticks. The goal on each is the same, predict something, but no two of them can be read the same way.

Hold back a test set so a model's score is honest, then catch the leak that makes a broken model look perfect.

Your model scores 99% on the house table it just trained on, so you ship it. But the table only handed back prices it had memorized, that 99% measured recall, not skill, and the first real house proved it.

Read a number off a fitted line, then tell when a straight line is too simple for the data and when a prediction has strayed past the range you measured.

Feed a model a stack of past house sales, then ask what a 2,000-square-foot place should cost. It answers $410k, a price that appears nowhere in the data, by reading the trend those sales trace out.

Draw the boundary that separates two categories, read a case's confidence from how far it sits from that line, and set the cut-off that decides which mistakes the model makes.

A new email hits your inbox, and the model will not hand back a number this time. It picks one bucket, `spam` or `not spam`, and commits: a real message sorted the wrong way rots unseen in the junk folder.

Trace a loan application down a tree's yes/no branches to a verdict, then explain why a forest of trees that vote beats any single tree that memorized its examples.

A loan officer never weighs your whole life at once: they fire one question, `income > 50000?`, then the next, then the next, until a yes/no chain lands on approve or deny. A model can decide the very same way.

Diagnose a model that memorized its training data from the gap between its training and test scores, tell that failure apart from a model too simple to catch the pattern, and pull an overfit model back with more data, a simpler model, or regularization.

A spam filter aces every email in its training folder, posts `99% correct`, then meets your inbox and waves the junk through while quarantining your boss: it learned those exact emails, not what spam actually looks like.

Split one accuracy score into a confusion matrix's four cells, and weigh a false alarm against a missed case to see why a 99%-accurate model can be useless on rare events.

A screening model looks at each patient and, every time, returns `healthy`. It is right for 999 of every 1,000 people, a score most teams would ship, and it has never once caught the patient who is actually sick.

Compare two models fairly by rotating the held-out slice instead of trusting one lucky split, keep the simpler model when scores tie, and seal the test set so checking it never inflates the verdict.

You ship Model A over Model B because A scored higher on your test pile. A teammate reruns the exact comparison with `random_state=3` instead of `0`, B now wins, same code and same emails.

Trace a model's unfair tilt back to the skew in its training data, and judge when a confident prediction has not earned your trust.

A résumé scoring model trained on a decade of mostly-male hires reads a new application and returns `reject`. No one wrote that rule; the model only ever learned the one pattern the old hiring data already carried.