The roadmap table counts ninety eight tutorials and the headline claims a hundred and ten

The module table adds up to less than the headline claims

The pitch is a set of numbers, and the numbers are the first thing to check.

The headline claims 110 detailed tutorials across more than 580,000 Chinese characters, with 400 plus curated GitHub projects and 30 plus chapter projects. Each module in the table then carries its own tutorial count: eight for the learning methodology module, twelve each for Python and JavaScript, six for HTML and CSS, twelve for React, ten for the backend, eight for the database and engineering module, eight for the AI fundamentals, fourteen for the agent frameworks module, and eight for the final project.

Those figures add up to ninety eight. The table is two modules short of the headline figure, and the gap is not explained anywhere in the file.

The same pattern appears in the project count. The headline says 30 plus chapter projects while the table names exactly one acceptance project per module, which is ten. Those are not contradictory in the same way, since a module can hold more than the one project listed in its row, but the discrepancy means the headline numbers are marketing and the table is the specification.

The practical reading is that the table is what you should plan against. It is per module, it names a deliverable for each row, and it is the only part of the file you can check.

Three timelines describe the same curriculum and none of them match

The schedule is stated three times in the file and the three statements do not agree.

The overview diagram allocates the curriculum to four stages by month: the foundation stage covering the first three months, the front end stage covering months four to seven, the back end stage covering months eight to ten, and the AI core stage covering months eleven to fifteen. So the diagram's total is fifteen months.

The module table allocates by week instead: one week, then ten, ten, four, ten, eight, six, six, twelve, and a final module of eight to twelve weeks. Those add up to between seventy five and seventy nine weeks, which is roughly seventeen to eighteen months. The same curriculum is fifteen months in one place and seventeen and a half in another.

The third statement is a pace table, and it gives three options keyed to hours rather than to modules: three hours a day on weekdays plus six at the weekend for twelve to fifteen months, aimed at students and people with free time; an hour and a half a day plus the weekend for eighteen to twenty four months, aimed at people with a full time job; and five or more hours a day for eight to ten months, for full time study.

That table is the one to use, because it is the only one that tells you what daily effort produces which outcome. The module weeks and the month ranges are two attempts at the same estimate and they disagree by a quarter.

The diagram itself is also cut off mid line, so any stage after the AI core one is not visible in the retrieved copy.

The acceptance projects are named tools, not exercises

Each module requires one deliverable, and the rule is stated bluntly: if you have not built it, you have not finished the chapter. What makes this unusual is that the deliverables are specific products with names.

The Python module ends with an asynchronous crawler command line tool published to the Python package index. The JavaScript module ends with a miniature utility library and an online code sandbox. The front end module asks for a pixel accurate reconstruction of three real commercial landing pages, and the React module asks for a collaborative whiteboard plus a hand written React with its reconciler and hooks. The backend module is a reference application backend with realtime chat, and the database module is a high concurrency microblogging community. The AI fundamentals module is an enterprise document question answering tool plus a language model implemented from scratch.

The agent module, marked as the centrepiece, ends with a miniature agent SDK and a self-built MCP server. The final module is not a technical artefact at all: it is described as a product that can be shipped, can earn money, and can be written onto a resume.

Every one of those is a public-shaped task, because most of them are things you could put on a profile page. That is the deliberate design, and it is also the part that will take longer than the week counts suggest.

Mastery is four stages and the last one is teaching someone else

The file states four principles and the first one is a definition of what mastery means.

Mastery at the source level is said to require passing through four stages in order: understand, then imitate, then rewrite, then teach someone else. That is a demanding definition, since the last stage is a public one, and it explains why the curriculum asks for hand written replacements of existing tools rather than exercises.

The build the wheel principle is the concrete form of that. By the source reading stage you are expected to have written your own miniature versions of a front end framework, a language model orchestration library and an agent framework by hand. The learning methodology module, eight tutorials of its own in the first week, is where that method is set out.

Project driven learning is the second principle, and it is the reason every module has a deliverable: not done means not learned. The third principle applies the Feynman technique, asking the learner to write notes that teach the subject to someone else after each section, which is the written form of the teaching stage in principle one.

The stated outcome list at the end of the file matches the ambition: production quality code without relying on frameworks, shipping a full application end to end, designing and deploying multi agent systems, reading parts of three specific codebases, having containers, pipelines, monitoring and tests in place, and being able to build an open source project with a hundred stars.

The content licence is share-alike and lives only in the readme

Licensing is stated in the file and it is the one thing here that constrains what a learner may do with these tutorials.

The repository content is offered under a Creative Commons attribution share-alike licence, version 4.0, with four conditions spelled out: free sharing, reposting and adaptation are allowed, commercial use is allowed provided the source is credited, attribution must be preserved with the author named, and derivative works must adopt the same licence.

Two things follow. The share-alike clause is the one that matters if you adapt the tutorials, since you are not relicensing your adaptation under terms of your choosing. And the attribution requirement names a specific person, so a repost has to carry that name, which is also stated in the contribution section where forks and reposting are explicitly welcomed provided the author is credited.

The repository's own licence field is unresolved and no licence file appears among the entries at the top level, so the readme is the only statement of terms. That is unusual for a repository asking people to repost its contents, and it is worth checking the canonical version before you build anything on top of these lessons.

Obsidian is the intended interface and the canvas comes first

The recommended way to use this is a note-taking application rather than a website, and the setup instructions assume it.

You download the application, clone the repository, open the cloned folder as a vault, and then open one specific file first: the mind map canvas inside the route directory. After that you start with the readme in the same directory. The canvas needs the application to render, and it is the global view of the whole curriculum with the relationships between modules visible at once.

There is an alternative for people who do not want to install anything, which is to browse the content directory directly on the hosting site, and the file notes that the Chinese directory names are compatible with it. That alternative loses the canvas and the graph view, which are the parts that need the application.

The repository itself is shaped around this decision. A configuration directory for the note application is committed at the top level rather than ignored, which is what makes a clone open as a working vault immediately, and the content lives in one directory with a Chinese name. Three readmes sit at the root, in Chinese, English and Japanese, so the interface is localised even when the content is not.

That mismatch is worth stating plainly: the prose is Chinese only, while the readme that tells you how to navigate it exists in three languages.

Editorial conclusion

This is a plan rather than a library, and it is worth reading as a shape: what it sequences and what it refuses to skip. Two things to check before you commit a year to it. The arithmetic in the file does not reconcile, so treat the durations and counts as approximate and re-plan your own schedule from the module list. And the content licence requires attribution and share-alike, which matters if you plan to repost or adapt the tutorials rather than just follow them.

Frequently asked questions

Official sources

1. Issues
2. Karovia/fullstack-ai-agent-roadmap on GitHub
3. README