The Best AI Engineering Courses to Take in 2026: A Complete Guide

I built this list for people who already write code and want to build with large language models (LLMs). In 2026, that's what AI engineering means: calling models through an API, grounding them in your own data, connecting them to tools, and keeping them working once real users arrive.

Your starting point changes the answer. A backend developer who has never trained a model needs a different first course from a data scientist who can fine-tune a model but has never shipped an API, so the first 2 sections split by background. The other 6 are organized by skill, from LLM APIs to AI coding tools.

If you're still deciding whether you want to build with AI or use it, start with our broader guide to the best AI courses instead.

Course ratings, review counts and learner numbers last verified 25 September 2026.

Best AI Engineering Courses Comparison Table

Every DataCamp course and track in this article is listed below with its live rating and learner count. Courses from other providers are covered in the sections themselves.

Best AI Engineering Courses For Software Engineers

The best AI engineering course for a software engineer starts at the API, not the math, because the job is shipping LLM features inside software you already maintain.

You already have the hard part: version control, testing, and deployment. What's missing is how to call a model, ground it in your data, and connect it to tools.

1. Associate AI Engineer for Developers - DataCamp

Our main path for developers who already know Python but have no machine learning or LLM experience, and the one I'd take first.

• Level: Beginner in AI, comfortable in Python
• Time: 29 hours
• Cost: Included with a subscription, from $14/month billed annually
• Best for: Developers adding LLM features to a product they already maintain

Its 10 courses run from the OpenAI API and prompt engineering through embeddings, Pinecone, Hugging Face, LangChain, and LLMOps. The latest version added Working with the OpenAI Responses API and Introduction to Model Context Protocol (MCP), so it now covers tool connections, not just chat calls.

Guided projects sit between the courses, such as a Paris travel assistant built on the OpenAI API and a topic analysis of clothing reviews with embeddings. There's also a course on software engineering principles in Python, which is easy to skip and worth doing.

The track prepares you for our AI Engineer for Developers Associate certification, the credential to add once you finish. What it doesn't teach is training models: there's no PyTorch here, which is right for this audience and wrong if you want to fine-tune.

2. Building AI Agents with Google ADK - DataCamp

A second agent framework in an hour, and the cheapest way to learn which agent ideas belong to one library and which carry across.

• Level: Intermediate
• Time: 1 hour
• Cost: Included with a subscription
• Best for: Developers on Google Cloud, or anyone who has only built agents in LangChain

Two chapters cover running an agent with Google's Agent Development Kit (ADK), then building a multi-agent system. Francesca Donadoni teaches it.

The developer track teaches agents through LangChain and MCP only, so ADK gives you a comparison point. If your company runs on Google Cloud, it's also the framework you'll most likely be asked to use. At 1 hour, it's light on deployment, so treat it as orientation rather than a full course.

3. AI Engineer Path - Scrimba

The better pick if your stack is JavaScript or TypeScript rather than Python.

• Level: Intermediate, assumes front-end JavaScript
• Time: 11.4 hours of interactive screencasts
• Cost: Scrimba Pro, $24.50/month billed annually
• Best for: Web developers working in Node or front-end codebases

It covers agents, retrieval augmented generation (RAG), MCP, and context engineering, with tools like LangChain.js and the Vercel AI SDK. Lessons use Scrimba's interactive screencasts, where you pause the instructor and edit their code in the browser.

Almost every AI engineering course, ours included, assumes Python. If you ship JavaScript, learning the patterns in your own language first is faster. The trade-off is depth: there's nothing on model internals or fine-tuning, and you'll want Python eventually for open-model tooling.

Our pick: Take our Associate AI Engineer for Developers track, then Building AI Agents with Google ADK for a second framework. If you work in JavaScript, start with Scrimba's AI Engineer Path instead.

Best AI Engineering Courses For Data Scientists

The best AI engineering course for a data scientist skips the machine learning you already know and teaches what notebooks never required: LLM applications, software practice, and deployment.

Data scientists arrive with the model side covered. The gap is shipping: tests, version control, and putting a model behind an interface other people depend on.

1. Associate AI Engineer for Data Scientists - DataCamp

Our track for data scientists moving from notebooks to production AI systems.

• Level: Intermediate, assumes Python and basic machine learning
• Time: 40 hours
• Cost: Included with a subscription, from $14/month billed annually
• Best for: Data scientists who want to train, fine-tune, and deploy models, not only call them

