How This Course Works (Prerequisites & Optional Primers)

You're oriented: you know what AI engineering is, who does it, what you can build, and how to think about it. This final welcome lesson is the practical part — what you need before you start, how the course is structured, and how to get the most out of it so the next ~280 lessons compound instead of overwhelm.

You'll learn:

• The prerequisites — what you need, what's helpful, and what you don't need
• Optional primers if you're rusty on a foundation
• The course roadmap — the seven sub-courses and how they build on each other
• The shape of every lesson — so you always know what to expect
• How to study this to actually become a great AI engineer

Good news, and we mean it: the bar is software engineering, not machine learning. If you can write a script, call an API, and read JSON, you're ready.

We use Python throughout (it's the lingua franca of AI). You don't need to be an expert — but if you've never programmed, do a short Python primer first; this course assumes you can read and modify simple Python. Everything AI-specific, we teach from scratch.

If a foundation feels shaky, brush up just enough — you don't need mastery:

• Python rusty? Spend an hour on functions, dictionaries, list comprehensions, and requests/SDK calls. That's 90% of what we use.
• Never touched ML? Perfect — you're the target audience. We teach the just-enough mental model of how models work (Section 2 next) without the heavy math. You will not need to derive backprop or train a network by hand.
• No API key yet? No problem — the upcoming dev-environment lesson walks you through installing the Anthropic & OpenAI SDKs, setting an API key, and making your first call.

Our promise: if a term is new, we define it on first use. You should never feel quietly lost. If you do, that's a bug in the lesson, not in you.

The course is seven sub-courses, each a coherent unit you could be proud to finish on its own — together a single beginner-to-production journey:

It's deliberately front-loaded with foundations — the early sections make everything later feel easy. The order isn't arbitrary; each part assumes the ones before it.

So you always know what to expect, every lesson follows the same rhythm — and the same principles:

• Concept first, with an analogy — we explain the why from first principles before any code (you've already seen "model as a new kind of CPU").
• A visual — a diagram or infographic for the core idea (we're visual-first; few courses are).
• Runnable code — real, copy-pasteable examples, provider-agnostic (primarily Claude and OpenAI), so you can run them yourself.
• First-principles → frameworks — we build things from scratch first, then show the framework that automates it, so your skills don't expire when tools change.
• Honest engineering — every lesson includes the tradeoffs, failure modes, and "when not to do this."
• Key takeaways — a tight recap to lock it in.

Lessons build on each other, so they're best done in order — especially the foundations.

Reading is not learning. To actually become an AI engineer:

1. Run the code. Don't just read it — execute every example, then break it and fix it. Hands beat eyes.
2. Build alongside. Pick one small idea of your own (a tool for your life) and apply each new lesson to it. By the capstones you'll have real experience, not just notes.
3. Adopt eval-first early. From your very first prompt, peek at a few real outputs and ask "is this actually good?" The habit (from last lesson) compounds.
4. Don't skip foundations. It's tempting to jump to agents — resist. The early sections are what make agents click later.
5. It's okay to revisit. Concepts deepen on a second pass; come back to a lesson after you've built something.

And a mindset note: don't compare your day-1 to someone's year-3. This field is young; everyone is learning. Consistent, hands-on practice is the entire game.

Run the readiness check on yourself. Rate the only four things that matter — calling an API, JSON, running a script, and Python basics — and get a personalized verdict: dive into Section 2, or do the one short primer that fills the gap.

The whole prerequisite bar is ordinary software skills. If something is rusty, that's a short primer — not a blocker — and everything model-specific, this course teaches from scratch. If all four are solid, you're ready for everything ahead.

Quick readiness check. Can you (a) call an HTTP/API from Python or JS, (b) read and write JSON, and (c) run a script from your terminal? If yes, you're ready for everything ahead — dive in. If one is shaky, that's the only prerequisite to shore up first (a 30-minute primer, not a prerequisite course). Everything model-specific, this course teaches from scratch.

• Prerequisite is software engineering, not ML: comfort with Python basics and APIs. No PhD, heavy math, or GPU required.
• Brush up just enough with the optional primers if needed — and trust that we define new terms as they appear.
• The course is seven sub-courses, front-loaded with foundations, taking you from beginner to production-ready.
• Every lesson follows the same shape: concept + analogy → visual → runnable code → honest tradeoffs → takeaways, first-principles before frameworks.
• Run the code, build alongside, adopt eval-first, and go in order — that's how this becomes skill.

Next: we go under the hood. Section 2 — From Tokens to Transformers — answers the question every great AI engineer can actually answer: how does a language model actually work? Starting with the deceptively simple idea of predicting the next token.