The reader’s guide

A working developer's path into AI and machine learning.

The short version. Eight core chapters take you from shipping software to shipping AI systems in about 450 hours. A ninth applied chapter covers offer recommendation, price recommendation and churn, with model choices and a full business decision workflow. You build on one thread — one dataset becomes one model becomes one AI product. Each chapter has a practical plan and a resources folder for deeper reading.

Contents

The chapters

1. Getting oriented  ·  resources
2. Data foundations  ·  resources
3. Core machine learning  ·  resources
4. Deep learning  ·  resources
5. Language models and AI engineering  ·  resources
6. Running it in production  ·  resources
7. Choosing a specialisation  ·  resources
8. Finding the work  ·  resources
9. Business machine learning: offers, prices and churn  ·  resources

Applied guides

• Model-selection decision trees
• Offer recommendation
• Price recommendation
• Churn prediction and retention
• Shared delivery plan and completion gates

Before you start

• Who this book is for
• How to read this book
• Start here: your first week
• The path at a glance
• One thread through the whole book
• How much time it takes
• How each chapter works
• Using AI assistants while you learn

Reference

• Terms in plain English
• Projects, in order of difficulty
• Common pitfalls
• Where thoughtful people disagree
• Keeping this book current
• A note from the author

Who this book is for

This is written for someone who already writes software. You use Git, you call APIs, you have deployed something, and you can read a stack trace without panic. What you want is a clear route into machine learning and AI engineering, without spending six months on material that turns out to be out of date.

If you are not yet programming, this book will be hard going. From a standing start, add a substantial programming stage before these chapter budgets. A planning allowance of 1,000 to 1,500 total hours is an estimate, not a measured completion time or a job guarantee. CS50P is an excellent place to begin, and this book will still be here afterwards. You will move through it much faster.

A word on what this can and cannot promise. It is a well-researched, carefully checked path, and I think it is a good one. It is not the only good one, and it will not fit everyone. Where the evidence is genuinely mixed, I have tried to say so rather than sound more certain than I am.

How to read this book

Follow the core chapters in order. Chapter 9 is an applied track after Chapters 3 and 6. Use one guide as your Chapter 7 capstone, or work through all three afterwards. Everything optional is marked as optional. When you are unsure what to do next, do the next thing on the list. Most roadmaps offer a branching menu, and that turns out to be part of the problem: a long list of choices is easy to browse and hard to finish.

Build something in every stage. Dunlosky and colleagues' 2013 review rated practice testing and distributed practice highly across the learning conditions it examined. Re-reading and highlighting were less useful overall. Roediger and Karpicke's 2006 experiments found that recalling studied text, rather than studying it again, helped people remember it later. Neither study tests a software curriculum directly. This book applies their ideas: explain from memory, space out sessions, and build the key exercise with the tutorial closed. Then use your references to check and correct the result.

Keep a short log. One file, one line per session: the date, the hours, what you built, and what broke. It gives you a way to revise, and it is a genuinely good answer when someone asks how you learned all this.

Give yourself room. The plan below assumes ten to twelve hours a week, not twenty. A slower plan you finish is worth more than a faster one you abandon, and there is no prize for rushing.

Find one place to ask questions. You will get stuck, and a stuck hour with no one to ask is how most self-study ends. Pick one community early and use it: the fast.ai forums, the DataTalks.Club Slack, or the Hugging Face forums are all free, active and kind to beginners. Ask with what you tried and what you saw. That habit is itself a skill people hire for.

When you feel lost, do this: open the chapter you are on, find the week plan near the top, and do only that week's row. Use the resource list to look things up, not to hunt for a better next hour.

Start here: your first week

If eight chapters and forty-four weeks feel like a lot, start smaller. Week 0 is eight hours. You do not need to understand machine learning yet. You need a target role, a public repo, a log file, and a notebook that runs. The day-by-day plan for that week is at the top of Chapter 1.

End of week 0: you have a public repo, a log, a role, and Colab working. Open Chapter 2 and follow Week 1 of its plan.

The path at a glance

The diagram shows the order. The table gives each chapter’s time budget and outcome. Start Chapter 8 alongside Chapter 6 in week 33. Chapter 9 is an applied extension after Chapters 3 and 6, and can be your Chapter 7 capstone.