The 13 courses start with scikit-learn and PyTorch, move through LLM fundamentals and running Llama 3 locally, and finish on software practice: testing with pytest, Git, and MLOps concepts. Explainable AI with SHAP and LIME is in there too.

It's 11 hours longer than the developer track because it adds the engineering habits most data scientists never needed. Guided projects include an OCR model for scanned insurance documents and an LLM project classifying car reviews.

It prepares you for our AI Engineer for Data Scientists Associate certification. The gap: it teaches very little LLM application building, with no RAG and no agent frameworks, which is why the next course is here.

2. Developing LLM Applications with LangChain - DataCamp

The app-building layer the data scientist track skips, and the course I'd take right after it.

• Level: Intermediate
• Time: 3 hours
• Cost: Included with a subscription
• Best for: Data scientists who can fine-tune a model but have never built an application around one

Three chapters cover LangChain and chatbot mechanics, chains and agents, and a first pass at RAG. Jonathan Bennion, a LangChain contributor, teaches it.

LangChain draws fair criticism for its layers of abstraction, and its API changes often. It's still the framework most job postings name, and this is the first course of our Developing Applications with LangChain track if you want to keep going.

3. Generative AI Engineering with LLMs Specialization - IBM, Coursera

Deeper on the model side than anything we publish at this level.

• Level: Intermediate, assumes Python, with PyTorch helpful
• Time: 6 courses, about 3 months
• Cost: Coursera subscription
• Best for: Data scientists who want transformer internals and fine-tuning methods

Across 6 courses, it goes from tokenization and data loaders through transformer language models to LoRA, QLoRA, and alignment methods such as DPO and PPO, all in PyTorch and Hugging Face. IBM's catalog lists a content update in August 2026.

Its last course covers RAG and agents with LangChain, but lightly. Take it if your interest is how LLMs work and how to adapt them, not what you can ship with them this quarter.

Our pick: Take our Associate AI Engineer for Data Scientists track, then Developing LLM Applications with LangChain to fill its application gap. Add IBM's specialization only if you want more fine-tuning depth.

Best Courses For Working With LLM APIs

The best course for working with LLM APIs teaches the request itself: messages, parameters, structured output, function calling, and what to do when the API fails.

Every later section assumes you can do this. All 5 picks here are ours, because this is where our catalog runs deepest, with 2 providers covered and every course updated in 2026.

1. Working with the OpenAI API - DataCamp

The first course to take, and the most-taken standalone course in this article.

• Level: Beginner in AI, comfortable in Python
• Time: 3 hours
• Cost: Chapter 1 free, full access from $14/month billed annually
• Best for: Developers making their first API call

Three chapters cover the OpenAI API, prompting OpenAI models, and multi-turn conversations. James Chapman and Eduardo Oliveira, our CTO, teach it.

With 174K learners and 9,508 reviews, it has the largest sample behind its rating of any single course here. It's OpenAI-only, so the concepts transfer to other providers and the code mostly doesn't.

2. Prompt Engineering with the OpenAI API - DataCamp

Prompting as code, where the goal is output you can reproduce rather than output that worked once.

• Level: Beginner
• Time: 4 hours
• Cost: Included with a subscription
• Best for: Developers who need consistent, structured output from a model

Four chapters cover prompting best practices, advanced strategies, prompts for business applications, and prompts for chatbots. Fouad Trad teaches it.

At 4 hours, it's the longest course in this section. The chatbot chapter overlaps with the conversation chapter above, so you can move quickly through it.

3. Developing AI Systems with the OpenAI API - DataCamp

What to learn once your prototype meets users who didn't build it.

• Level: Intermediate
• Time: 3 hours
• Cost: Included with a subscription
• Best for: Developers about to put an LLM feature in front of users

Three chapters cover structuring end-to-end applications, function calling, and best practices for production applications. Francesca Donadoni teaches it.

Function calling is the chapter to prioritize, since it's how a model hands structured requests to your code. The latest version of our developer track dropped this course, so take it separately if you did the track.

4. Introduction to Claude Models - DataCamp

The Anthropic API, for teams that want a second provider or build on Claude first.

• Level: Intermediate
• Time: 3 hours
• Cost: Included with a subscription
• Best for: Teams evaluating more than one model provider

