llm-master: a Chinese full-stack LLM learning path for working programmers

What llm-master is, and the gap it claims to fill

The README opens with a blunt claim: there is no shortage of LLM material online, what is missing is a learning path built for programmers. That framing defines the project. It is a curated route, not a library, not a framework, and not a course platform. The repository root contains only LICENSE, README.md and docs/, so everything of value sits inside a documentation tree.

The intended reader is stated explicitly: someone with a Java, C++, Go, Python or frontend background who wants to move into LLM application development, Agent engineering or AI backend work. That is a narrower audience than the topic list suggests. The topics cover agent, large-language-models, llm, llm-learning, llm-tutorial and rag, but the README's own suitability section excludes people whose goal is researching new model architectures, training foundation models, or working through mathematical proofs. It calls itself a supplement for application engineering in that case, not the primary source.

So the problem being solved is sequencing. A developer who already ships software does not need another explanation of what a token is; they need to know which concept to learn before which, and what counts as finished at each step. The repository answers that with staged completion criteria rather than article lists.

The six-stage route and its completion criteria

The README lays out a mermaid flowchart with six stages: global awareness, model invocation, RAG, Agent, production engineering, and principles plus interviews. Each stage has a learning entry point and, more usefully, a stated completion marker.

Stage 0 asks you to be able to draw the full chain of a single model request and explain the technical map and role boundaries. Stage 1 moves from chatting to developing, covering Prompt, structured output, streaming responses, tool calling, context, cost and latency, with a project that must support streaming output, JSON Schema, error handling and cost accounting. Stage 2 is RAG end to end: document processing, chunking, embedding, recall, rerank, generation, citation and evaluation, delivered as a knowledge base with hybrid retrieval, answer citations, an offline evaluation set and error analysis. Stage 3 covers tool contracts, state, memory, planning, permissions, failure recovery and evaluation, ending in an Agent that can be interrupted, resumed, traced and evaluated. Stage 4 is the operational layer: deployment, caching, quantization, rate limiting, timeouts, retries, monitoring, load testing and capacity planning. Stage 5 is Transformer internals plus interview preparation, with the marker being that you can hand-write a minimal Transformer and discuss metrics, failures and trade-offs.

This is the strongest part of the design. Completion criteria tied to artefacts, rather than to articles read, are what separate a route from a reading list. Whether the linked files deliver on those criteria is something you have to check yourself, because the README states the intent and the docs/ tree holds the content.

Getting started with the route: no install, just a clone or a browser

There is no package to install. The project has no releases, no build step and no runtime. You either read it on the web at notes.kamacoder.com/llm/ or clone the repository and read the Markdown files locally. The README's own instruction is to start from the full learning route rather than browsing the whole catalogue.

To work offline, clone and open the roadmap entry point:

git clone https://github.com/youngyangyang04/llm-master.git
cd llm-master
cat docs/roadmap/README.md

What you should see is the roadmap document that the README links as the recommended first stop. From there, the stage files are referenced by path, for example docs/roadmap/beginner.md, docs/roadmap/application.md, docs/roadmap/agent.md and docs/roadmap/interview.md.

The topic indexes work the same way. If you are mid-project rather than starting from zero, the README suggests entering the topic index and filling gaps by problem:

cat docs/topics/README.md
cat docs/topics/rag.md
cat docs/topics/agent.md

For interview preparation, the repository keeps a separate tree under docs/interview/llm/, including a general index plus topic files for Transformer, RAG, Agent, fine-tuning, Vibe Coding and at least one company-specific interview write-up. The README recommends answering project questions with a fixed structure: business problem, technical choice, system design, evaluation metrics, failures and optimisation, final result. That structure is the closest thing here to a reusable template.

Four portfolio projects and what each one demands

The README lists four projects with minimum delivery standards, and the standards are where the value sits. An AI business assistant must include exception handling, token accounting and automated tests. An enterprise knowledge base must include a fixed evaluation set, bad-case classification and a metric baseline. A tool-using Agent must include traces, failure recovery, a budget ceiling and a completion-rate evaluation. A production-grade AI service must include P99, TTFT, TPOT, goodput and a capacity report.

