The next step after GenAI‑101. Learn to build and ship real tools with generative AI — enough software engineering to write good plans, how to work with coding agents, how to shape and spec what to build, and the six skills behind reliable AI applications.
This course is organized around Andrew Ng's map of what it takes to build a career in AI Engineering — a map formed from analysing a large number of job postings, expert interviews, and survey responses.
The key difference between AI applications and ordinary software is that an AI system's output is less predictable. You don't know in advance what an LLM will say. Because of that uncertainty, building AI systems is far more iterative: you repeatedly build a piece, examine it, and decide what to try next. Being able to skillfully decide what to do next is what lets you create reliable software from unreliable AI components.
Ng breaks AI Engineering into four top-level skills, and the first — building and deploying AI applications — into six sub-skills. GenAI‑102 covers the three general engineering skills first (Modules 2–4), then goes deep on the six building-and-deploying sub-skills (Modules 5–10).
Source: Andrew Ng, “AI Engineering Skills Map: Building and Deploying AI Applications” — DeepLearning.AI / The Batch. The six sub-skills follow his post; the Module 2–4 breakdowns are this course's own elaboration.
GenAI‑101 taught you how generative AI works. GenAI‑102 teaches you to turn that understanding into working, maintainable, production-ready tools.
Move from prompting a chatbot to engineering software: RAG pipelines, agents, evals, and systems that run in production.
You don't need to be a senior engineer — but knowing frontend, backend, databases and system design lets you write realistic plans and direct coding agents intelligently.
AI output is unpredictable. The skill that matters most is running a disciplined build→inspect→decide loop — and this course is built around it.
Learn to build evals and drive an error-analysis loop — the trait that most distinguishes people who are great at building AI systems.
Observability, drift, prompt-injection, cost and latency — operating AI software is genuinely different from operating traditional software.
It's easy to have an AI crank out something that runs once and nobody can maintain. Learn to build tools that are readable, extensible, and safe to hand off.
10 modules: the general AI-engineering skills first, then the six skills behind building and deploying AI applications. Content is in development — the outline below is the plan.
The skills map, and why building with AI is different. Unpredictable output means an iterative build→inspect→decide loop is the core skill — and this module shows where every later module sits on the map.
Enough software literacy to write realistic plans and direct coding agents well: how a system is built end-to-end, the kinds of apps you might build, and the fundamentals of version control, testing, deployment, cost and load.
Working with coding agents as an engineering discipline: giving context, prompting, planning and steering, reviewing output you never trust blindly, tools and multi-agent workflows — and Skills, the glue that ties tools, commands and context together, shared as plugins in marketplaces.
The product/architect skill: deciding what to build under uncertainty. Write specs with GenAI's help, choose the stack and design, define success with tests before the design, decompose into tasks, and build tools that don't turn into AI slop.
The engineering decisions behind using an LLM well: tokenization and generation, context-window tradeoffs, cache hits, knowledge cutoff, reasoning effort, sampling parameters, tool calling, and when fine-tuning or self-hosting is worth it. Links to GenAI‑101 for the underlying concepts.
Giving LLMs the right input context so they produce useful output. RAG with vector search as the early technique, then the wider menu: prompt vs. retrieve-on-demand, vector indexes vs. knowledge graphs vs. semantic layers, turning documents into LLM-ready inputs, and keeping data clean and fresh.
From predefined workflows to agent harnesses that decide their own next step. Choose the architecture (chain, parallelize, code vs. LLM), design the agent loop with tools and memory, know when multi-agent orchestration is needed, and turn prototypes into reliable, safe, secure agents.
The disciplined evals / error-analysis loop that most distinguishes people great at building AI systems. Look at traces and outputs, decide what to measure, and pick from the menu: deterministic evals, LLM-as-a-judge, human-in-the-loop — then evaluate your evals so they keep evolving.
Running AI software is different because of its unpredictability, cost and latency. Build observability, track performance and detect drift, respond to failures and prompt-injection incidents, do regression testing that leans on statistics, and optimize cost and latency at scale.
The ML depth behind good LLM engineering. Modern LLMs are built with supervised learning and reinforcement learning; know the popular models and their tradeoffs, how to engineer training data, and the mental frameworks — bias/variance, error analysis — for navigating uncertain output. Bridges to ML‑101 rather than re-teaching it.
This is a build course. Every lesson ends with a “Build It” section — how to implement the idea, and the key takeaways that feed one of two capstones. Complete one, or both.
Build a weekly task & progress tracker — hierarchical tasks, notes, a week view — then connect it to WhatsApp or another messaging app so you can add tasks, log progress, and get summaries by message. An LLM parses your messages; an agent decides the action; evals check it got it right.
Turn what a person already knows — skills, projects, writing — into a polished personal-brand website, generated and refined with GenAI. Grounded in their real material (résumé, repos, notes) so every claim is true, not invented — the platform's honesty discipline, applied.