Three chapters cover the Anthropic API, prompting with Claude, and multi-message interactions. Nikhil Rangarajan teaches it.

Building against 2 providers is cheap insurance against price changes and outages, and the request formats differ more than the documentation suggests. With 981 reviews, its rating rests on a smaller sample than the OpenAI courses.

5. Introduction to LLMs in Python - DataCamp

What happens inside the model you've been calling.

• Level: Intermediate
• Time: 3 hours
• Cost: Included with a subscription
• Best for: Developers who want to debug model behavior, not only observe it

Three chapters cover how LLMs and transformers work, fine-tuning LLMs, and evaluating LLM performance. Jasmin Ludolf and Iván Palomares Carrascosa teach it.

You can ship plenty without it. The evaluation chapter is why I'd take it anyway, because knowing how LLM output gets scored tells you when a score is lying. It's also part of our data scientist track, so skip it if you've done that.

Our pick: Take Working with the OpenAI API first, then Developing AI Systems with the OpenAI API before you ship anything. Add Introduction to Claude Models if you use more than one provider.

Best Courses For RAG And Embeddings

The best RAG course teaches retrieval before generation, because a bad RAG answer usually comes from retrieving the wrong chunks, not from the model.

Retrieval augmented generation (RAG) grounds a model's answer in documents you supply. It rests on embeddings, which turn text into vectors you can compare by meaning.

1. Introduction to Embeddings with the OpenAI API - DataCamp

Semantic search from first principles, and the idea the rest of this section rests on.

• Level: Intermediate
• Time: 3 hours
• Cost: Chapter 1 free, full access from $14/month billed annually
• Best for: Developers who want to understand why retrieval returns what it returns

Three chapters cover what embeddings are, embeddings for AI applications such as semantic search and recommendations, and an introduction to vector databases. Emmanuel Pire and James Chapman teach it.

It uses OpenAI's embedding models throughout. Open-source embedding models from Hugging Face work the same way conceptually but need different code.

2. Building AI Applications with Pinecone - DataCamp

Where the vectors go once there are too many to keep in memory.

• Level: Intermediate
• Time: 3 hours
• Cost: Included with a subscription
• Best for: Developers moving from a prototype index to a production-sized one

Three chapters cover Pinecone basics, managing vectors in Python, and performance tuning for AI applications. James Chapman and Ryan Ong teach it.

It teaches Pinecone specifically, a managed vector database. Most concepts carry over to Weaviate, Chroma, or pgvector, and the client code doesn't.

3. Retrieval Augmented Generation (RAG) with LangChain - DataCamp

The pattern itself, end to end, and the most recently updated course in this article.

• Level: Intermediate
• Time: 3 hours
• Cost: Included with a subscription
• Best for: Developers grounding answers in documents they control

Three chapters cover building RAG applications with LangChain, improving the RAG architecture, and Graph RAG with knowledge graphs. Meri Nova teaches it.

Graph RAG is the chapter most RAG courses don't have, and it's the right tool when your documents describe entities and their relationships. It's also the second course of our Developing Applications with LangChain track.

4. Retrieval Augmented Generation (RAG) - DeepLearning.AI, Coursera

The deeper option once you have a RAG system and its answers aren't good enough.

• Level: Intermediate, Python required
• Time: 5 modules, about 3 weeks at 10 hours a week
• Cost: Coursera or DeepLearning.AI subscription
• Best for: Developers whose retrieval quality has plateaued

Zain Hasan teaches retrieval in more depth than we do: BM25 keyword search, hybrid search with reciprocal rank fusion, cross-encoder reranking, and chunking, with Weaviate as the vector database. The final module covers evaluation and monitoring with Arize Phoenix.

It launched in July 2025. The labs build chatbots on fictional e-commerce and news datasets rather than your documents, so take it second, once you've hit retrieval problems of your own.

Our pick: Take our 3 courses in order, starting with Introduction to Embeddings with the OpenAI API. Move to DeepLearning.AI's RAG course when retrieval quality, not the pipeline, is your problem.

Best Courses For Building AI Agents

The best AI agent course teaches the design patterns first and one framework second, because frameworks change faster than the patterns do.

An AI agent is an LLM that decides which steps to take and which tools to call, rather than answering once. For a LangChain-only list, see our guide to the best LangChain courses for developers.

