HA7CH School: a curriculum that installs as a Claude Code skill and teaches through your own agent

A course that loads into the agent instead of sitting on a docs site

The premise is a single inversion. Rather than publishing a written curriculum and hoping readers work through it, HA7CH School ships the curriculum as a skill that a coding agent loads, at which point the agent takes the role of the tutor and opens the conversation by asking which course you want to start. The README states the position directly: this is not a pile of documents for you to chew through on your own.

The intended student is someone with a Claude Code or Codex setup who wants to understand two specific subjects: the zero token product architecture HA7CH advocates, and the Forward Deployed Engineer role. Both courses assume you will do work, not read. The stated audience explicitly includes people from business, product and operations backgrounds rather than engineers only, which is why a shared GitHub module exists at all.

The content lives in two places, and the split is part of the design. The hosted site at `school.ha7ch.com` carries the course content, while what goes to SkillHub is described as a thin loader under `publish/loader/`. That keeps the distributed artefact small and lets the lessons change without republishing the skill.

Nested skills and lesson-at-a-time loading

The mechanism that makes this more than a long prompt is progressive loading. `SKILL.md` acts only as the registration desk: it asks which course you want, maintains the learning record, and sequences lessons. Every course and every individual lesson is a separate file under `references/lessons/`, loaded only when the student reaches it.

The reason is context budget. A curriculum with eight numbered lessons plus shared modules would consume a large share of a session's context if loaded at once, and content that matters for lesson three is dead weight during lesson one. By splitting on file boundaries and loading on demand, the working context stays close to what the current lesson needs.

The sequencing rule is the more opinionated part. The README says the lesson order is not fixed at 01, 02, 03. The tutor first works out where the student is strong and where they are weak, starts from familiar ground, and pushes the weakest area later where it gets detailed treatment. A student with a business background who wants to work as an FDE covers business content first and takes the technical material last. The engine for this lives in `references/pedagogy.md`, and the cross-session record format is documented in `references/state-schema.md`.

Teaching also stays in the main thread by design. The README makes a point that the student can interrupt at any time and send the tutor off to look something up, without being handed to an invisible background process. For a tutoring interaction that is the right call: a subagent that returns a finished answer removes exactly the back and forth that makes the session teaching rather than reading.

Installing with npx and entering the classroom

The fastest documented path is a single npx invocation, which detects your setup and writes the skill into the right directory:

npx @ha7ch/school
npx @ha7ch/school --codex
npx @ha7ch/school --force

The bare command installs to `~/.claude/skills/ha7ch-school`. The `--codex` flag targets `~/.codex/skills/` for Codex users. The `--force` flag updates to the newest version, and the README notes that learning progress is unaffected because it lives elsewhere, in `~/.ha7ch-school/`.

Developers who want the repository itself can clone straight into the skills directory:

git clone https://github.com/HA7CH/ha7ch-school ~/.claude/skills/ha7ch-school

After installing, the README says to run `/ha7ch-school` inside Claude Code, or simply tell the agent you want to learn AI Native or FDE. You should see the tutor open by asking which course to take rather than printing an outline. Two install-free routes also exist: paste `https://school.ha7ch.com/install.md` to your agent and ask it to install the skill, or paste `https://school.ha7ch.com/school.md` to start a lesson with nothing installed at all.

Progress is stored at `~/.ha7ch-school/{handle}.json`, one file per handle, local to each machine. There is no sync, so a student switching between a laptop and a desktop starts over on the second machine.

The self-update check, and the assumption underneath it

Before each session the tutor compares the local `manifest.json` version against the hosted one. If they match it says nothing and teaches. If the local copy is behind, the README says it announces a short line about the school having updated, runs `--force` to reinstall, and continues. A student never manually updates and never restarts the session, because lessons are read as they are reached and a refreshed file takes effect immediately.

The README is also explicit about why this matters beyond convenience: the check and the update are performed by the student's own agent, so the school spends no tokens of its own. That is the zero token design being taught, applied to the thing teaching it. As a demonstration it is more convincing than the lesson text could be.

The assumption worth examining is trust. A skill that reinstalls itself from the network at the start of a session means content can change under a student between one day and the next, and the trigger is a version comparison rather than anything the student approved. The README does say that when the network is unavailable or the update fails, the tutor skips silently and teaches with what it has, which at least means an outage does not block a lesson. Anyone in an environment where installed tooling has to be pinned should know this behaviour is on by default.

Two distribution paths that must not drift apart

The release section documents a maintenance hazard the project has clearly already hit. The courses ship through two channels that must be updated together: the hosted site, deployed automatically by Vercel when changes merge to master, and the npm package `@ha7ch/school`. If the two versions diverge, every installed student's self-check concludes it is behind and reinstalls, repeatedly.

