ai-engineering-from-scratch-zh: A Chinese Translation of a 523-Lesson AI Engineering Curriculum

The Spine Problem This Curriculum Claims to Solve

The README opens with a specific complaint: AI material arrives in fragments. One paper here, a fine-tuning write-up there, an agent demo somewhere else. The stated symptom is that you can build a chatbot without being able to explain its loss curve, or attach a function to an agent without knowing what attention is doing inside the model that calls it. The course positions itself as the spine that connects those fragments, ordered so that lower layers support upper ones. The intended reader is someone who already writes code in some language and wants to understand how AI systems work rather than call an API. The README's own framing of the gap is a pair of survey numbers, and they are presented as motivation, not as evidence about this repository. The scope is broad by design: 20 phases, 523 lessons, roughly 348 hours, with code in Python, TypeScript, Rust and Julia. That breadth is the selling point and also the first thing to scrutinize, because a curriculum this wide has to keep its lesson count, its translations and its code in sync, and the README describes a CI guard specifically for the lesson count.

Build It Then Use It: The Six-Beat Lesson Loop

Each lesson follows a fixed sequence the README renders as a flowchart: a one-line core idea, a concrete problem, core concepts with diagrams and intuition, a hand-written build using pure math and no framework, a second pass that does the same thing with PyTorch or scikit-learn, and finally an output you keep. The split between the build step and the use step is the structural claim of the whole project. You write the small version yourself, then run the production library, and the README argues that this is why the framework stops being opaque. That is a defensible pedagogical choice, and it is also the reason the course is long. A lesson that only demonstrated the library call would be a fraction of the size. The trade-off is that the hand-written implementations are teaching artifacts, not components you should expect to drop into a production pipeline. The README does not claim otherwise, but the framing around reusable outputs could be read that way, and the distinction matters when you decide what to keep from a lesson.

The Folder Layout Is the Real Interface

The repository is organized per lesson, and the README gives the exact shape: phases/<NN>-<phase-name>/<NN>-<lesson-name>/ containing code/, docs/zh.md, and outputs/. The code directory holds runnable implementations in Python, TypeScript, Rust and Julia. The docs directory holds the lesson text, with zh.md as the Chinese body. The outputs directory holds the artifacts the lesson produces, which the README describes as prompts, skills, agents or MCP servers. This layout is the part of the project you will actually interact with if you clone it, and it has consequences. There is no single package to install and no importable module that spans the course. Progress tracking lives on the companion site, not in the repository. If you want to work offline, you are navigating directories and reading Markdown. The README's own example of a lesson output listing shows two prompt files under a loss-functions lesson, which is a fair illustration of the granularity: small, self-contained, copy-pasteable artifacts rather than a library.

Getting It Running: Three Paths and the Commands Behind Them

The README offers three entry points. Path A is reading on aieng-zh.cn, no clone and no setup. Path B is a clone followed by a single run command: git clone https://github.com/fancyboi999/ai-engineering-from-scratch-zh.git, then cd into the repository, then python phases/01-math-foundations/01-linear-algebra-intuition/code/vectors.py. That command is the concrete proof that the layout works, and it is the first thing to try. Path C uses agent skills. The README lists /find-your-level, a ten-question placement quiz that maps your knowledge to a starting phase and generates a path with hour estimates, and /check-understanding <phase>, an eight-question per-phase quiz that returns feedback and names specific lessons to review. Both are described as working in Claude, Cursor, Codex, OpenClaw, Hermes or any agent with the course skills installed. The README also documents /claude-certification, which selects among four exam tracks (CCAO-F, CCDV-F, CCAR-F, CCAR-P) and saves progress to CLAUDE-CERTIFICATION.md. Prerequisites are stated plainly: you can write code in any language, Python preferred, and you want to understand how AI works rather than tune APIs. The site build has its own check, node site/build.js --check, which the README says CI uses to verify that the lesson count on the site matches what is on disk.

What the Chinese Edition Actually Changes

