Learn AI Series (#156) - What's Next: Your AI Journey

What will I learn?

You will learn how far you've come across 156 episodes and what that knowledge actually means;
the four honest paths forward - research, engineering, product, domain - what each one demands and how to pick;
how to contribute back to the community and why that is the highest-leverage learning you can do;
the open problems worth caring about, the ones that could define the next decade;
AI as a craft: the mindset of deliberate practice over chasing every shiny new paper;
a personal, honest word on what makes this field worth staying in.

Requirements

A working modern computer running macOS, Windows or Ubuntu;
155 episodes of context behind you. You've earned this one.

Difficulty

Advanced

Curriculum (of the `Learn AI Series`):

Learn AI Series (#156) - What's Next: Your AI Journey

This is episode 156. The last one.

When I sat down to write episode #1, the goal was embarrassingly simple: explain machine learning from absolute zero in a way that respects your intelligence. Not dumbed down. Not hand-wavy. Not "trust me, it works" -- but "here is WHY it works, here is the math, here is the code, and here is what it actually means when the hype gets stripped away."

Did I pull it off? That is genuinely not for me to say -- that is for you to judge. But I will say this much: if you followed along, even partially, even just the arcs that happened to grab you, you now have a foundation that a frightening number of people with "AI Engineer" in their LinkedIn headline simply do not have. You built things from scratch before you reached for the libraries. You know what the libraries are doing under the hood. That is rare, and (trust me on this) it matters more every single year.

Let me use this final episode not to teach one more algorithm, but to be honest with you about where things stand, where they are heading, and what I think you should actually do with all of this. Here we go, one last time.

What you actually know now

Let's be concrete about it, because vague reassurance helps nobody. After 156 episodes, this is genuinely in your hands:

# Not a to-do list. An inventory. Read it slowly -- you can DO all of this now.
what_you_can_do = {
    "build_from_scratch": [
        "linear + logistic regression, gradient descent by hand (#6-12)",
        "a neural network with full backprop, no framework (#37-39)",
        "a transformer: attention, multi-head, positional encoding (#51-53)",
        "an executor, a bytecode VM's cousin -- the training loop itself (#7)",
    ],
    "use_effectively": [
        "scikit-learn for classical ML (#16)",
        "PyTorch for deep learning (#42-44)",
        "Hugging Face for pretrained everything (#74)",
        "XGBoost / LightGBM for the tabular data that pays the bills (#19)",
        "FAISS / Chroma for vector search (#63)",
        "FastAPI + monitoring to keep a model alive in prod (#121, #123)",
    ],
    "reason_about": [
        "when accuracy LIES to you (#13)",
        "bias-variance, overfitting, regularization (#11, #40)",
        "drift, robustness, and why lab models die in the wild (#123)",
        "security, privacy, fairness, and the ethics of what you ship (#127-128, #149)",
    ],
}

for skill_class, items in what_you_can_do.items():
    print(f"{skill_class}: {len(items)} things you couldn't do 156 episodes ago")

That is not nothing. That is a serious foundation, and I do not use that word lightly. Most people who claim this field never build the perceptron by hand (#37). You did. You understand attention not as a magic word but as three matrices and a softmax (#51). That understanding does not evaporate when the next model architecture trends on the timeline -- it is the thing that lets you read that new architecture in an afternoon in stead of a week.

The four ways forward

Episode #152 gave you the skill tree. Here I want to be more honest and more blunt about the four real directions, because each one asks something different of you, and picking wrong wastes years.

ML Engineer / MLOps. You like building systems more than you like tuning models. The model is one component; the machinery around it -- pipelines, serving, monitoring, automation -- is where you create value. This path is in absurdly high demand, because almost every organisation on earth has more model ideas than it has engineering capacity to actually deploy them. Start by deploying one real thing, however small. Keeping a model alive in production for six months will teach you more than any course ever could.

Research / Science. You want to push the frontier itself. This usually means a PhD or a lab position, and I will not sugarcoat it: academic ML research is brutally competitive. Thousands of very smart people fighting over the same conference slots, often with compute you simply cannot match. If this is your path, find a niche. The big labs will always beat you on scale -- so beat them on insight, on a novel problem formulation, on some domain they cannot be bothered to care about. Your math episodes (#8-9) and every from-scratch build (#37-39, #52-53) were the preparation.

Domain Expert / Applied AI. You carry AI into a specific field -- healthcare, agriculture, law, finance, climate, manufacturing. This, I would argue, is where the most real-world impact actually lives. The bottleneck in these domains is almost never raw AI capability; it is finding the person who understands BOTH the domain and the AI deeply enough to connect them. A mediocre model aimed at exactly the right problem with the right data beats a state-of-the-art model aimed at the wrong one. Every time.

Product / Entrepreneurship. You build things people actually use. This fuses technical chops with product sense, user empathy, and a bit of business instinct (episode #153 covered the ground floor). The skill here is emphatically NOT building the best model -- it is spotting the problems where AI creates genuine value and then building the simplest system that delivers it. Most successful AI products are, technically, almost embarrassingly boring.

So how do you choose? You do not choose from the paths -- you choose from yourself. Answer honestly:

def which_path_fits_you(you):
    """
    Not a personality quiz. An honesty check. There are no wrong answers,
    only dishonest ones. Pick the row that makes you nod, not the one
    that sounds impressive at a party.
    """
    signals = {
        "ml_engineer": you["energised_by"] == "making things run reliably",
        "researcher":  you["energised_by"] == "not knowing the answer yet",
        "domain":      you["energised_by"] == "a field you already love that isn't AI",
        "product":     you["energised_by"] == "someone using the thing you made",
    }
    fits = [path for path, matches in signals.items() if matches]

    if len(fits) == 1:
        return f"Go deep on: {fits[0]}. Stop shopping. Start building."
    if len(fits) > 1:
        return f"Lucky you -- {fits}. Pick one for TWO YEARS, then reassess."
    return "None lit up? You're not ready to specialise. Build three more projects first."

print(which_path_fits_you({"energised_by": "someone using the thing you made"}))
# -> Go deep on: product. Stop shopping. Start building.

Nota bene: you do not have to pick forever. You pick for a couple of years, you go deep enough to actually be good, and then you reassess with real information in stead of a beginner's guess. The mistake is not picking the "wrong" path -- it is refusing to commit to any path and staying a permanent tourist across all four.

Contributing to the community

Here is a thing I want you to sit with for a second. This entire series -- 156 episodes of it -- exists ONLY because thousands of people, over decades, shared what they knew for free. Papers on arXiv. Code on GitHub. Answers on forums at 2am from strangers who got nothing for it. The whole field advances because knowledge flows freely, and I mean that almost literally: closed knowledge rots, open knowledge compounds.

You can pay into that pool at any level, and (this is the part people miss) the paying-in is selfishly good for you too:

# Ranked by leverage. Notice the top of the list isn't "give more" --
# it's "give in a way that also teaches YOU the most".
contribution_ladder = [
    ("teach it", "highest leverage -- you discover your own gaps by explaining"),
    ("write what you built", "the honest 'here's what actually broke' post nobody writes"),
    ("reproduce a paper", "undervalued, vital -- if it doesn't reproduce, we NEED to know"),
    ("open-source a tiny tool", "a loader, a script -- if it saved you time it saves others"),
    ("answer questions", "solidifies your own understanding, every single time"),
]

def leverage_of(activity):
    # Teaching sits on top because it forces total clarity. You cannot
    # teach a thing you only 70% understand -- the gaps show instantly.
    return len(contribution_ladder) - [a for a, _ in contribution_ladder].index(activity)

for activity, why in contribution_ladder:
    print(f"[{leverage_of(activity)}] {activity}: {why}")

The community is drowning in "how to do X" tutorials. What it is starving for is honest accounts of "I tried to do X and here is what actually happened, including the three days I lost to a shape mismatch." Write THOSE. Reproduce a paper and publish the result even -- especially -- when it does not reproduce. Answer the stuck beginner on the forum, because six months ago that beginner was you, and someone answered.

And teaching? Teaching is the cheat code. I have learned more from writing these 156 episodes than from any 156 papers I have read, because you cannot fake your way through explaining something clearly. Every time I sat down to write an episode and realised I could not explain a piece of it simply, that was the field politely informing me that I did not actually understand it yet. Painful. Invaluable.

Open problems worth caring about

The field moves fast, yes, but do not mistake speed for solvedness. Several genuinely fundamental problems remain wide open. If you want to work on something that matters, here is where I would point you:

# Open problems, scored by how much I think they matter and how hard
# they are. High impact + high difficulty = career-defining if you crack
# even a corner of it. These are not solved. Do not let anyone tell you
# otherwise ;-)
open_problems = {
    "reasoning":         {"impact": 10, "difficulty": 10, "ref": "#142"},
    "sample_efficiency": {"impact": 9,  "difficulty": 9,  "ref": "#144"},
    "robustness":        {"impact": 9,  "difficulty": 8,  "ref": "#127"},
    "alignment":         {"impact": 10, "difficulty": 10, "ref": "#147"},
    "energy_efficiency": {"impact": 8,  "difficulty": 7,  "ref": "#150"},
    "accessibility":     {"impact": 8,  "difficulty": 6,  "ref": "#148"},
}

def worth_a_decade(problem):
    p = open_problems[problem]
    return p["impact"] + p["difficulty"] >= 18  # both high, not just one

for name in open_problems:
    verdict = "career-defining" if worth_a_decade(name) else "very worth it"
    print(f"{name:20s} -> {verdict}")

Let me put a little flesh on the two I lose sleep over.

Reasoning. Today's best systems -- and I mean the very best -- pattern-match at a level that genuinely astonishes, and then fall flat on their face on a novel logic puzzle a bright ten-year-old handles without breaking stride. Deliberate, step-by-step reasoning over genuinely new problems is not solved. Episode #142 covered the techniques people are throwing at it. It remains wide open, and whoever makes real progress here changes everything downstream.

Alignment. As these systems get more capable, making sure they do what we actually mean -- not the literal thing we typed, not the reward we accidentally specified, but the thing we wanted -- becomes the whole ballgame. Episode #147 introduced the problem. It is not solved. I would argue it is the single most important unsolved problem in the field, and it is not close.

The others -- sample efficiency (humans learn from a handful of examples; our models need millions), robustness (perfect in the lab, brittle in the rain), energy (training one big model can burn a year of a household's electricity), accessibility (the best tools are hoarded by the wealthiest labs) -- every one of them is a genuine, open, worth-your-life problem. Pick one. You are qualified to at least understand it now, which is more than most.

AI as a craft

Now for the part that never, ever makes it onto a conference slide, and it is the part I most want you to leave with.

This is a craft. It is not a pile of tools. It is not a stack of papers. It is not a race to nudge a benchmark number by 0.3%. It is a craft in exactly the way woodworking is a craft, or cooking, or writing prose, or -- yes -- writing code. You get better by doing it, consistently, over years. By studying what the people before you did. By building things and watching, honestly, how they hold up under real load. By being ruthlessly clear-eyed about your own mistakes rather than hiding them.

# The loop that actually makes you good. There is no shortcut around it.
# Notice: 'read_the_new_paper' is NOT in here as step one. Building is.
def deliberate_practice(you, years):
    skill = you["skill"]
    for _ in range(years * 52):          # week by week, not paper by paper
        project = pick_slightly_too_hard()   # just past your current reach
        result = build(project)              # it will break. good.
        gap = honestly_diagnose(result)      # where did I actually fail?
        skill = study_that_specific_gap(skill, gap)  # targeted, not random
        share_what_broke(result)             # teaching = compounding (see above)
    return skill

# The trap most people fall into instead:
def tutorial_hell(you, years):
    for _ in range(years * 52):
        watch_another_video()   # feels like progress. isn't.
    return you["skill"]         # unchanged. ouch.

The people who are genuinely, durably good at this -- the ones who ship systems that work and last -- are almost never the ones sprinting after every new paper and trend. They are the ones who understand the fundamentals so deeply that new things slot in easily. They can tell you, from scar tissue, exactly when a gradient-boosted tree will quietly demolish a neural network on a specific problem (#19 vs #44). They can glance at a loss curve and diagnose the issue without reading a line of the code (#40). They know, in their bones, when a problem needs more data, a better model, or a completely different framing.

That intuition does not come from reading 156 episodes. It comes from building, failing, debugging at 3am, and building again. Having said that -- the episodes were never meant to be the destination. They handed you the tools and the understanding. The craft only comes from using them, badly at first, then less badly, then well.

The habit that outlasts the hype

Let me give you one more thing, because a craft needs a practice, and a practice needs a habit. The field will keep throwing new things at you forever. You cannot -- and should NOT try to -- chase all of them. Here is the filter I actually run:

def should_i_learn_this_new_thing(thing):
    """Run this before diving into the shiny new model of the week.
    Most 'revolutionary' releases fail the second check quietly."""
    # 1. Is it built on fundamentals you already own?
    if thing["reducible_to"] in ("attention", "gradient_descent", "bayes_rule"):
        return "SKIM the paper -- you already understand 80% of it (#52, #6, #32)"
    # 2. Does it solve a problem you ACTUALLY have right now?
    if not thing["solves_a_problem_i_have"]:
        return "BOOKMARK it. Learning it now is procrastination in a lab coat."
    # 3. New primitive, real need -> this is the rare one worth the deep dive.
    return "LEARN it properly -- build the smallest version by hand first."

print(should_i_learn_this_new_thing(
    {"reducible_to": "attention", "solves_a_problem_i_have": False}
))
# -> SKIM the paper -- you already understand 80% of it (#52, #6, #32)

Most of what trends is the third thing dressed up as the first -- a familiar idea (attention, gradient descent, Bayes' rule) in a new coat, marketed as a revolution. Because you built the primitives by hand, you can undress it in an afternoon and get on with your actual work. That, quietly, is the superpower this whole series was aiming at: not knowing every model, but being un-intimidated by any of them.

Your next thirty days

Enough philosophy -- let me give you something you can DO, starting tomorrow, because a foundation that just sits there is a foundation that quietly crumbles. Reading is not doing, and the gap between the two is where 90% of people stall out (I have watched it happen to quit some talented folks over the years). So here is a concrete, unglamorous, month-long plan. Steal it, adapt it, ignore the parts that do not fit -- but do something shaped like it:

# Not aspirational. Executable. Print it, tape it to your monitor.
# The goal of week one is not a good project -- it's a FINISHED one.
next_thirty_days = {
    "week_1": "Ship ONE tiny end-to-end thing. Ugly is fine. Finished beats perfect.",
    "week_2": "Deploy it so a stranger can hit it. A URL. Watch it break in the wild (#121).",
    "week_3": "Write the honest post: what worked, what broke, what you'd redo (#153).",
    "week_4": "Pick your path (see above) and start project #2 -- one notch harder.",
}

def am_i_actually_progressing(log):
    # The only metric that matters here. Not videos watched. SHIPPED.
    shipped = sum(1 for entry in log if entry["status"] == "shipped")
    if shipped == 0:
        return "You're consuming, not building. Close the tabs. Open an editor."
    return f"{shipped} shipped. THAT is momentum. Keep the streak alive ;-)"

print(am_i_actually_progressing([{"status": "shipped"}, {"status": "shipped"}]))
# -> 2 shipped. THAT is momentum. Keep the streak alive ;-)

Notice what week one is NOT: it is not "read three more papers", it is not "watch a course on the new framework", it is not "wait until you feel ready" (you will never feel ready -- nobody does, myself included). It is ship one finished thing. Small. Complete. Yours. The finishing is the whole lesson, because finishing is the skill almost nobody practices and everybody needs.

The honest ending

I am not going to stand here and tell you that you are now an "AI expert." Real expertise takes years of practice on real problems that fight back, and no series on earth substitutes for that. What you have is a foundation -- solid, honest, build-it-from-scratch-before-you-import-it foundation that will serve you no matter which way the field lurches next.

And it WILL lurch. Techniques that feel central today will be museum pieces in five years (some of the frontier stuff from episode #150 already ages by the month). New breakthroughs will reshape what is possible. But look at what does not move:

# The half-life test. Things fade at wildly different rates. Invest
# your deepest attention where the half-life is measured in decades,
# not months. This is where I'd spend 80% of my learning time.
half_life = {
    "gradient descent":        "decades",   # #6-7  -- bedrock
    "probability & linear algebra": "forever",  # #8-9  -- literally math
    "the training loop":       "decades",   # #7    -- shape never changes
    "evaluation discipline":   "decades",   # #13   -- 'accuracy lies' is eternal
    "architectural thinking":  "decades",   # #155  -- the real meta-skill
    "this week's SOTA model":  "months",    # trending now, gone by spring
    "a specific API's syntax":  "a year, tops",
}

invest_deeply_in = [k for k, v in half_life.items() if v in ("forever", "decades")]
print("Where to spend your best hours:", invest_deeply_in)

The fundamentals -- gradient descent, probability, linear algebra, the training loop, evaluation methodology, architectural thinking -- those do not change. They are the bedrock under all the churn. And you have them. That is the whole reason I spent so long, so stubbornly, making you build things by hand before letting you touch a library. The libraries change. What they are doing does not.

So here is my actual, final, no-hype advice. Go build something. NOT something designed to impress other ML engineers on the timeline. Something that helps an actual person. Something that works. Something you are proud of -- not because it is technically sophisticated, but because it quietly does the thing it was supposed to do, day after day, without drama.

That was always the whole point.

What to remember from this one

You can build the core of modern AI from scratch AND use the real tools -- that combination is genuinely rare, protect it;
there are four honest paths (engineering, research, domain, product) -- pick from yourself, commit for a couple of years, then reassess with real data;
contributing back (teaching most of all) is the highest-leverage learning you will ever do -- the community is starving for honest "here's what broke" writing;
the big problems (reasoning, alignment, sample efficiency, robustness, energy, accessibility) are open, real, and worthy of a career -- you are now qualified to at least understand them;
treat AI as a craft: deliberate practice on slightly-too-hard projects beats chasing every trending paper;
invest your deepest hours in the long-half-life fundamentals -- the SOTA model of the week fades, gradient descent does not.

Bedankt, en tot ziens.

156 episodes. If you read even a fraction of them, respect -- genuine, unqualified respect. This was a LONG ride and I appreciate every single person who stuck around for it. If you got value here, the best way to pay it forward is to help someone else learn what you now know. The field needs more people who understand the foundations, not more people who can prompt an API and hope. Keep building. Keep learning. Keep sharing. ;-)

@scipio

Learn AI Series (#156) - What's Next: Your AI Journey

Learn AI Series (#156) - What's Next: Your AI Journey

What will I learn?

Requirements

Difficulty

Curriculum (of the Learn AI Series):

Learn AI Series (#156) - What's Next: Your AI Journey

What you actually know now

The four ways forward

Contributing to the community

Open problems worth caring about

AI as a craft

The habit that outlasts the hype

Your next thirty days

The honest ending

What to remember from this one

Curriculum (of the `Learn AI Series`):