%%{init: {"theme":"base","themeVariables":{"fontFamily":"Arial, sans-serif","fontSize":"16px","textColor":"#17324D","primaryColor":"#F5F7FA","primaryTextColor":"#17324D","primaryBorderColor":"#8796A8","lineColor":"#718096","secondaryColor":"#EFF6FF","tertiaryColor":"#E9F6F2","clusterBkg":"#F8FAFC","clusterBorder":"#D6DEE8","edgeLabelBackground":"#FFFFFF"},"flowchart":{"htmlLabels":true,"nodeSpacing":18,"rankSpacing":28,"curve":"linear","padding":10,"subGraphTitleMargin":{"top":8,"bottom":12}}}}%%
flowchart TB
    accTitle: The core learning path
    accDescr: Complete foundations, machine learning and AI engineering in order, then choose one specialisation. Job search begins alongside production in week 33.
    F["Foundations<br/>Ch 1–2 · weeks 0–5"]
    M["Machine learning<br/>Ch 3–4 · weeks 6–22"]
    E["AI engineering<br/>Ch 5–6 · weeks 23–37"]
    S{"Choose one role<br/>Chapter 7"}
    A["AI<br/>Engineer"]
    B["ML<br/>Engineer"]
    C["Data<br/>Scientist"]
    F --> M --> E --> S
    S --> A
    S --> B
    S --> C
    classDef data fill:#EFF6FF,stroke:#3973AC,color:#17324D,stroke-width:1.5px
    classDef model fill:#EFF2FD,stroke:#596FC2,color:#17324D,stroke-width:1.5px
    classDef decision fill:#FFF5DF,stroke:#A8751A,color:#17324D,stroke-width:1.5px
    classDef action fill:#E9F6F2,stroke:#23866E,color:#17324D,stroke-width:1.5px
    classDef neutral fill:#F5F7FA,stroke:#8796A8,color:#17324D,stroke-width:1.5px
    class F data
    class M model
    class E action
    class S decision
    class A,B,C neutral

One thread through the whole book

You are building one connected project. One dataset becomes one model becomes one AI product. That is an end-to-end story an interviewer can follow in five minutes.

%%{init: {"theme":"base","themeVariables":{"fontFamily":"Arial, sans-serif","fontSize":"16px","textColor":"#17324D","primaryColor":"#F5F7FA","primaryTextColor":"#17324D","primaryBorderColor":"#8796A8","lineColor":"#718096","secondaryColor":"#EFF6FF","tertiaryColor":"#E9F6F2","clusterBkg":"#F8FAFC","clusterBorder":"#D6DEE8","edgeLabelBackground":"#FFFFFF"},"flowchart":{"htmlLabels":true,"nodeSpacing":18,"rankSpacing":28,"curve":"linear","padding":10,"subGraphTitleMargin":{"top":8,"bottom":12}}}}%%
flowchart LR
    accTitle: One project, developed across the book
    accDescr: Your Chapter 2 data becomes a model in Chapters 3 and 4, then an AI product in Chapters 5 and 6.
    D["Data<br/>Ch 2"] --> M["Model<br/>Ch 3–4"] --> P["AI product<br/>Ch 5–6"]
    classDef data fill:#EFF6FF,stroke:#3973AC,color:#17324D,stroke-width:1.5px
    classDef model fill:#EFF2FD,stroke:#596FC2,color:#17324D,stroke-width:1.5px
    classDef decision fill:#FFF5DF,stroke:#A8751A,color:#17324D,stroke-width:1.5px
    classDef action fill:#E9F6F2,stroke:#23866E,color:#17324D,stroke-width:1.5px
    classDef neutral fill:#F5F7FA,stroke:#8796A8,color:#17324D,stroke-width:1.5px
    class D data
    class M model
    class P action

The same project grows. The table shows what each chapter adds.

For the business cases, a connected retail or subscription thread can start with transaction and customer snapshots, move to demand or churn prediction, add a document feature over product or support policies, and end with an offer, price or retention policy and measured feedback. Choose that domain early if Chapter 9 is your goal. For intervention exercises, public transaction data usually needs clearly labelled synthetic exposure and assignment data. Do not invent evidence that real discounts or prices caused the observed purchases.

Pick a domain you care about in Chapter 2 and stay with it until Chapter 6 at least. If you change datasets every chapter, you will finish tired and with nothing coherent to show.

How much time it takes

