Learning Machines: Why I'm Rebuilding My ML Foundations in Public

I’ve been a software engineer for a while now. I can build APIs, design systems, ship products. But somewhere along the way, I realized something uncomfortable: I’ve been using AI without truly understanding it.

I’ve called APIs. I’ve fine-tuned models by following tutorials. I’ve dropped pre-trained weights into projects and watched them work. I’ve built with LLMs, wired up agents, and shipped features powered by models I couldn’t fully explain. But if you sat me down and asked me to explain backpropagation from first principles, or to walk through how an attention mechanism actually works, or to tell you why a particular model architecture was the right choice — I’d stumble. And that gap has started to bother me.

It’s a bit like driving a car you assembled from a YouTube tutorial. It runs. It gets you places. But you have no real idea what half the parts under the hood are doing, and you really don’t want to break down somewhere you can’t Google the answer.

So I’m going back to the beginning.

What This Series Is

Learning Machines is a series where I rebuild my AI and machine learning foundations from scratch — and share the process as I go.

Not a course. Not a tutorial series where I pretend to have it all figured out and hand you polished notes. This is closer to a lab notebook: raw, honest, sometimes messy. I’ll be working through concepts, writing about them to make sure I actually understand them, and publishing what I find along the way.

The scope covers two sides of the same coin. First: understanding how things actually work. Classical ML fundamentals, the math behind how models learn, what’s really going on inside LLMs and agentic systems beyond the API layer. Second: building and shipping them. MLOps, LLMOps, deployment pipelines, the operational reality of getting models into production and keeping them there. Theory without practice is academic. Practice without theory is guesswork. I want both.

I don’t have a rigid roadmap. I’m figuring out the path as I walk it. Some posts will be conceptual. Some might include code. Some might just be me wrestling with a concept until it clicks. The format will evolve as the learning does.

Why I’m Making This Transition

The honest answer is that it’s both strategic and personal.

Strategically: the industry is moving. Fast. ML and AI aren’t side features anymore — they’re becoming the core of how software works. I’ve watched the shift over the past few years, and I’d rather be building these systems than just consuming their outputs. Every engineering team I see is trying to hire someone who can do both: build software and build models. The transition from software engineer isn’t a pivot away from what I know. It’s a deepening of it. Everything I’ve learned about building reliable, scalable software still applies — it just needs new layers on top. Layers like model training, deployment pipelines, agent orchestration, and the operational infrastructure that keeps it all running.

Personally: there’s something about watching a model learn — actually learn — that scratches a part of my brain that regular software development doesn’t always reach. The intersection of math, data, and code producing something that can recognize patterns, generate language, reason through problems, and take autonomous action. That’s not just interesting to me. It’s the kind of problem space I want to spend the next chapter of my career in.

Why in Public

Here’s the thing — I never actually stopped writing. My Obsidian vault is full of notes, half-formed explanations, and concept breakdowns I wrote for myself while studying. I’ve been learning and documenting the whole time. But publishing? That stopped around my final exams, and I just… never picked it back up. Months went by. The notes kept piling up in private, and the blog went quiet.

That ends now.

I’ve written before about how building in public changed things for me. The accountability is real. When I know someone might read what I write, I can’t afford to half-understand something and move on. I have to sit with it. Explain it. Make it make sense on paper, not just in my head.

Writing is how I learn. It always has been. If I can explain a concept clearly, I know I actually understand it. If I can’t — if the explanation falls apart or I keep reaching for vague hand-waves — that’s my signal to go back and study it again.

This series is that process, made visible.

There’s another reason, though. I know I’m not the only engineer staring at this transition. If you’re a software developer who’s been curious about ML but never felt like you had the “right” background, or if you’ve tried learning it before and bounced off the math, or if you’ve been using these tools without fully understanding what’s happening underneath — this series is for you too. Not because I have the answers. Because I’m actively looking for them, and maybe working through it together is better than doing it alone.

An Honest Disclaimer

This series is a learning log, not a curriculum. I’m not qualified to write a “complete guide to machine learning” (yet), and I’m not going to pretend otherwise. If a concept takes me three readings to understand, I’ll say so. If I get something wrong, I’ll correct it.

What this is — is honest. I’ll share what clicks, what confuses me, and which resources actually helped versus the ones that just sounded good. The goal is simple: learn this properly, and bring anyone who’s interested along for the ride.

What’s Next

The next post in this series will get into actual content — the first real concept I’m working through. No spoilers on what it’ll be (mostly because I haven’t decided yet). But it’ll be the start of going from “I know this exists” to “I understand why it works.”

If you’ve been meaning to properly learn ML, or figure out what’s actually happening inside the tools you’re already shipping with — come along. I can’t promise I’ll have all the answers. I can promise I’ll be honest about the parts where I don’t.

The gap between using AI and understanding it doesn’t close itself. So I’m closing it — one post at a time, starting from the parts I should have learned first.