Zero to Top AI Engineer (2026): Full Series Plan

79 posts in two tracks. The Programming Track (Phase 1) is deep and optional for experienced developers. The AI Track (Phases 2 to 9) is the core.

Tags used in Phase 1: (core) = everyone reads it, (skippable) = skip if you already know it, (optional) = nice to have.

Phase 0: Orientation

1. What Is an AI Engineer in 2026? AI engineer vs ML engineer vs data scientist vs research scientist

2. The 12-Month Roadmap: the whole series at a glance, with reading paths and a week-by-week plan

3. How to Learn AI Faster: using AI as a tutor, building in public, avoiding tutorial hell

Phase 1: Programming in Depth

Track A: Python, Properly

1. Python Fundamentals: variables, types, control flow, how Python executes code (skippable)

2. Built-in Data Structures: lists, dicts, sets, tuples, and their time complexity (skippable)

3. Functions in Depth: scope, closures, *args/**kwargs, lambdas, higher-order functions (core)

4. Iterators, Generators & Comprehensions: the backbone of data pipelines and streaming LLM output (core)

5. Decorators & Context Managers: how FastAPI and PyTorch use them (core)

6. OOP the Practical Way: classes, dataclasses, composition vs inheritance, protocols (core)

7. Type Hints & Pydantic: why modern AI code is typed, and how structured outputs depend on it (core)

8. Errors, Logging & Debugging: exceptions, retries, pdb, reading stack traces (core)

9. Packaging & Environments: modules, pyproject.toml, uv/pip (core)

10. Testing with pytest: fixtures, mocking LLM calls, property-based testing (core)

11. Concurrency: threads vs processes vs asyncio, the GIL, and why LLM apps are async-heavy (core)

12. Performance & Memory: profiling, vectorization, how Python manages memory (core)

Track B: Computer Science Fundamentals

1. Data Structures for AI Engineers: arrays, hash maps, trees, graphs, heaps (skippable)

2. Algorithms You'll Actually Use: sorting, searching, recursion, dynamic programming, top-k, beam search (skippable)

3. Big-O Without the Fear: why complexity matters for vector search and batching (core)

4. How Computers Work: CPU vs GPU, memory hierarchy, processes, OS basics (core)

5. Networking & the Web: HTTP, REST, WebSockets, Server-Sent Events (how streaming works) (core)

6. Databases in Depth: SQL, indexes, transactions, Postgres, and when NoSQL makes sense (core)

Track C: Engineering Craft

1. Git & GitHub Workflows: branching, PRs, code review (core)

2. Linux, Shell & Docker: the daily toolkit (core)

3. Clean Code & Design Patterns: readability, refactoring, SOLID without the dogma (core)

4. TypeScript for AI Engineers: most AI products have a web frontend, and many agent SDKs are TypeScript-first (core)

5. Intro to C++/Rust: only what you need to read performance-critical AI code (optional)

Phase 1 Projects

1. Mini Project 1: a CLI tool, such as a markdown note searcher

2. Mini Project 2: a REST API with tests, Docker, and CI

3. Capstone: a small Python library published on PyPI

4. 30-Day DSA Practice Plan: and an honest take on how much LeetCode you actually need

Phase 2: Math & Data for AI

1. Linear Algebra with Intuition: vectors, matrices, dot products, and why embeddings work

2. Calculus & Gradients: derivatives, the chain rule, gradient descent

3. Probability & Statistics: distributions, Bayes, expectation, and why loss functions look the way they do

4. NumPy in Depth: broadcasting, vectorization, memory layout

5. Pandas & Polars: cleaning, joins, group-bys, and when to pick which

6. EDA & Data Visualization: Matplotlib and plotting that answers questions

7. Project: an end-to-end data analysis notebook published on GitHub

Phase 3: Machine Learning & Deep Learning

1. Classical ML in a Weekend: scikit-learn, regression, trees, cross-validation, metrics

2. Neural Networks from Scratch: backprop in pure NumPy

3. PyTorch Crash Course: tensors, autograd, training loops

4. Why Your Model Isn't Learning: a debugging checklist for overfitting, bad data, and learning rates

5. Project: an image or text classifier, trained and evaluated

Phase 4: Transformers & LLMs Under the Hood

1. Tokenization Explained: build a BPE tokenizer

2. Attention, Line by Line: implement self-attention yourself

3. Build a Mini-GPT from Scratch: a nanoGPT-style walkthrough

4. How LLMs Are Trained: pretraining, SFT, preference tuning (RLHF/DPO), RL with verifiable rewards

5. Reasoning Models & Test-Time Compute: what changed and why it matters

6. KV Cache, Context Windows, and MoE: the concepts behind inference behavior

Phase 5: Building with LLMs (the core of the job)

1. Your First LLM App: API calls, streaming, structured outputs

2. From Prompt Engineering to Context Engineering

3. Tool Use & Function Calling

4. Embeddings & Vector Search: how they work, not just which database to pick

5. RAG from Scratch

6. Advanced RAG: chunking, hybrid search, reranking

7. Build an Agent Loop Without a Framework

8. MCP Explained: build your own MCP server

9. Agent Memory & Multi-Agent Systems: when they help and when they're overkill

10. Voice & Multimodal Apps: vision, speech, real-time

11. Project: a deployed RAG or agent app with a public demo

Phase 6: Evaluation, Safety & Reliability

1. Evals: The Most Underrated AI Engineering Skill: build a test set, track regressions

2. LLM-as-Judge: where it works, where it lies

3. Observability & Tracing for AI Apps

4. Prompt Injection & Security: guardrails, sandboxing, least-privilege agents

Phase 7: Customizing Models

1. Prompt vs RAG vs Fine-Tune: a decision framework

2. Fine-Tune an Open Model with LoRA/QLoRA (hands-on)

3. Synthetic Data & Distillation: getting small models to punch above their weight

4. Intro to RL Fine-Tuning for Reasoning and Agents

Phase 8: Production & Scale

1. Shipping LLM Apps: FastAPI, queues, caching, rate limits, cost control

2. Inference Optimization: quantization, batching, vLLM, speculative decoding

3. GPU & CUDA Basics for AI Engineers: what to know without becoming a kernel engineer

4. Cloud, Kubernetes & CI/CD for AI: versioning prompts, models, and evals

Phase 9: Career & Becoming Top-Tier

1. 10 Portfolio Projects That Actually Get You Hired

2. Resume, GitHub & LinkedIn for AI Engineers

3. AI Engineering Interviews: coding, ML fundamentals, and AI system design

4. How to Read Research Papers and reproduce one

5. Contributing to Open Source: your first PR to an AI library

6. Choosing a Specialization: agents, evals, inference infra, applied research, AI safety

7. Junior to Senior to Staff: tradeoff thinking, product sense, and owning ambiguity

8. Staying Current Without Burning Out: a sustainable weekly learning routine

Reading Paths

(for post 2)

Extras

• Standalone bonus posts: "AI Engineer Salary & Job Market Report," "Best Free Resources Ranked," "Mistakes I Made Learning AI," "Open vs Closed Models: How to Choose."

• Post template: the problem, the concept, the code, a mini-project, and a "next in series" link. This helps SEO and keeps readers moving.

• Freshness: teach concepts first, and keep tool-specific posts (49 to 56, 68, 69) clearly dated and easy to update, since tools and model names change every few months.