Each of those is a real engineering constraint rather than a feature list. Requiring a fixed evaluation set before you can call a RAG project finished forces you to think about measurement early, which is the opposite of how most tutorial projects are structured. Requiring a budget ceiling on an Agent forces you to treat token spend as a runtime concern.

The README is direct that a working demo is not the finish line. It asks whether you can explain why a choice was made, how the effect is measured, how failure is recovered and how cost is controlled. That is a reasonable bar for someone preparing for interviews at large Chinese technology companies, which the interview tree targets. It is also a heavier bar than most learners expect from a tutorial repository, and the README does not pretend otherwise.

Where llm-master is the wrong tool

The README's own suitability section is the clearest limitation, and it is worth taking at face value. This is not a resource for pure algorithm research or large-scale pretraining. If your goal is designing new model architectures, training a foundation model, or working through mathematical proofs, the repository positions itself as an application-engineering supplement rather than your main source.

There are two more constraints the material implies. First, the content is in Chinese; the README carries a language badge marking it as 中文, and the tutorial count badge reads 150+. If your reading language is English, the cost of using this route is translation, not just reading. Second, the repository is documentation only. There is no library to import, no CLI, no test suite you can run against your own code. Someone looking for an SDK, a RAG framework or an evaluation harness will not find one here; the projects described are things you build yourself, using whatever stack you choose.

A third point is structural. Because everything lives under docs/, the route is only as good as its links. The README does not document any link-checking or content-versioning process, so a reader following a stage file is relying on the repository's internal consistency. That is a normal risk for a large documentation tree, but it is a real one when the whole product is the tree.

How it differs from a framework and from a video course

The most useful comparison is with a RAG or Agent framework such as LangChain. A framework gives you runnable abstractions: you install it, wire components together, and the library handles chunking, retrieval or tool dispatch. llm-master gives you the reasoning behind those components and a project specification, but no code you can import. The difference matters at the point of failure. When a framework's retriever returns poor results, you need to know what chunking, embedding and rerank decisions produced that outcome. A framework teaches you its API; this repository aims at the decision layer underneath it.

The second comparison is with a structured video course or a paid bootcamp. Those typically supply a fixed syllabus, graded exercises and an instructor. llm-master supplies a dependency-ordered outline, per-stage completion criteria and a large body of written tutorials, but no grading and no schedule. Progress depends entirely on whether you actually build the four projects. The README's staging is closer to a syllabus than to a link dump, but it is still self-directed.

Against both alternatives, the trade-off is the same: you get conceptual and engineering coverage without runnable scaffolding, and you pay for it in time spent building everything yourself.

Maintenance, licence and the cost of following along

The repository is not archived, and its last push was on 2026-09-13, which is recent enough that the README's claim of continuous updates is consistent with the commit history. There are no retrieved releases, which fits a documentation project: versioning happens through commits to docs/ rather than through tagged artefacts.

The upgrade cost is therefore low in the mechanical sense and high in the cognitive sense. You never migrate an API, but the field moves, and the README itself acknowledges this by promising to add new engineering practices, project experience and interview questions. Following the route means re-reading sections as they change rather than pinning a version. The README also points to a WeChat public account as the first publication channel for new content, which is worth knowing if you want to track additions without watching the repository.

The licence is MIT, and the README adds a content-specific note: articles and images should retain their source when reproduced, subject to the copyright notices on that content. That is a distinction worth noticing. MIT covers the repository's code-oriented licensing terms, but the README treats the prose and images as carrying their own attribution expectations. If you plan to reuse material in training content or internal documentation, read the LICENSE file and the README's content note together rather than assuming MIT settles everything. This is not legal advice; it is a pointer to where the project states its own terms.

Editorial conclusion

Adopt llm-master if you already write Java, C++, Go, Python or frontend code and want a dependency-ordered path through LLM application engineering, with Chinese as the reading language. Do not adopt it if you need an installable package, an English-language course, or research-level material on pretraining and model architecture; the README states that it is not aimed at pure algorithm research or large-scale pretraining. Before committing time, open docs/roadmap/README.md and check that the stage matching your current level links to files that actually exist, since the repository is a docs/ tree and every claim about the path depends on those links resolving.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. youngyangyang04/llm-master on GitHub