This repository is a derivative, not the original. The README credits Rohit Ghumare's AI Engineering from Scratch as the upstream project and states that the course structure and code stay aligned with upstream while the translation tracks upstream updates. The localization goes beyond translation: 523 lesson bodies, an 83-entry glossary, quiz questions, mermaid diagrams and interactive chart labels are in Simplified Chinese, with technical terms such as agent, token and transformer kept in English by convention. There is a separate site at aieng-zh.cn with a searchable catalog, learning paths, progress tracking, draggable interactive charts, a command palette bound to Cmd/Ctrl+K, and dark mode. Build-time generation of sitemap.xml, llms.txt and structured data is aimed at search engines and AI assistants. Animated explainer videos in the style of 3Blue1Brown with Chinese narration are embedded in lesson pages, and the README is explicit that Phase 1 (22 math lessons) is live while other phases are still in production. That sentence is the most important one for planning. A reader who assumes the video layer covers the whole course will be wrong, and the README says so directly rather than burying it.

Where the Course Stops Being the Right Tool

Several boundaries are visible in the material. The certification track is preparation material, not certification. The README states it is independent study material based on public exam objectives, is not affiliated with Anthropic, contains no real exam questions, and does not guarantee a pass, and it warns that eligibility, fees, scoring and program policies can change and that the official documentation governs. Treat any exam-readiness claim accordingly. The video layer is partial, as noted above. The translation is a moving target by design: the README says the translation follows upstream updates, which means lesson text can change under you, and there is a TRANSLATION.md describing the approach but no stated freeze point. If you need a stable, versioned artifact to build on, this is the wrong shape of project. It is also the wrong tool if you want depth in one area rather than a path across twenty. The phase ordering is a dependency chain, and the README warns against skipping a lower layer and then wondering why an upper one collapses, which is a reasonable warning but also an admission that the curriculum resists cherry-picking. Finally, the multi-language code claim (Python, TypeScript, Rust, Julia) is a breadth statement, not a statement that every lesson is implemented in all four. The README does not detail per-language coverage, and that is something to verify lesson by lesson rather than assume.

Compared With a Conventional Textbook or a Framework Tutorial

The closest conventional alternative is a single-language textbook that teaches one stack end to end, for example a deep learning book paired with a framework's own tutorials. The difference is the build-then-use split. A framework tutorial typically starts at the library call and explains the math as background; this course inverts that and makes you write the algorithm before the library appears. The cost is time, roughly 348 hours by the README's own estimate, and the benefit is that the library's behavior stops being magic. A second alternative is a video-first course. The animated explainers here are supplementary by the README's own description, positioned as an addition to hands-on derivation rather than a way to skip it, so a learner who wants to watch rather than type will find the format mismatched. A third comparison is the upstream English repository. If you read English comfortably, the upstream is the canonical source and this edition adds the Chinese localization, the companion site and the video layer. If Chinese is your working language for study, this edition is the one with the glossary, the translated diagrams and the placement skills. The trade-off is that you inherit a translation lag that the upstream does not have.

Licence, Maintenance and What to Verify Before You Commit

The repository is MIT licensed, and the README states the upstream project is also MIT. MIT permits reuse and modification with the licence and copyright notice retained, but this is a description of the licence text, not legal advice, and if you plan to redistribute the material or build a paid product on it you should read the LICENSE file and the upstream licence yourself. Maintenance signals in the supplied material are limited. There are no releases retrieved, and the README describes an active translation effort with video production still in progress, so the practical upgrade cost is re-syncing when upstream changes. The repository does not publish a versioned release you can pin. The CI lesson-count check is the one automated consistency mechanism the README documents, and it guards the count, not the translation accuracy or code correctness. Before adopting it for a cohort or a study plan, verify three things: that the specific phase you need is translated and has runnable code, that the video coverage matches what you promise learners, and that the vectors.py command from the quick start runs on your machine. If those three hold, the folder layout and the build-then-use loop are the parts that carry the value, and they are the parts that survive an upstream update.

Editorial conclusion

Adopt this if you want a structured, from-scratch Chinese curriculum with runnable per-lesson code and you are willing to work in the phases/<NN>-<phase-name>/<NN>-<lesson-name>/ layout rather than through a hosted course player. Do not adopt it if you need certified exam material, a stable API surface, or a guarantee that every lesson is translated and every video is published; the README states Phase 1 videos are live and the rest are still being produced. Before relying on it, clone the repository, run the vectors.py command from the quick start, and run node site/build.js --check to confirm the lesson count matches the disk contents.

Official sources

1. fancyboi999/ai-engineering-from-scratch-zh on GitHub
2. Issues
3. License: MIT
4. Project website
5. README