1. AI Agent Fundamentals - DataCamp

Agent concepts without code, and the right first step even if you'll write plenty of code later.

• Level: Beginner, no coding
• Time: 6 hours
• Cost: Included with a subscription, from $14/month billed annually
• Best for: Anyone who needs to understand agents before choosing how to build one

Its 3 courses start with Introduction to AI for Work and Introduction to AI Agents, then finish with Building Scalable Agentic Systems. Along the way, you meet the Thought-Action-Observation loop, ReAct prompting, multi-agent patterns, and the Agent-to-Agent (A2A) protocol.

Developers can skip the first course. The part worth your time is why agents fail to leave development, which is the question every later course in this section assumes you've asked.

2. Designing Agentic Systems with LangChain - DataCamp

Agent design past the tutorial stage, which is where the interesting problems start.

• Level: Intermediate
• Time: 3 hours
• Cost: Included with a subscription
• Best for: Developers whose agent works in a demo and not in practice

Three chapters cover the essentials of LangChain agents, building chatbots with LangGraph, and dynamic chat agents. Dilini K. Sumanapala teaches it.

LangGraph is the reason to take it: it's how LangChain now handles agents that loop, branch, and keep state. It's the last course of our Developing Applications with LangChain track, so take the track if you want the full sequence.

3. Introduction to Model Context Protocol (MCP) - DataCamp

The standard for connecting agents to tools, and the course I'd prioritize if you only have time for one more.

• Level: Intermediate
• Time: 3 hours
• Cost: Included with a subscription
• Best for: Developers tired of writing a custom integration for every tool

Three chapters cover the building blocks of MCP, MCP-enabled LLM applications, and preparing MCP servers for production. James Chapman and Korey Stegared-Pace of Microsoft teach it.

MCP replaces per-framework glue code with one interface that any compatible client can use. It's also part of our developer track, and with 607 reviews, its rating rests on a smaller sample than most here.

4. AI Agents Course - Hugging Face

Free, framework-spanning, and the best no-cost option in this section.

• Level: Intermediate
• Time: 4 core units plus 3 bonus units, self-paced
• Cost: Free, with a certificate
• Best for: Developers who want to see agents across more than one framework

It covers smolagents, LlamaIndex, and LangGraph, with bonus units on fine-tuning for function calling and agent observability. Hugging Face maintains it in public, and it was still being updated in September 2026.

Seeing the same agent built 3 ways is the fastest route to knowing which parts are framework convention. The certificate is free, so there's little reason not to take it alongside ours.

5. Agentic AI - DeepLearning.AI

Andrew Ng on agent design patterns, in plain Python.

• Level: Intermediate, Python required
• Time: 5 modules, about 10 hours
• Cost: Videos free, labs and certificate with Pro at $25/month billed annually
• Best for: Developers who want the patterns without a framework in the way

Launched in October 2025, it teaches 4 patterns: reflection, tool use, planning, and multi-agent collaboration. Everything is built in raw Python rather than through a library.

That makes it the most durable material in this section, since the patterns will outlast every framework named above. The trade-off is that you won't learn any framework's production features, such as LangGraph's state handling.

Our pick: Take AI Agent Fundamentals if agents are new to you, then Introduction to Model Context Protocol (MCP) and Designing Agentic Systems with LangChain. Add Hugging Face's free course for a second and third framework.

Best Courses For Open Models And Fine-Tuning

The best fine-tuning course starts with finding and running open models, because dataset preparation, not training, is where most of the work goes.

Open-weight models such as Llama let you run and adapt a model on your own hardware. Fine-tuning retrains one on your data so it follows a format or tone that prompting can't hold.

1. Working with Hugging Face - DataCamp

Finding, loading, and running open models, which is the prerequisite for everything else here.

• Level: Beginner
• Time: 2 hours
• Cost: Chapter 1 free, full access from $14/month billed annually
• Best for: Developers who have only ever used a hosted API

Two chapters cover getting started with the Hugging Face Hub and building pipelines for common tasks. Jacob Marquez teaches it.

It's the oldest course in this article, last refreshed in July 2025, and the Hugging Face libraries have moved since. It doesn't show a rating yet, so judge it on the 38K learners and the chapter list. It's in both of our AI engineer tracks.

2. Fine-Tuning with Llama 3 - DataCamp

