Classic ML with Modern Models

Classic ML - classification, labeling, the boring stuff - is where the real money is in an AI pipeline. Not the billion-parameter model. The classifier that runs on a CPU and costs nothing.

Everyone wants to talk about frontier models. Nobody wants to talk about stage 1. But stage 1 is where most pipelines live or die, and a well-trained classifier will outperform a frontier model on that work every time - faster, cheaper, more accurate.

The Jig, Not the Chisel

In woodworking, when you need to make the same cut five hundred times, you don’t measure and saw each piece by hand. You build a jig - a simple template that guides the blade to the same spot every time. The jig is cheap. The per-piece cost is near zero. And once it’s set up, you don’t need a master craftsman at the bench; anyone can pull the saw through the jig and get an identical result.

Classic ML classifiers are jigs. The frontier model is the master craftsman.

If you’re routing helpdesk tickets - “does this go to networking, billing, or security?” - you could send every ticket through a frontier model and wait for it to reason its way to an answer. That works. It’s also slow, expensive, and surprisingly error-prone; the model that’s great at generating prose is not necessarily the best at consistent bucket-sorting.

A trained classifier does that job in milliseconds, on a CPU, for free. It doesn’t reason. It doesn’t hallucinate. It applies a pattern it learned from your data - your data, not the internet’s - and it applies it the same way every single time.

The Training Data Was Always the Hard Part

Here’s the catch, and it’s always been the catch: a classifier is only as good as the data you trained it on. Garbage in, garbage out isn’t a cliché in ML - it’s a literal description of what happens.

That’s why classic ML fell out of fashion. Not because the algorithms were bad. Naive Bayes, logistic regression, gradient-boosted trees - these are mature, well-understood, and remarkably effective. The problem was the labeling. To train a classifier on helpdesk tickets, you needed thousands of examples, each one manually labeled by a human. And not just any human - humans who understood the categories, who could distinguish “this is a billing dispute” from “this is a pricing question” with consistency.

Get five people in a room to label tickets and you’ll get five different interpretations of “urgent.” One person’s “networking” is another person’s “infrastructure.” The inter-rater reliability problem eats your data quality alive, and your classifier inherits every disagreement.

Modern Models as Labeling Assistants

This is where the frontier model earns its keep - not as the production classifier, but as the labeling tool that builds the production classifier.

You take your raw tickets, feed them to a modern model, and ask it to label them. It’s fast. It’s consistent - one model, one mental model, one interpretation of “urgent” applied across the entire dataset. It doesn’t get tired at ticket #4,000 the way a human does.

The data still needs review. You spot-check the labels, correct the edge cases, and catch the moments where the model misunderstood a category. But you’re reviewing, not labeling from scratch - and the consistency of the underlying data is dramatically higher than if you’d handed the same tickets to a team of humans and tried to reconcile their disagreements after the fact.

The frontier model isn’t the product. It’s the scaffolding you use to build the product, and then you take the scaffolding down.

Kilobytes, Not Gigabytes

Here’s the part that surprises people: the classifier you end up with is small. We’re talking kilobytes - a logistic regression model might be a few hundred kilobytes. A naive Bayes classifier is smaller than the emoji set on your phone. A gradient-boosted tree ensemble might crack a megabyte if you’re being generous with the hyperparameters.

That model runs on a CPU. No GPU. No inference server. No API calls. You can deploy it in a Lambda function, on a Raspberry Pi, in a sidecar container that costs nothing to run. It classifies a ticket in the time it takes to read this sentence.

The frontier model that helped you label the data? It cost dollars per thousand tickets and lives in a data center. The classifier it produced costs pennies per million and lives anywhere you want it to.

Re-Training Is a Button, Not a Project

In the old world, retraining a model was a project. You’d discover a new ticket category, realize your training data didn’t cover it, and face weeks of relabeling, retraining, and revalidating before you could ship.

With a modern model doing the labeling, retraining becomes a script. New categories show up in your ticket stream? Feed the new data through the model for initial labels, review and correct, retrain the classifier. The whole loop - from “we noticed a new category” to “the classifier now handles it” - can be an afternoon, not a quarter.

That changes how you think about the pipeline. The classifier isn’t a fragile artifact you’re afraid to touch. It’s a living tool you tune as the business evolves. The training is fast enough that iteration is cheap, and cheap iteration is how you get to accuracy.

Summary

The story everyone tells about AI is the frontier model doing everything - reasoning, writing, generating. That’s the headline. But the quiet, boring, profitable work is classic ML: small, fast classifiers that do one job reliably and cheaply.

The frontier model made that work practical. It solved the labeling problem - the thing that kept classic ML expensive and brittle - by becoming the consistent, tireless labeler that humans couldn’t be. But the frontier model is the jig-maker, not the jig. The jig is the classifier: kilobytes, CPU, milliseconds, free to run, and easy to retrain when the world changes.

Use the expensive model to build the cheap one. Then put the expensive model away.