The documented procedure raises the version in three files at once, `manifest.json`, `cli/package.json` and `cli/package-lock.json`, with the last two handled by `npm version` run inside `cli`. Merging to master updates the hosted site. Publishing to npm is triggered by a tag:

git tag v1.3.1 && git push origin v1.3.1

The tag name must be `v` plus the version and must match `manifest.json` and `cli/package.json` exactly, because the workflow validates this first and fails the release when it does not. The repository also needs an `NPM_TOKEN` secret holding an npm automation token.

This is a sensible guard, and it exists because the failure mode is invisible to the maintainer and loud for students. It is also a reminder that a self-updating skill turns a routine version mistake into a reinstall loop on other people's machines.

No licence file, and what that leaves unresolved

The repository tree lists `README.md`, `SKILL.md`, `WALL.md`, `install.md`, `school.md`, `manifest.json`, `vercel.json`, and the `cli/`, `publish/`, `references/` and `assets/` directories. There is no `LICENSE` file, and GitHub reports no licence for the project.

Without a licence, the default position under copyright is that the author keeps all rights and grants none in writing. That sits awkwardly with a project whose teaching method asks students to fork the repository, add their name to `WALL.md` and open a pull request, and whose content is served publicly for agents to read. The practical consequence for a reader is limited if you only take the course. It becomes a real question if you want to translate the lessons, adapt them for a team, or redistribute the lessons. This is not legal advice, and the fix is available to the maintainers in one commit: add a licence file, or state the terms in the README.

A second consideration is that lessons name real commercial next steps, including a paid two day FDE Camp with dated sessions and a WeChat contact for registration. The README itself tells readers to confirm schedule and cost against the camp's own reference material before paying, which is the right instruction to include.

Against the in-person FDE Camp, and against just reading the site

The project links its own alternative, which makes the comparison unusually concrete. HA7CH FDE Camp is a two day residential class in small groups, linked from the README, that combines enterprise judgement, AI building, client communication and on-site delivery, with a whiteboard interview as the graduation bar, a `HA7CH FDE Certified` result and entry into an FDE talent pool. The README records that the Shenzhen session ended on 13 September 2026 and that a Beijing session starts on 26 September 2026.

The difference in approach is not depth of content so much as what supplies the pressure. The skill gives you a tutor that adapts to your pace and costs nothing beyond your own token usage, and its assessment is a diagnosis skill run against your own answers. The camp supplies a room of other people, a fixed clock, a live interview and a credential, none of which a local skill can simulate. A student who stalls without external commitment gets little from the first and a lot from the second.

The third option is the lightest: read the hosted material directly, since `school.ha7ch.com` serves the same lessons and `school.md` can be pasted into any agent. You lose the adaptive ordering, the cross-session record and the prompt to start, which is most of what distinguishes this project from a documentation site.

What the repository shows about how the courses are built

The structure section maps content to files in a way that makes the teaching method auditable. `references/pedagogy.md` holds the sequencing engine, `references/course-ai-native.md` and `references/course-fde.md` hold the two outlines with their adaptive branches, and `references/sources.md` lists every source behind the lessons, including article URLs, local source files and the products used in practical work. The README states that each lesson is anchored to real sources: HA7CH's own articles, the founder's spoken scripts and working products.

The practical lessons are the part that is hardest to fake and easiest to verify. The AI Native track ends with building a live page from your CV through `cv.ha7ch.com`, and the FDE track runs the built-in `fde-diagnosis` skill against you to report whether you are missing Echo or Delta. The README notes that `fde-diagnosis` is bundled and needs no separate install, while `cv-pro` is installed on demand, and that the tutor degrades honestly when an external capability is unavailable.

The GitHub module is the clearest statement of who this is for. It teaches repo, commit, branch and pull request, issue, fork, and merge as deployment, with the stated rule that students do not memorise commands because commands belong to the agent. The exercise is forking this repository and landing a first pull request against `WALL.md`, after which the merged name appears at `school.ha7ch.com/WALL.md`. Using the school's own repository as the exercise target removes the artificiality that sandbox tutorials usually carry.

Editorial conclusion

This is worth installing if you work with Claude Code or Codex, want the HA7CH view of zero token product design or the FDE role, and prefer being questioned to reading an outline: the adaptive sequencing in references/pedagogy.md and the WALL.md pull request exercise are the parts that justify the format. It is the wrong fit if you need a stable pinned artefact, since the tutor reinstalls itself with --force whenever manifest.json is behind, or if you want to reuse the course content, because the repository ships no licence file. Verify two things before starting: that npx @ha7ch/school placed the skill in ~/.claude/skills/ha7ch-school, and that your progress file exists at ~/.ha7ch-school/{handle}.json after the first lesson.

Frequently asked questions

Official sources

1. HA7CH/ha7ch-school on GitHub
2. Issues
3. Project website
4. README