Adapting an open-weight model, on hardware you can plausibly get.

• Level: Intermediate
• Time: 2 hours
• Cost: Included with a subscription
• Best for: Teams needing a consistent format or tone at volume

Two chapters cover preparing data for Llama fine-tuning and fine-tuning with Hugging Face's SFTTrainer. Francesca Donadoni teaches it.

Dataset preparation is most of the work and the part people underestimate, which is why it gets a full chapter. Its rating rests on 414 reviews, a small sample, so weigh it accordingly.

3. Transformer Models with PyTorch - DataCamp

Building the architecture yourself, which few engineers need and which changes how you read everything else.

• Level: Advanced
• Time: 2 hours
• Cost: Included with a subscription
• Best for: Engineers who want the mechanism, not the abstraction

Two chapters cover the building blocks of transformer models, including attention and positional encoding, then assembling full transformer architectures in PyTorch. James Chapman teaches it.

Take it for understanding rather than application. Nobody builds production transformers from scratch, and after this course, attention stops being a word you nod along to.

4. LLM Course - Hugging Face

Free, first-party, and further into training technique than we go.

• Level: Intermediate to advanced
• Time: 12 chapters, about 6 to 8 hours each
• Cost: Free
• Best for: Engineers doing serious fine-tuning work

The newest chapters cover dataset curation, supervised fine-tuning with SFTTrainer, LoRA, and training reasoning models with GRPO. Hugging Face develops it in the open, and its GitHub repository was still being updated in July 2026.

The people who maintain the libraries wrote it, which is its biggest strength. The early chapters cover classic NLP tasks that you can skim if you only care about LLMs.

Our pick: Take Working with Hugging Face first, then Fine-Tuning with Llama 3. Move to Hugging Face's LLM Course when you need LoRA or reasoning-model training.

Best Courses For LLMOps And Deployment

The best LLMOps course teaches evaluation and monitoring alongside deployment, because an LLM feature fails quietly, with plausible but wrong output rather than an error.

LLMOps covers everything after the prototype: versioning prompts, evaluating output, serving the model, and watching it in production.

1. LLMOps Concepts - DataCamp

One hour, and the best-value hour in this article for anyone about to ship.

• Level: Beginner
• Time: 1 hour
• Cost: Chapter 1 free, full access from $14/month billed annually
• Best for: Developers whose prototype is about to become someone's dependency

Three chapters follow the LLM lifecycle through the ideation, development, and operational phases. Max Knobbout, an applied scientist at Uber, teaches it.

It's conceptual, with no deployment code. Take it before the next 2 entries, which assume you know why each lifecycle stage exists.

2. Deploying AI into Production with FastAPI - DataCamp

Getting a model behind an API other services can call.

• Level: Advanced
• Time: 4 hours
• Cost: Included with a subscription
• Best for: Engineers responsible for the service, not just the model

Four chapters cover FastAPI for model deployment, integrating AI models, securing and optimizing the API, and API versioning, monitoring, and logging. Matt Eckerle teaches it.

The versioning and logging chapter is the one tutorials skip, and it's the part you'll need first when something breaks. It was last refreshed in November 2025, so check FastAPI's current docs for anything version-specific.

3. MLOps Fundamentals - DataCamp

The wider practice that LLMOps inherits most of its habits from.

• Level: Advanced
• Time: 14 hours
• Cost: Included with a subscription, from $14/month billed annually
• Best for: Teams putting any model into production, LLM or not

Its 4 courses, including MLOps Concepts, cover how models move from a notebook to production and how to keep them healthy once they're there.

Monitoring for drift carries over most directly to LLM work. At 14 hours, it's the biggest commitment in this section, and data scientists who took our AI engineer track have already seen MLOps Concepts.

4. AI Evals for Engineers & PMs - Hamel Husain and Shreya Shankar, Maven

The course practitioners point to for LLM evaluation, the skill most teams skip.

• Level: Intermediate to advanced
• Time: 4 weeks at 3 to 5 hours a week, live cohort
• Cost: About $5,000 before discounts, with lifetime access to recordings and future cohorts
• Best for: Engineers and product managers responsible for whether an LLM feature works

You instrument a real agent, read its traces, group its failure modes, and build LLM-as-judge and code-based evals that match expert judgment. The October 10, 2026 cohort is the last of the year.