The week ranges in the roadmap are planning windows. The job search overlaps Chapters 6 and 7, because it takes several months and starting early tells you a lot. It adds three to four hours a week on top of the chapter hours, so weeks 33 to 43 are the fullest in the book. If that is too much, slow the chapters down rather than skipping the search.

About the hour figures. These are your hours on each chapter, assuming you use each resource as described rather than finishing it end to end. Several listed courses are much longer than the chapter that mentions them. Where that matters, the chapter says which parts to do. The resource tables give each item's full length, so those numbers are often larger. That is expected, not a contradiction.

The applied extension has its own budget. Chapter 9 adds about 40 hours for one case or 90 for all three, including shared data and delivery work. The original core estimates total 453 hours, not counting the parallel job search. The core schedule covers 44 calendar weeks: orientation week 0 plus weeks 1–43. Doing all of Chapter 9 afterwards makes it 543 hours, or roughly eight to nine extra weeks at 10–12 hours per week. If one case doubles as Chapter 7's 30-hour capstone, count those hours once. The practice budgets leave out waiting for real churn labels or for a properly powered live experiment to finish.

Allow extra calendar time for the job search. Four to eight months is a planning buffer, not a median estimate or a forecast for you. Location, experience, work authorisation, target level and hiring conditions can change it greatly. Chapter 8 shows how to adjust the plan using current postings and your own application funnel. Bootcamp cohort reports do not show how long AI/ML searches take in general.

How each chapter works

Every chapter runs on the same loop.

%%{init: {"theme":"base","themeVariables":{"fontFamily":"Arial, sans-serif","fontSize":"16px","textColor":"#17324D","primaryColor":"#F5F7FA","primaryTextColor":"#17324D","primaryBorderColor":"#8796A8","lineColor":"#718096","secondaryColor":"#EFF6FF","tertiaryColor":"#E9F6F2","clusterBkg":"#F8FAFC","clusterBorder":"#D6DEE8","edgeLabelBackground":"#FFFFFF"},"flowchart":{"htmlLabels":true,"nodeSpacing":18,"rankSpacing":28,"curve":"linear","padding":10,"subGraphTitleMargin":{"top":8,"bottom":12}}}}%%
flowchart TB
    accTitle: The learning loop used in each chapter
    accDescr: Learn and practise with a reference, wait a day, build with the tutorial closed, compare and correct, then explain from memory. Revisit the exercise if you cannot explain it.
    L["Learn + practise<br/>One guided exercise"]
    W["Wait a day"]
    B["Build from memory<br/>Tutorial closed"]
    R["Compare + correct<br/>Reference open"]
    C{"Explain it<br/>without notes?"}
    N(["Next chapter"])
    L --> W --> B --> R --> C
    C -->|Yes| N
    C -.->|Revisit| L
    classDef data fill:#EFF6FF,stroke:#3973AC,color:#17324D,stroke-width:1.5px
    classDef model fill:#EFF2FD,stroke:#596FC2,color:#17324D,stroke-width:1.5px
    classDef decision fill:#FFF5DF,stroke:#A8751A,color:#17324D,stroke-width:1.5px
    classDef action fill:#E9F6F2,stroke:#23866E,color:#17324D,stroke-width:1.5px
    classDef neutral fill:#F5F7FA,stroke:#8796A8,color:#17324D,stroke-width:1.5px
    class L,W,R neutral
    class B model
    class C decision
    class N action

Solid arrows show the normal order. The dashed arrow is the revision loop.

The step people skip is build it yourself, and it is the one that does most of the work. If you can finish a chapter by watching, something has gone wrong with the chapter.

Chapters 1 to 6 share one layout: week plan (what to do each week), what you will be able to do, what to learn, resources, what to build and before you move on, usually closing with a few things worth knowing. Chapters 1 and 5 add day-by-day plans where the work needs finer scheduling, and Chapters 7 and 8 are organised around the three branches and the job search instead.

Chapter 9 has a shared decision and delivery plan and three case guides. Each guide covers the target, data, baseline, candidate models, evaluation, constraints, experiments, operations and completion evidence. It is an applied extension, not a prerequisite for the job search.

Using AI assistants while you learn

How assistant use affects learning depends on the task and how you use it.

The 2026 Stack Overflow survey, released on 6 October, shows wide use: 73% of respondents who use AI coding assistants or agents say they use them daily. That share is of assistant users, not all developers. This self-selected survey describes reported practice and feelings. It does not show that assistants improve learning or independently measured productivity.

