Rules vs ML vs DL vs LLMs

The decision tree, finally

After all the previous tracks, the right closing question is: when do you reach for which? Use rules when the logic is stable and auditable. Use classical ML when labels are abundant, the input is tabular, and the team needs a fast, inspectable artifact. Use deep learning when the input is naturally a tensor (image, audio, text) and you have enough data. Use LLMs when labels are scarce, instructions are easier than code, and 95% accuracy is enough.

Hybrid is usually the answer

Real systems mix all four. Rules for the known patterns. Classical ML for the long tail of tabular cases. Deep learning for embeddings on unstructured inputs. LLMs at the edges for explanation, summarization, or rare cases. The architectural skill is choosing which layer owns which case, not picking one tool for everything.

Closing rule

Always start with the simplest tool that could work. Add complexity only when the metric forces you to. Every layer of complexity is a maintenance debt that someone will pay later — usually you, after a vacation.

Code

Decision template a team can argue against·python

def choose(problem):
    if problem.is_stable_and_auditable:
        return "rules"
    if problem.is_tabular and problem.has_labels:
        return "classical_ml_lightgbm"
    if problem.is_perception:
        return "deep_learning"
    if problem.is_unstructured_text and problem.labels_scarce:
        return "llm_with_eval_set"
    return "clarify_problem_first"

Always carry the rule-based fallback·python

def serve(features, model, rule_fn, ok_to_use_model):
    rule_decision = rule_fn(features)
    if not ok_to_use_model() or rule_decision is not None:
        return rule_decision  # auditable path
    try:
        return model.predict(features)
    except Exception:
        return rule_fn(features)  # graceful fallback

The decision tree, finally

Hybrid is usually the answer

Closing rule

Code

External links

Exercise

Progress

Comments 2