The zod-tutorial repo is an exercise runner that makes you read the Zod docs

An exercise runner with a curriculum bolted on

The repository is called zod-tutorial and is described as a crash course on Zod, a schema validation library for TypeScript. What it actually is, from the repository layout, is a small TypeScript project whose whole purpose is to run exercises. The package name is zod-tutorial, the version is 1.0.0, the only runtime dependency is zod, and the devDependencies are the exercise runner and the test tooling. The scripts section tells the story. The main entry point is an exercise command that invokes an exercise CLI, and there is a second command for solutions, plus ten numbered pairs, one per exercise, that run a specific exercise with or without its solution. The npm scripts also include a CI command that runs the test suite and a prepare command that prepares a StackBlitz project. So this is a course in the shape of a repository, and the repository is a tool that runs the course.

Every exercise is a problem file and a solution file

The central convention is stated in one line: the course is split into exercises, and each exercise is split into a *.problem and a *.solution. That naming convention is the whole pedagogy. The problem file contains the exercise as it is given to you, the solution file contains the author's answer, and the exercise runner can present either. Two consequences follow. First, the amount of work you can do is bounded by what the repository contains, and the numbered scripts stop at ten, so the curriculum is ten exercises. Second, the answers are in the repository you cloned, which is a genuine weakness of the format and worth naming: nothing stops you from opening the solution file before you have tried, and the only thing that keeps a learner honest is the instruction to unpause the video and compare afterwards. A learner who reads the solution first gets the syntax but not the habit the course is trying to build.

Installing and running one exercise

The setup is two commands, documented at the top of the readme:

# Installs all dependencies
npm install

# Asks you which exercise you'd like to run, and runs it
npm run exercise

After the install, running the exercise command opens a prompt for choosing which exercise to run. The package.json shows the whole command surface:

  "scripts": {
    "exercise": "tt-cli run",
    "e": "npm run exercise",
    "solution": "tt-cli run --solution",
    "s": "npm run solution",

The short aliases e and s exist so you can type less, and the numbered variants e-01 through e-10 and s-01 through s-10 let you jump straight to a specific exercise with or without its solution. That is the workflow the readme describes: run the exercise command, choose the one you want, attempt it, and only look at the solution when you have succeeded or you are stuck. The prepare command is a nice touch for the browser, since preparing a StackBlitz project means you can work on an exercise without a local toolchain at all.

The tests are the teacher, the docs are the reference

The teaching method is described as active, exploratory learning. In the video the author explains a problem and you are asked to try to find a solution, and the readme is explicit about what that means in practice. You check out Zod's own documentation at zod.dev, you try to find something that looks relevant, and you give it a go to see if it solves the problem. The feedback signal is simple: you will know you have succeeded because the tests will pass. The test runner is vitest, listed in the devDependencies, and the CI script runs it over the tests directory. The effect of this design is that the documentation is the primary source and the video is commentary, not the other way around. For a library whose API surface is large and whose docs are thorough, that is a defensible choice. It also means the course is only as good as your willingness to read, and a learner who wants to be told the answer will find the format slower than a walkthrough.

The toolchain is modern and deliberately small

The dependency list is short and tells you what the course assumes. Zod itself is pinned as ^3.23.8, so the course content is written against version 3 of the library rather than the latest major. TypeScript is ^5.6.2, vitest is ^3.0.5, and the exercise runner is @total-typescript/exercise-cli at ^0.11.0, with jsdom and vite-tsconfig-paths alongside for the test environment and path resolution. The project is an ES module, with type set to module, and the repository carries a .nvmrc, a tsconfig.json and a vite.config.mts. There is also an update-snapshots script that runs vitest with the update flag, which tells you the test suite relies on snapshots somewhere, and a renovate.json for dependency updates. The project is authored by Matt Pocock, and the acknowledgements point to his Twitter, his Discord and the Total TypeScript course.

What this repository is not

Two limits deserve a clear statement, because the readme can be read as more than it is. The first is that the videos are not in the repository. The readme links to the TotalTypeScript.com tutorial page with a watch link, and the text repeatedly refers to the video, telling you to unpause it when you are done. If you want a self-contained artefact, this is not one, and the repository is best understood as the lab that accompanies a course. The second is the licensing situation. The licence is recorded as unknown in the repository metadata, while the package.json inside declares MIT and names Matt Pocock as the author. Those two statements are not necessarily in conflict, since the package manifest and the repository licence are different files with different audiences, but if you intend to reuse code from the exercises, read the licence file rather than trusting the manifest. The last push to the repository was on 2026-07-31, and there are no GitHub releases, so there is no versioned history to point at.

Why an exercise course beats reading zod.dev in one sitting

The obvious alternative is to read the Zod documentation from the beginning, which is free and complete, and to consult it whenever a problem appears. The difference in approach is real. Reading docs gives you a mental model in the order the authors chose, and it gives it to you quickly, but it does not make you write the code. The exercise format inverts that. You are given a failing test and a goal, you have to find the API yourself, and the documentation becomes a tool you reach for rather than a chapter you read. That ordering is the one the readme insists on, with the numbered steps of check the docs, try to find something relevant, give it a go. For someone who already knows TypeScript and wants Zod specifically, that is a reasonable way in. For someone who is new to schema validation in general, the same ten exercises will feel thin, and the documentation becomes the primary source anyway. The plain reading is that this repository teaches you how to use the Zod documentation, which is a skill, and it does not pretend to be a substitute for it.

Editorial conclusion

Adopt zod-tutorial if you learn best by writing code against a failing test and you want the habit of reading the Zod documentation rather than copying a solution. Do not adopt it as a substitute for the Zod docs themselves, because the repository holds ten exercises and points back to zod.dev for the actual reference, and do not expect a standalone curriculum, since the videos live on the Total TypeScript site. Before you start, run npm install and npm run exercise, pick the first numbered exercise, and resist reading the matching .solution file until the tests have failed at least once, since the answer is committed to the repository.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. total-typescript/zod-tutorial on GitHub