There is now a small controlled experiment too. In a randomised trial published by Anthropic in January 2026, 52 developers, mostly junior, learned an unfamiliar Python library with or without an AI assistant. The assistant group was not reliably faster, and scored 50% versus 67% on an immediate comprehension quiz. That is a reason to protect first attempts, not proof that every kind of AI help harms every learner.

Other designs give different results. A preprint revised on 4 October 2026 randomised AI access for 211 undergraduates studying unfamiliar topics and writing essays. It found higher scores on an unaided knowledge test, and a smaller gain a week later. This was not a coding task, and its tutoring-versus-delegation comparisons were descriptive, not separately randomised. A 2026 programming-classroom workshop paper links feedback with short-term completion, but does not show lasting mastery without help. Before applying a study's result to your learning, compare its intervention, population and unaided outcome.

An assistant can take away the effort of recall, so keep some practice unaided. The book's practical rule has two modes: do first attempts yourself, and when you ask for help, ask for an explanation rather than the fix.

This is a reasonable compromise, not a proven one. The coding trial measured immediate understanding. Other studies use different tasks and follow-up periods. Rebuild a small exercise without help at the next session and again a week later, then compare mistakes. Finishing with help and feeling confident do not show what you retained. Adjust how you ask for help based on what you find.

One thing worth taking seriously either way: only put code in your portfolio that you could talk through line by line, and be ready to explain its data and evaluation too.

Terms in plain English

Every term below is also explained in plain words where it first matters in a chapter. Come back here whenever a word feels fuzzy.

Projects, in order of difficulty

What each one proves, and separately what makes it stand out. Those are different questions. The Where you build it column names the chapter whose build exercise covers each project, or notes when it is optional or spans several chapters.

Three punch above their weight for the effort involved: the deliberate leakage write-up (project 3), the published failure taxonomy (project 7), and the honest fine-tuning comparison whose answer may be "not worth it" (project 8). That last kind of negative result shows a tested hypothesis and a fair decision. Explain the comparison, uncertainty and operating costs so a reviewer can judge it.

Common pitfalls

Collected from practitioner writing and from resources that turned out to be dated when checked. None of these are character flaws. Most are design problems with the material available.

About sequencing

Resources that are commonly recommended and now dated

Technical traps

About money and portfolios

• Certificates mostly signal enrolment. Audit courses free and spend the money on compute.
• Expensive cohort courses are often excellent, and their authors frequently publish most of the same material free. Read the free version first.
• Buying a GPU before exhausting free tiers is usually procrastination in physical form.
• Ten shallow projects read worse than three deep ones.
• Code you cannot explain is a real risk now that reviewers ask about repositories in detail.
• Building in public works better in the quiet version: ship small things and write up what broke. The high-profile examples usually had a large audience already.

Where thoughtful people disagree

This book takes positions throughout. These are the places where competent, experienced people genuinely disagree, and where stating both sides is more impressive than picking one.

Keeping this book current

Three kinds of information in this book age fastest: prices and free tiers, model names and capabilities, and salary figures. Treat any specific number as a snapshot, and check the source before you rely on it.

The illustrated edition — 30 October 2026

The web edition adds shorter lessons, eight original interactive field notes, local search, optional on-device reading progress, focus reading, a complete print edition and an EPUB. Chapter Markdown is still the source for all of them.

Chapters 2–6 now include original worked examples, independent exercises, hints and explained answers. Chapter 2 sets aside a holdout before you look at outcomes, and a shared causal primer prepares the business cases. Completion gates ask to see your reasoning and debugging.

The reference lab supplies deterministic synthetic data, training-only model fitting, separate calibration and test cohorts, a paired comparison, business decision examples and filled reports. Its results illustrate a stated simulator and implementation, not real commercial performance. The source inventory records cited URLs, without claiming that every source was independently rechecked on the edition date.

Two studies shaped how the book asks you to work: Dunlosky and colleagues (2013), on which study techniques actually hold up, and Roediger and Karpicke (2006), on why self-testing feels worse in the moment and works better in the end.

A few places deserve extra scepticism, and I would rather point them out myself. Causal and experimental methods rest on assumptions about assignment, confounding and interference. Chapter 9 now states those assumptions for the business cases and adds primary sources. The two-mode rule for AI assistants is a reasonable compromise, not a proven method. And the four-to-eight-month job-search allowance is a planning judgement, not an outcome estimate.