Nothing we publish goes this deep on evaluation. The price is the obvious limitation: at that level, it's a training budget decision, not a personal one.

Our pick: Take LLMOps Concepts before you ship, then Deploying AI into Production with FastAPI to serve the model. If your company will pay for it, the Maven evals course is the best investment in this section.

Best Courses For AI Coding Tools

The best course for an AI coding tool teaches you to review what the tool writes, because accepting generated code you don't understand is the fastest way to ship bugs.

AI coding tools range from autocomplete in your editor, such as GitHub Copilot, to agents like Claude Code that edit many files and run tests. Pick the course for the tool your team actually uses.

1. AI for Software Engineering - DataCamp

The broad track, covering the tools you're likely to meet across different teams.

• Level: Intermediate
• Time: 8 hours
• Cost: Included with a subscription, from $14/month billed annually
• Best for: Engineers setting a standard for how a team uses AI tools

Its 4 courses are AI-Assisted Coding for Developers, Software Development with GitHub Copilot, Software Development with Windsurf, and Vibe Coding with Replit. Matt Palmer, head of developer relations at Replit, teaches the Replit course.

The first course is tool-agnostic and the most useful: prompting for code, then testing and documenting what comes back. The Windsurf and Replit courses matter less if your team has standardized on one editor.

2. GitHub Copilot Fundamentals (GH-300) - DataCamp

Preparation for GitHub's Copilot certification, built in collaboration with GitHub.

• Level: Intermediate
• Time: 7 hours
• Cost: Included with a subscription
• Best for: Developers whose employer asks for the GH-300 certification

It shares its first 2 courses with the track above, then adds Advanced AI-Assisted Coding for Developers and AI Ethics. Tutorials fill in exam topics such as Copilot plans, the Copilot CLI, and content exclusions.

Its learner count comes from AI Ethics, the track's most-taken course, so the headline numbers say more about that course than about Copilot. Take it if you want the certificate. Otherwise, the track above covers more tools.

3. Claude Code 101 - DataCamp and Anthropic Academy

Agentic coding in a terminal, free on our platform and produced by Anthropic.

• Level: Beginner
• Time: 3 hours
• Cost: Free
• Best for: Developers who want AI doing multi-file work, not line completion

Four chapters cover what Claude Code is, your first prompt, daily workflows, and customizing Claude Code for your project. Anthropic Academy produced it.

Claude Code works across a whole codebase, so the course spends its time on reviewing and steering changes rather than on prompting tricks. It's Claude-specific, and the workflow habits carry to other coding agents.

4. Claude Code in Action - DataCamp and Anthropic Academy

The follow-on for anyone who has hit Claude Code's defaults, and the highest-rated course in this article.

• Level: Intermediate
• Time: 3 hours
• Cost: Free
• Best for: Developers who want to hand Claude Code longer jobs

Four chapters cover steering long sessions, configuring Claude with rules and hooks, automating repeat work with routines and GitHub, and verifying what comes back. Anthropic Academy produced it.

Its 4.9 rating comes from 249 reviews, so it sits just above our 200-review threshold. Expect the screens to date quickly, since Claude Code changes often.

Our pick: Take AI for Software Engineering for broad coverage, or GitHub Copilot Fundamentals (GH-300) if you need the certificate. For Claude Code, start with the free Claude Code 101.

How We Chose These Courses

The ratings, review counts, and learner numbers for our own courses are pulled from live course data, on the date shown in the freshness stamp at the top of this page. For tracks, the rating is a review-weighted average of the courses the track contains, and the learner number is that of its most-taken course.

Any course with no content update in the past 18 months didn't make the cut, whether it was ours or someone else's. We also left out courses with fewer than 200 reviews from the ratings, and capped each section at 5 picks.

External courses were checked against the provider's own pages or recent coverage in September 2026. Where an outside course is the better choice, we included it and said why.

Final Thoughts

For most developers, our Associate AI Engineer for Developers track is where I'd start, because it covers the API, RAG, agents, and LLMOps in 29 hours and prepares you for a certification. Data scientists should take our Associate AI Engineer for Data Scientists track instead, and JavaScript developers will get further, faster with Scrimba.

If you're a beginner and only take one course this week, make it Working with the OpenAI API. It takes 3 hours, and every other course in this article assumes you've done it.