After Finishing 'Hands-On Machine Learning': A Complete Roadmap to Becoming an AI Engineer

The Learning Plateau After Finishing a Classic Textbook

Almost everyone on the self-taught machine learning journey hits the same turning point: you finish a classic textbook — say, Aurélien Géron's Hands-On Machine Learning — and suddenly find yourself at a crossroads. You've built a solid mental framework for traditional ML, but when faced with higher-level concepts like RAG, LLMs, and generative AI, you have no idea where to begin.

A learner on Reddit recently raised exactly this question: they'd completed what many consider the definitive ML introductory text, were practicing on Kaggle (not to chase leaderboards, but to get comfortable coding independently without tutorials), and wanted to learn new concepts through real projects. Their core question: What should I learn next?

This question reflects a broader need that many AI learners face today — upgrading their knowledge architecture as they transition from "machine learning engineer" to "AI engineer."

The Knowledge Gap Between Traditional ML and Modern AI Engineering

The value of Hands-On Machine Learning is undeniable — it systematically covers supervised and unsupervised learning, neural network fundamentals, and hands-on applications with TensorFlow/Keras. But it's worth recognizing clearly: the book's knowledge framework is largely built on the technical paradigm from around the deep learning explosion, and its coverage of the generative AI wave powered by large language models is limited.

ML Engineer vs. AI Engineer: Two Diverging Technical Tracks

Today's AI practitioners generally split into two directions:

• Machine Learning Engineer: Focused on model training, feature engineering, data pipelines, model deployment, and optimization. Kaggle competitions are an ideal training ground for this path.
• AI Engineer: More focused on building applications on top of existing large models (like GPT, Claude, Llama), involving prompt engineering, RAG (Retrieval-Augmented Generation), agent orchestration, vector databases, and LLM application architecture.

The person asking the question clearly wants to move toward the latter — and it's a smart choice. Industry demand for engineers who can actually deploy LLMs to solve real problems is enormous, and these skills are precisely what traditional ML textbooks don't cover.

RAG (Retrieval-Augmented Generation) is one of the most central application paradigms in AI engineering today. The core idea: when querying a large language model, you first retrieve the most relevant document chunks from an external knowledge base and feed them as context to the model alongside your question. This grounds the model's responses in up-to-date, private, or domain-specific information rather than relying solely on knowledge baked in during training — addressing two major LLM pain points: knowledge cutoff dates and hallucinations. Vector databases (such as Chroma, FAISS, and Pinecone) are critical infrastructure for RAG systems: they convert text into high-dimensional numerical vectors (embeddings) and retrieve content via semantic similarity rather than keyword matching, enabling search that "understands meaning." Agents go a step further — giving LLMs the ability to autonomously plan and invoke external tools (search engines, code executors, APIs, etc.), upgrading models from "question-answering machines" to "agents capable of taking action."

A Layered Learning Roadmap for AI Engineers

Layer 1: Build a Solid Understanding of LLM Internals

Before diving into RAG and application development, it's worth filling in your understanding of the Transformer architecture. Here are a few free, high-quality resources:

• Andrej Karpathy's YouTube series: His "Let's build GPT" and "Neural Networks: Zero to Hero" series implement everything from scratch and are among the best materials available for understanding how LLMs work internally.
• 3Blue1Brown's neural network and Transformer visualization videos: Intuitive animations that explain the attention mechanism — great for building geometric intuition.

The goal here isn't to be able to train a GPT from scratch. It's to ensure that when you use large models, you're not treating them as a complete black box.

The Transformer architecture is the foundational prerequisite for understanding modern LLMs. Introduced by Google in the 2017 paper Attention Is All You Need, its key innovation is self-attention: it allows the model to simultaneously "attend" to all other positions in a sequence when processing each token, dynamically computing relevance weights. Compared to the previously dominant RNN/LSTM architectures, Transformers not only solve the long-range dependency problem but also support parallel computation natively — making training on massive datasets feasible. GPT series, BERT, LLaMA, and virtually all modern large models are built on Transformer variants. Understanding how the attention mechanism works helps you design better prompts, understand how models behave under different inputs, and make more informed decisions during fine-tuning.

Layer 2: Build Real LLM Application Projects

Once the concepts are clear, the most effective learning approach is still building projects. Here are some directions to start with:

• Build a RAG system: Create a "chat with your documents" application. The stack can be LangChain or LlamaIndex, paired with a vector database like Chroma or FAISS. This is the most direct hands-on project for understanding retrieval-augmented generation.
• Develop AI Agents: Try using Function Calling to enable the model to perform searches, calculations, and API calls.
• Fine-tuning practice: Once you have the basics down, use the Hugging Face ecosystem to try LoRA fine-tuning on smaller models.

Hugging Face's free courses (NLP Course, LLM Course) are high quality and stay current with the latest developments — highly recommended as the primary curriculum for this stage.

LoRA (Low-Rank Adaptation) is currently the most mainstream parameter-efficient fine-tuning method for large models. Full fine-tuning of a multi-billion-parameter LLM requires enormous GPU memory and compute, but LoRA's approach is elegant: freeze all original model weights, then insert a pair of low-rank matrices (with very few parameters) alongside specific layers. Only these small matrices are updated during training, and at inference time they're merged back into the original weights with no added latency. This makes task-specific customization of LLMs feasible on consumer-grade GPUs. Hugging Face's PEFT library encapsulates LoRA and its variants (such as QLoRA, which supports 4-bit quantization for further memory reduction), significantly lowering the engineering barrier to fine-tuning. For engineers looking to adapt LLMs to vertical domains (law, medicine, code generation), LoRA fine-tuning offers the best cost-to-performance ratio.

Layer 3: Maintain the Habit of Independent Coding

The person who asked the question mentioned deliberately reducing their reliance on tutorials and AI assistants on Kaggle — a habit worth strongly endorsing. In an era overflowing with AI coding tools, the ability to solve problems independently has actually become rarer and more valuable.

A reasonable approach: try implementing things yourself first, turn to AI hints only when stuck, and always go back to understand why the AI's solution works. Treat AI as a mentor you can ask anything, not a ghostwriter who codes for you.

Recommended Books and Courses

Beyond the resources above, here are a few more advanced materials worth attention:

• Designing Machine Learning Systems by Chip Huyen: Focused on ML system design and production deployment — fills the gap that textbooks leave on engineering in practice.
• Build a Large Language Model (From Scratch) by Sebastian Raschka: Walks you through implementing an LLM by hand, deeply filling in foundational understanding.
• DeepLearning.AI short course series: Free short courses produced by Andrew Ng's team in collaboration with major companies, covering RAG, Agents, LangChain, prompt engineering, and more. Compact and practical — perfect for getting up to speed quickly.

Practical Advice for Self-Taught ML Learners

Finally, it's worth emphasizing: the AI field evolves extremely fast. There's no need to fall into perfectionist anxiety about "finishing one book before moving on." A far more effective strategy is project-driven learning — identify gaps as you go and fill them in.

When you're building a RAG application and retrieval quality is poor, you'll naturally go research embedding models and document chunking strategies. When your Agent keeps making errors, you'll proactively study prompt optimization and evaluation methods. Learning driven by real problems is far more durable than working through a textbook chapter by chapter.

Graduating from Hands-On Machine Learning is just the beginning of a journey. Your traditional ML foundation will become solid bedrock for understanding modern AI — and what comes next is simply getting your hands dirty and putting LLMs to work in real projects.