# learn-ai is a free, self-contained HTML course on building AI products
> learn-ai is an open course for AI product managers, written as seven chapters of interactive slides covering how large models work, how harnesses are engineered, and how to take a demo to a product. It has 54 topics across more than 180 pages, every page is a standalone HTML file you can open locally, and the whole thing is free under an AGPL licence that exists specifically to stop it being resold.
**itshen/learn-ai** — AI 产品从入门到精通 —— 面向 AI 产品经理的完整培训课程，涵盖大模型底层原理到 AI 工程化落地
- Repository: https://github.com/itshen/learn-ai
- Website: https://xueai.app
- Stars: 542 · Forks: 64
- Language: HTML
- License: AGPL-3.0
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/itshen-learn-ai
## A curriculum, not a tip list
The repository describes itself as a complete training course for AI product managers, covering the underlying principles of large models through to AI engineering in practice.
The scale is stated in one line and it is a useful signal about the ambition. Seven chapters plus an after-class dessert, 54 topics, more than 180 interactive slides, all free and openly published.
The audience framing matters, because it determines what the course assumes. This is written for product managers rather than for researchers or for engineers who already know the field. That shows up in the topics: alongside the model fundamentals and the retrieval pipelines there are chapters on harness design patterns, tool design and evaluation methodology, secure containerisation, and a whole chapter on a vibe coding methodology that covers process control, quality floors, documentation, security gates and writing style.
Those are not the topics of a machine learning course. They are the topics of somebody who has watched teams ship AI features and has written down what went wrong.
The online version is at xueai.app, and the author is Luo Xiaoshan, described as an AI product manager and independent developer, with a personal site and a public account for AI writing. The copyright is held by the author together with Miyang Tech, a company registered in Zhuhai Hengqin.
The project is AGPL-3.0 licensed, the primary language of the repository is HTML, the default branch is main and there are no GitHub releases. The last push was on 2026-09-03.
The repository itself is tiny, and that is not a sign of a thin project. There is a .gitignore, the LICENSE, the README, two QR code images for the author's public account and donation, and a slides/ directory that holds the course.
## The seven chapters, and how they build
The chapter structure is the curriculum, and the order is the argument.
The first chapter is how large models came to be. It covers the token generation mechanism and training principles, the history of the GPT leaps, the evolution from completion to dialogue, and the causes of model hallucination together with four mitigation approaches, which are retrieval augmented generation, prompt engineering, supervised fine-tuning and temperature.
That last grouping is a useful teaching device. Putting four fixes for the same symptom side by side makes the point that hallucination is not one problem with one solution, and it sets up the later chapters where RAG and prompting each get their own treatment.
The second chapter is the AI harness, and it is the one that marks this course as being about practice rather than theory. Context engineering. Advanced prompting and prompt injection defence. Agent design and tool calling with the ReAct framework. Vector databases and Milvus, taken from the embedding all the way to a complete retrieval pipeline. And a five-layer cost optimisation system, with the key-value cache among them.
That chapter is where a lot of what matters most to a working team lives, because context is what determines both the quality and the bill.
The third chapter is practice, from demo to product. Image generation productisation. Agent loop control and context compression. Long-term memory design. And multi-agent collaboration with the MCP ecosystem.
The fourth goes further into engineering design patterns, with context engineering taken apart from the Claude Code source, tool design and evaluation methodology, and secure containerisation.
The fifth turns the lens on the tooling itself, covering harness design patterns, the automatic evolution of context engineering, and the frontier of recursive self-improvement.
The sixth is a specific case study. It dissects a production-grade coding agent along its Rust source, covering the runtime, the tools and the memory mechanisms, and the security and extension design.
The seventh is the vibe coding methodology, built on an open source repository of AI collaboration rules, covering process control and quality floors, and then documentation, security gates and writing style.
And the dessert is an extra that is explicitly not part of the AI course: a startup lecture covering product and one-person-company entrepreneurship, the seven-character startup maxim, raising money with financing, valuation and equity, and cash flow management.
## Reading it locally, without a server
The local reading section is short and it answers the practical question immediately.
The courseware is all single-file HTML. You open any page under the slides/ directory directly in a browser by double-clicking it, and no server is needed.
That is a deliberate and unusual choice for an interactive course, and it has consequences worth spelling out.
The obvious approach would be a static site generator or a JavaScript framework with a build step and a bundler, which gives you nicer authoring and component reuse. This goes the other way: every slide is one file that carries everything it needs, which means the repository can be cloned and read on a train with no network, on a machine with nothing installed, or served from a USB stick.
It also means the course cannot rot the way a hosted one can. There is no deployment to keep alive and no domain to lose, and the licence requires that anyone who redeploys it keeps the attribution, so the course survives its absence from any particular server.
For orientation, two entry points are named. If you want to start from the beginning, open slides/home.html, which is the front page, or slides/learn.html, which is the course index.
The interactive part is in the slides themselves rather than in a surrounding application, which is consistent with the single-file approach. Each page carries its own navigation and its own behaviour, so a slide can be linked to directly and shared on its own without any context from a surrounding shell.
There is one more detail that tells you about how the author thinks about distribution. Alongside the two QR code images there is a code for the author's public account and a code for sending a small donation, which is the standard arrangement for writing published by an individual in the Chinese ecosystem rather than by an organisation.
## Why the licence is AGPL and not MIT
The licensing section is the most interesting document in the repository, because it is written as an argument rather than as a legal notice.
The reasoning starts with a claim about the AI era. Good learning content should belong to everyone who wants to learn, rather than being a paid barrier for a few.
The project is open source because the hope is that more people can reach systematic AI knowledge and push up the level of the industry as a whole, on the belief that the freer knowledge flows, the higher the overall level of the industry rises, which benefits everyone.
Then the qualification, and it is a sharp one. Open source does not mean it can be used without restraint. The one thing they least want to see is someone taking learning content that should belong to everyone, repackaging it as a paid course or a closed-source product, and profiting from it. That would betray the trust of the open source community and erode the learning environment they are trying to build.
Given that reasoning, the licence choice follows. AGPL-3.0 rather than a permissive licence, with four consequences spelled out.
Anyone may use, study and improve the content for free. Any modification or derivative must also be open source, so improvements flow back to the community. Whether it is a website deployment or a redistribution of the content, the original author's attribution must be preserved. And using the project in a closed-source commercial product is prohibited.
That last point is what distinguishes AGPL from MIT in practice here. The copyleft obligation is the mechanism, and the stated purpose is specific: to prevent the content from being captured and resold.
It is an unusual choice for courseware, and a defensible one. Most open course content is published under a permissive licence and then sold back as a course, which is exactly the outcome this author says they want to prevent. The licence is doing the work the donation request also does, just with teeth.
The AGPL is also the reason a commercial team cannot simply vendor the slides into an internal training portal without publishing the result, which is worth knowing before you plan to do that.
## What this course is for, and what it is not
It is worth being clear about where this sits against other AI learning resources, because the choice of medium is unusual.
There are model reference documentation, which tells you what a parameter does. There are tutorials, which take you through one task. There are video courses, which are narrated and sequenced but cannot be skimmed or searched. And there are handbooks, which are references you dip into.
This is a curriculum, and the difference matters in how you use it. A curriculum is ordered so that each chapter assumes the previous one, so the value is in working through it rather than in looking up an answer. The order of the chapters is the argument: the models first, then the harness that wraps them, then practice, then the engineering patterns, then the tooling turning on itself, then a case study, then the working method.
The case study chapter is the one that stands out for a working product manager. Dissecting a production coding agent along its Rust source is not a technique most courses teach, and it is the sort of thing you learn a lot from if you are responsible for an agent that has to be reliable rather than merely impressive.
The vibe coding chapter is similarly practical in a way that is easy to dismiss. Process control and a quality floor, documentation, security gates and writing style are the parts of working with a coding agent that a team needs to agree on, and they are rarely written down.
The limits are worth stating too. It is not a model training course; there is no mathematics of transformers and no code for training. It does not cover evaluation infrastructure in the sense of building a benchmark harness, only the methodology for evaluating tools. And it is one person's view, delivered by one author with a commercial interest in the space, which for a course means the opinions are consistent and the alternatives are not represented.
The licence also constrains the practical uses. If your organisation wants to run this as internal onboarding, a modified version of the deck has to be published and attributed, and a closed internal product built from it is out of bounds. That does not stop you from reading it, pointing people at the site, or running the unmodified slides internally, but it does change what you can build with it.
## Conclusion
Adopt learn-ai if you are a product manager or developer who wants a structured path through how large models behave and how AI features get built, since the content goes from tokenisation to production patterns rather than stopping at prompt tips. Skip it if you want a reference you can query rather than a curriculum you work through, and if you need to embed the content in a closed commercial product, which the licence explicitly forbids. Verify first how you want to read it, since every slide is a single HTML file that opens in a browser with no server, and that the deck is current enough for your purposes, since the last push was on 2026-09-03.
## FAQ
### What does the learn-ai course cover?
It is a training course for AI product managers in seven chapters plus an after-class extra, with 54 topics and more than 180 interactive slides. The chapters cover how large models came to be, the AI harness including context engineering and prompt injection defence, practice from demo to product, AI engineering design patterns, harness design and self-improvement, a dissection of a production coding agent from its Rust source, and a vibe coding methodology. The extra is a startup lecture on funding, valuation and cash flow.
### How do I read the learn-ai course locally?
The courseware is all single-file HTML. You open any page under the slides/ directory directly in a browser by double-clicking it, with no server needed. To start from the beginning, open slides/home.html, which is the front page, or slides/learn.html, which is the course index. The online version is at xueai.app.
### Why is learn-ai licensed under AGPL-3.0?
The author's reasoning is that good learning content should belong to everyone who wants to learn rather than being a paid barrier, but that open source must not be turned into a resale channel. The licence therefore requires that modifications and derivatives stay open source, that attribution is preserved whether the content is deployed as a site or redistributed, and it prohibits use in a closed-source commercial product. The stated fear is content being repackaged as a paid course and sold.
## Sources
- [Issues](https://github.com/itshen/learn-ai/issues)
- [itshen/learn-ai on GitHub](https://github.com/itshen/learn-ai)
- [License: AGPL-3.0](https://github.com/itshen/learn-ai/blob/main/LICENSE)
- [Project website](https://xueai.app)
- [README](https://github.com/itshen/learn-ai/blob/main/README.md)
---
Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/itshen-learn-ai