If something here has drifted out of date, that is the field doing what it does. Check it against the source, adjust, and keep going. If you find a broken link or a claim that no longer holds, an issue or a pull request on this repository is very welcome. Corrections from readers are how a book like this stays useful.

What changed in the illustrated edition review

• Edition 2026.10.1. Every diagram in the PDF now prints in its own place, and the EPUB passes the EpubCheck validator that ebook stores use.
• One thread, end to end. Chapters 4 and 5 now start with a same-thread build, and Chapter 6 runs the Chapter 3 model alongside the Chapter 5 application. Chapter 7 shows how each capstone stays connected, and Chapter 8 adds operations evidence to the portfolio template.
• New practice. A broadcasting exercise in Chapter 2, a training-debugging checklist in Chapter 4, document field extraction and output guardrails in Chapter 5, and explained exercises in Chapters 6, 8 and the offer, price and churn guides.
• Production. Safe artifact loading, provider outages, retention and erasure, and incident severity with blameless write-ups.
• Laboratory. Stricter manifest and sample-ratio checks, an experiment result reported with its uncertainty, and a test that the checked-in reference matches a fresh run.
• Corrections. Consistent fine-tuning placement, hour figures and reading selections. Missing links and resource notes added. A citable edition with EPUB and PDF downloads.
• Web edition. Illustrated plates for the start page, reader's guide, applied guides and lab reports. Full-width field notes in the lab. Dollar amounts no longer render as mathematics.
• Licence. The text, illustrations and lab reports are now CC BY 4.0, so you may share, translate and adapt them with credit. The website and code remain under the MIT licence.

What changed in the October 2026 research revision

• Business cases. Added Chapter 9 with detailed offer, pricing and churn guides, conditional model recommendations, worked economics, practice data and production delivery gates.
• End-to-end coverage. Added rules for feature availability, label maturity and outcome observation, plus calibration and test discipline, regression and forecasting, optional segmentation and anomaly methods, experiment protocols, model lifecycle and delayed-outcome feedback. The business guides separate competing events, the uncertainty of picking the best-looking policy, and joint or adaptive assignment.
• Current evidence. Reviewed 2026 tabular, causal, survival, recommendation, pricing and agent research. Recent preprints appear as conditional challengers, with criteria for reproduction and adoption, not as universal winners.
• Corrections. Updated library compatibility, course editions, contribution policies and hiring data. Qualified benchmark claims by model variant and sampling protocol. Strengthened guidance on leakage, uncertainty, permissions, release evaluation and rollback.
• Sources. Primary papers and official documentation are linked where the chapters use them, with assumptions and practical limits alongside model recommendations.

What changed in the September 2026 revision

For readers already partway through, these are the changes worth knowing:

• Setup. Python 3.14 in the setup commands, and a note on uv's new default project layout (Chapter 1).
• AI assistants. A 2026 randomised trial on learning with an assistant, and a two-mode rule adjusted to fit it (above).
• Short new sections. Reasoning-effort costs and agent skills (Chapter 5), regulation as part of production (Chapter 6), and a security reference for the AI Engineer branch (Chapter 7).
• Tabular models. A more careful picture of tabular foundation models against boosted trees (Chapter 3).
• The job search. Newer hiring and pay data, and interviews that now include an AI assistant (Chapter 8).
• Resources. Chapter 5 now points to Anthropic's free Claude Academy course, one course website no longer loads, and many notes were refreshed for new versions, prices and owners.

A note from the author

I have spent my career as a developer, moving between domains, and every move brought a new set of challenges. Through all of them, one habit has helped me more than any tool: starting from a roadmap. A good roadmap does two quiet things. It builds the foundation in the right order, and it teaches you to think in systems — to see how the pieces connect before you start collecting them.

This book is that habit written down, for the move I think matters most right now: from software engineering into AI and machine learning.

I want to be open about how it was made. I used AI models, including Fable 5, to help me research and draft it. The plan, the judgements, and the final words are mine, but it felt right that a book about working with these systems should be honest about being written with their help.

I am not only the author here. I follow these chapters myself, to refresh my own skills, because in this industry the learning never stays done. If you find something that has aged, treat it the way this book will teach you to treat every claim: check it, correct it, and keep moving.

— Santosh Shinde