Course · in development

AI Vibe Coding Mastery

Thirty terms, five tiers, one repository that grows a commit at a time. The spine went out before a single unit was written, because if the spine is wrong the units inherit the error. It has since been recounted and corrected. Version 0.3.0, compiled 2026-08-21. Machine-readable at /research/data/vibe-coding-curriculum.json.

The five tiers are marketing. The thirty terms are eight ideas seen from five altitudes, and the tier a term lands in is an accident of when you happen to hit it rather than a statement about its difficulty. A reader who finishes this matrix should stop counting to thirty and start counting to eight.

Every term is mapped to a primary throughline and one or more secondary throughlines. A term with only two marks is a term that genuinely does one and a half things, and the verdict field says so rather than inflating it. Verdicts are opinionated on purpose: a curriculum that treats all thirty terms as equally load-bearing is a curriculum that has not been used.

14load-bearingLearning it changes what you build.

10already doingA name for existing practice. Short unit, real commit.

6thin or worseVibes, an umbrella, or a bad idea with a good name.

The overlap matrix

Thirty rows, eight columns. Filter to one line and watch the terms that share it light up across all five tiers, which is the whole argument: a tier is a place you meet an idea, not a property of the idea.

Thirty terms against eight throughlines. A filled mark is the primary line, an open mark is secondary.
#	Term	Tier	A	B	C	D	E	F	G	H	Verdict
1	Prompting	Noob	○	●					○		already doing
2	Context Window	Noob	●	○	○						load-bearing
3	Tokens	Noob	●					○	○		already doing
4	Projects	Noob	○	●							thin
5	API Keys	Noob				○	●	○			already doing
6	CLI	Noob		○		●	○				already doing
7	MCP Servers	Beginner	○	○			●				load-bearing
8	CLAUDE.md	Beginner	○	●				○			already doing
9	/commands	Beginner	○	●		○					already doing
10	Model Routing	Beginner	●		○				○		load-bearing
11	Sub-Agents	Beginner	○		●					○	already doing
12	Prompt Caching	Beginner	●	○					○		load-bearing
13	Git Worktrees	Pro			○	○				●	load-bearing
14	Skills	Pro	○	●			○				load-bearing
15	Hooks	Pro		○			○	●			load-bearing
16	Harness Engineering	Pro		○		○	○	●			umbrella
17	Background Agents	Pro			○	●				○	already doing
18	Headless Runs	Pro				●	○	○	○		load-bearing
19	Parallel Agents	Expert	○		●					○	already doing
20	Progressive Disclosure	Expert	●	○			○				load-bearing
21	Eval-Driven Loops	Expert				○		○	●		load-bearing
22	Orchestrator-Workers	Expert	○		●			○		○	load-bearing
23	Ultrathink	Expert	●						○		thin
24	Memory Consolidation	Expert	●	○					○		thin
25	Self-Improving Loops	Vibe-God		○				○	●		conditional
26	Tool Poisoning	Vibe-God	○	○			●	○			load-bearing
27	Self-Healing Tests	Vibe-God			○			●	○		dangerous
28	Agent CI/CD	Vibe-God				○		●	○	○	load-bearing
29	Agents Managing Agents	Vibe-God			●	○			○		thin
30	Multi-Repo Orchestration	Vibe-God			○		○			●	already doing
	marks on each line		17	15	10	10	10	12	12	7	93 total

Filled is the primary line, open is secondary.

Recount

93, not the 89 published and not the 94 guessed. Five terms carry four marks: 16, 18, 22, 26 and 28. Two carry two: 4 and 23, the two the verdict column calls thin. The remaining 23 carry three.

The published summary claimed 89 marks and was challenged on the grounds that the implied average forced almost every term to exactly three, which is tighter than terms like 22 and 28 deserve. The challenge was right about the shape and wrong about the size.

Every term was re-examined against one test: would the unit have to teach something on that line. Four marks were added. One candidate was considered and rejected, and it is recorded below so the discipline is visible rather than only its result.

added E to 18 Headless removes the human who approves tool calls, so permission mode becomes a design decision and the reachable tool surface widens. That is an E teaching point the unit cannot skip.
added F to 22 The merge step. Deterministic reconciliation of N stochastic worker outputs is why the pattern works, and the line C passage already described it without the mark being made.
added B to 26 A tool description is an instruction that binds, authored by an adversary. Framing poisoning as hostile instruction packaging is the sharpest available reading of the attack.
added G to 28 CI gates on an eval score, so the measurement from line G is what the gate reads. Without it the pipeline can only check that the run exited zero.
rejected D for 7 MCP transport, stdio against a remote service, was proposed as an execution-surface mark. Line D is about attendance, whether a human is in the loop, not about where a process runs. Transport belongs to E, which is already the primary. No mark added.

Teach order and build order

The numbering is the meme’s and it does not move. The order you can actually build in is a topological sort of the dependency edges, and it disagrees with the numbering in twenty-two places. Publishing both is the only way a reader building along can tell a forward reference from a mistake.

Teach order is the meme's 1 to 30 and does not move; those are the term IDs and they are the spine. Build order is a topological sort of the dependency edges, validated on every generation. Where the two diverge the unit carries a forward or backward pointer.

Twenty-two of the thirty positions move. 10 of those moves are design decisions and are marked; the rest are incidental consequences of packing the graph around them.

Teach order against build order, with the reason for each divergence.
Build	Teach	Term	Δ	Why
1	1	Prompting	·	Teach and build agree.
2	3	Tokens	-1	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
3	5	API Keys	-2	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
4	6	CLI	-2	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
5	2	Context Window	+3	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
6	4	Projects	+2	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
7	8	CLAUDE.md	-1	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
8	9	/commands	-1	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
9	7	MCP Servers	+2	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
10	26	Tool Poisoning	-16	Built with 7 because exposure begins the moment a third-party server is added. Ships the basic defence; the lazy-loading interaction forward-points to 20.
11	10	Model Routing	+1	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
12	11	Sub-Agents	+1	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
13	14	Skills	-1	Skills are prompt architecture, and 12 cannot be tuned until that architecture exists.
14	12	Prompt Caching	+2	Needs a stable prefix to have a hit rate at all, so it builds after 8, 9 and 14.
15	13	Git Worktrees	+2	Worktrees are the isolation primitive every parallel term later depends on. Earlier is cheaper.
16	15	Hooks	+1	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
17	18	Headless Runs	-1	Headless is the substrate for 17, 21 and 28, so it builds before all three rather than after 17.
18	17	Background Agents	+1	Needs both a worktree to run in and a headless runner to be.
19	19	Parallel Agents	·	Teach and build agree.
20	20	Progressive Disclosure	·	Teach and build agree.
21	21	Eval-Driven Loops	·	Teach and build agree.
22	22	Orchestrator-Workers	·	Teach and build agree.
23	23	Ultrathink	·	Teach and build agree.
24	24	Memory Consolidation	·	Teach and build agree.
25	28	Agent CI/CD	-3	CI gates on an eval score, so 21 must exist first.
26	27	Self-Healing Tests	-1	Auto-triage opens a PR, which needs the pipeline from 28.
27	25	Self-Improving Loops	+2	Enforced by ruling 3: conditional on 21, and it consumes 24's retention policy.
28	29	Agents Managing Agents	-1	Incidental. Position shifted by packing the DAG around a material move, not a design decision.
29	16	Harness Engineering	+13	The synthesis chapter names 15, 18, 21 and 28 as its parts, and its commit is the Makefile wiring them. You cannot wire together things that do not exist yet, so it builds last but reads in Tier 3.
30	30	Multi-Repo Orchestration	·	Teach and build agree.

The eight lines, five altitudes each

Each line is one idea escalating. The ladder names the terms in order; the passage says what actually changes between rungs.

AContext economics

What enters the window, what it costs, what gets evicted.

3 Tokens → 2 Context Window → 12 Prompt Caching → 20 Progressive Disclosure → 24 Memory Consolidation

Tokens are the unit of account, and for about a week that is all they are: a number at the bottom of the run. The context window turns the number into a constraint, because now there is a container and things fall out of it. Prompt caching is the first move that treats the container as an economic object rather than a physical one: the same prefix costs full price once and a fraction thereafter, so where you put a thing in the prompt starts to matter more than whether you put it there at all. Progressive disclosure inverts the default, loading a tool description or a skill body at the moment of use instead of at the top of the session. Memory consolidation is the terminal question the other four are all avoiding: when the session ends, what deserves to survive it, and who decides. Same idea, five altitudes: count, contain, amortise, defer, retain.

BInstruction packaging

Where standing instructions live, and at what scope they bind.

1 Prompting → 4 Projects → 8 CLAUDE.md → 9 /commands → 14 Skills → 15 Hooks

Every term on this line answers one question: how long does this instruction live, and what happens if it is ignored. A prompt binds for one turn and is forgotten. A project binds for a set of sessions because someone put a file in a folder. CLAUDE.md binds for a repository and is read every time, which makes it powerful and makes it a permanent tax on the window. A slash command binds only when called, which is the first time an instruction gets a trigger condition instead of a residency. A skill adds a description the model matches against, so the trigger becomes semantic rather than typed. Hooks are the discontinuity: everything above them is a suggestion the model may decline, and a hook is a process the harness runs whether the model likes it or not. That is the escalation, and it is not about verbosity. It is about bindingness.

CDelegation topology

How many agents, who reports to whom, who merges the result.

11 Sub-Agents → 19 Parallel Agents → 22 Orchestrator-Workers → 29 Agents Managing Agents → 30 Multi-Repo Orchestration

Delegation starts as a context trick and becomes an organisational chart. A sub-agent exists because the parent's window is finite: you send the search into a fresh context and get back a conclusion instead of four hundred lines of file dumps. Parallel agents are the same move widened, and the moment you widen it you inherit every problem a build system has ever had with concurrency. Orchestrator-workers names the shape that actually survives contact: one planner holding the scarce context, N workers holding none of it, and a merge step that is code rather than judgement. Agents managing agents is that shape with the planner's decisions themselves delegated, which mostly means you have handed away the budget. Multi-repo orchestration is the topology crossing an ownership boundary, where the question stops being how work is split and starts being who is allowed to push.

DExecution surface

Attended or unattended, interactive or headless, human in the loop or not.

6 CLI → 17 Background Agents → 18 Headless Runs → 28 Agent CI/CD

The CLI is a conversation you are present for, and almost every intuition people build in tier one is an intuition about being present: you will see the mistake, you will hit escape, you will notice the loop. Background agents remove your attention while keeping your machine. Headless runs remove the terminal altogether, and this is the real discontinuity, because a run with no human means every affordance you relied on has to become an exit code, a log line, or a machine-readable artifact. Agent CI/CD is the end state: a machine starts the run, a machine judges the output, and the only human in the loop is whoever reads the failure. Each step up removes a form of supervision, and every removal has to be paid for with something deterministic. That is why this line and line F are the same line viewed from different sides.

ETool surface and trust boundary

What the agent can reach, and who wrote the thing it is reaching.

5 API Keys → 6 CLI → 7 MCP Servers → 14 Skills → 26 Tool Poisoning

An API key is the first trust boundary anyone meets and almost nobody recognises as one: the credential is the perimeter, and its scope is the blast radius. The CLI widens the surface to whatever the shell can run. MCP servers widen it again and change its character, because now the tools are written by someone else and their descriptions are loaded into your model's context as instructions it will read. Skills bundle scripts alongside prose, so the same package that tells the model what to do can also hand it something to run. Tool poisoning is where the line stops being architecture and becomes an adversary: a tool description is untrusted input that arrives pre-approved. Note the interaction with line A, because it is the ugly one. Loading tool descriptions lazily saves tokens and means the string nobody read arrives after the human stopped watching.

FDeterminism wrapping stochasticity

The non-negotiable checks bolted around a probabilistic core.

15 Hooks → 16 Harness Engineering → 18 Headless Runs → 21 Eval-Driven Loops → 27 Self-Healing Tests → 28 Agent CI/CD

This is the line that makes the rest safe, and it is the line most curricula treat as plumbing. A hook is one deterministic check at one lifecycle point, and it is the smallest possible unit of the idea: the model proposed something, and a program decided. Harness engineering is that generalised into a shell, which is less a technique than a stance. Headless runs force determinism because there is nobody to interpret ambiguity. Eval-driven loops turn the binary gate into a score, which is what lets you compare two versions of a system rather than only rejecting one. Self-healing tests are where the line eats itself, and they need saying plainly: a test that rewrites its own assertion to pass has stopped being a check and become a very expensive way of printing PASS. Agent CI/CD is the whole line finally placed where it belongs, in front of the merge.

GFeedback loops

Measure, then feed the measurement back in.

3 Tokens → 12 Prompt Caching → 21 Eval-Driven Loops → 24 Memory Consolidation → 25 Self-Improving Loops

Count, rate, score, retain, rewrite. Token count is a measurement nobody acts on. Cache hit rate is the first measurement with an obvious action attached, and the action changes your prompt architecture rather than your prompt. Eval-driven loops are the point where measurement becomes a number you can regress against, and everything above tier four is unbuildable without one. Memory consolidation is a feedback loop pointed at the context itself: what proved useful is what gets kept. Self-improving loops close the circuit by letting the measured score select the next instruction set. The failure mode is at the top and it is Goodhart's, not a bug: an optimiser pointed at an eval will improve the eval, and whether it improved the system is a separate claim requiring separate evidence. Anyone who has watched a scored system get worse while its score went up already knows this line's real lesson.

HIsolation and parallel safety

Worktrees, sandboxes, branch topology, blast radius.

13 Git Worktrees → 17 Background Agents → 19 Parallel Agents → 22 Orchestrator-Workers → 30 Multi-Repo Orchestration

The thinnest line in the list by term count and the one that causes the most damage when skipped. A worktree is a second checkout of the same repository on a different branch, and it is the enabling primitive for every parallel thing that follows: two agents editing one directory is not a coordination problem, it is a corruption problem. Background agents need isolation for a different reason, which is that they run while you are also working and your uncommitted state is not their business. Parallel agents multiply the requirement. Orchestrator-workers formalises it, because a merge step only makes sense if the things being merged were separate. Multi-repo orchestration moves the boundary from directories to credentials and permissions, where the question is no longer whether two agents collide but whether one of them should have been able to push there at all.

Three collisions worth more than the sum

Places where learning two terms together produces something neither teaches alone. Each is justified by a specific failure that only appears in combination, because a collision you cannot demonstrate is a slogan.

1Prompt caching against progressive disclosure terms 12 and 20

The two most-recommended context optimisations are in direct tension, and applying both naively raises your bill while shrinking your context.

The failure that needs both

You adopt progressive disclosure to stop paying for tool schemas and skill bodies you are not using, and load them at the moment of need instead. Your average context length falls, which is what you were measuring, so you call it a win. Your spend rises. Caching prices a stable prefix once and a fraction thereafter, and it is a prefix, not a set: inserting anything mid-conversation invalidates the cache from the insertion point forward. Every efficient late load re-bills everything before it. Nobody catches this from either unit alone, because the caching unit says structure your stable content first and the disclosure unit says load late, and the reader hears two pieces of good advice rather than one contradiction.

What resolves it

Disclose late at the tail, cache hard at the head, and never let a late-loaded artifact land upstream of the cache breakpoint. Measure spend and context length together or you will optimise one into the other.

2Hooks against parallel agents and worktrees terms 15 and 19

A hook written for one agent becomes a source of nondeterminism the moment there are four.

The failure that needs both

The hook works perfectly for months. Then you fan out to four workers in four worktrees and gates start failing at random, passing on rerun, and never failing the same way twice. The cause is that hooks written under an implicit single-agent assumption reach for shared state: a lockfile, a package cache, a formatter run against the repository root rather than the worktree, a validation that reads the index instead of the tree it was invoked for. Worker two now passes or fails based on worker three's uncommitted work. Neither unit surfaces it, because the hooks unit assumes one agent and the worktrees unit assumes hooks are inert.

What resolves it

Every hook takes its working directory from the invocation rather than from the repository root, touches no shared mutable path, and is tested by running the same hook concurrently in N worktrees before you trust it in a fan-out.

3Eval-driven loops against self-improving loops terms 21 and 25

Pointing an optimiser at a score makes the score go up. Whether the system improved is a separate claim requiring separate evidence, and the loop cannot produce it.

The failure that needs both

Three generations in, the eval score is up eleven points and the system is worse. The loop found the cheap edges of your rubric: prompts that hit the graded keywords, answers shaped to the length the scorer rewards, cases the suite happens not to cover getting quietly worse because nothing measured them. This is Goodhart, and it is not a bug in either term. An eval alone is fine because nothing is optimising against it. An optimiser without an eval cannot run at all. Only combined do you get the specific failure of measurable improvement that is not improvement, and the thing that makes it dangerous is that every artifact the loop produces looks like evidence.

What resolves it

Hold out a set the optimiser never sees and score against it every generation. Report the gap between seen and held-out score as a first-class number, and treat a widening gap as the finding rather than as noise. This is the same discipline as an audit sample the auditee did not select.

What is load-bearing, and what is a name for something you already do

The read, term by term. A curriculum that treats all thirty as equally important is a curriculum nobody has used in anger.

load-bearing: Learning it changes what you build. Worth the full unit.
conditional: Load-bearing only when paired with a named prerequisite. Alone it is a hazard.
already doing: A name for something a working engineer is already doing. Build the commit, keep the unit short.
thin: More vibes than technique. The unit states the real underlying practice and stops.
umbrella: A label for the union of other terms rather than a technique of its own.
dangerous: The common reading of the term is a bad idea. The unit says so and gives the defensible narrower practice.

load-bearing · 13 of 30

2 Context Window tier 1, Noob · line A with B, C

The constraint every later term is a workaround for. Delegation exists because windows are finite; caching exists because refilling them costs money. Teach the limit and half the curriculum becomes obvious.

7 MCP Servers tier 2, Beginner · line E with A, B

A real protocol with a real trust boundary, and the moment you add a third-party server you have accepted the risk that term 26 describes nineteen terms later.

10 Model Routing tier 2, Beginner · line A with C, G

The cheapest large win in the list, and the first delegation decision anyone makes without noticing it is one. Route by measured task cost, not by vibes about which model is smarter.

12 Prompt Caching tier 2, Beginner · line A with B, G

Misplaced in tier 2. It forces a stable-prefix architecture, which you cannot have before you have a prompt architecture at all. Genuinely a tier 4 concern that pays tier 2 money.

13 Git Worktrees tier 3, Pro · line H with C, D

The enabling primitive for everything parallel. Nothing in tiers 4 and 5 is safe without it, and it is plain git that predates all of this by a decade.

14 Skills tier 3, Pro · line B with A, E

The first instruction package that is both semantically triggered and progressively disclosed. It is term 20 wearing a different hat, which is exactly the kind of overlap this matrix exists to surface.

15 Hooks tier 3, Pro · line F with B, E

The only term on the list that converts a suggestion into an enforcement. Everything in CLAUDE.md is advisory; a hook is a program. If a reader takes one thing from tier 3, this is it.

18 Headless Runs tier 3, Pro · line D with F, G, E

The boundary between a tool you use and a system that runs. Everything at tier 4 and 5 assumes it, and it is where ambiguity has to become an exit code.

20 Progressive Disclosure tier 4, Expert · line A with B, E

The actual scaling technique for context, and in direct tension with term 12. Learning either alone leaves you worse off than learning neither, which is why it is collision one.

21 Eval-Driven Loops tier 4, Expert · line G with F, D

Without this, tier 5 is vibes with a build step. An eval suite with a scored baseline is the single highest-value artifact in the whole repo.

22 Orchestrator-Workers tier 4, Expert · line C with A, H, F

The topology that survives contact. One planner holding scarce context, N workers holding none, and a merge that is code rather than judgement.

26 Tool Poisoning tier 5, Vibe-God · line E with F, A, B

Badly placed at tier 5. The exposure begins at term 7, the moment a third-party server is added, so the curriculum teaches the attack nineteen terms after the reader took the risk. This should be taught in tier 2.

28 Agent CI/CD tier 5, Vibe-God · line F with D, H, G

Gate agent output the way you gate human output, which mostly means refusing to make an exception. The technique is ordinary CI; the discipline is not treating a model's PR as pre-reviewed.

conditional · 1 of 30

25 Self-Improving Loops tier 5, Vibe-God · line G with B, F

Real, and worthless without term 21. An optimiser without an eval is a random walk with a larger bill. With one, it is collision three and its central hazard is Goodhart.

dangerous · 1 of 30

27 Self-Healing Tests tier 5, Vibe-God · line F with G, C

The most dangerous name on the list. A test that rewrites its assertion to pass has stopped being a test. The defensible practice is auto-triage: classify the failure, propose a diff, open a PR, require a human merge. Never auto-repair the assertion side.

thin · 4 of 30

4 Projects tier 1, Noob · line B with A

A product feature, not a technique: a folder with files and a standing instruction. It earns its slot only as the first time an instruction outlives a single turn. Two throughlines, honestly.

23 Ultrathink tier 4, Expert · line A with G

A knob, not an architecture: a token budget for reasoning. The real practice is spending more reasoning tokens where the branching factor is high, then checking whether the spend moved the eval score. Usually you cannot tell, and saying so is more useful than a chapter.

24 Memory Consolidation tier 4, Expert · line A with B, G

In practice this means writing a summary file. The real technique is a retention policy decided before the session and a rule for what earns a place, so retention is a scored decision rather than a vibe.

29 Agents Managing Agents tier 5, Vibe-God · line C with G, D

Orchestrator-workers with a longer leash and worse observability. The only genuinely new content is the budget and the kill switch, so the unit should be about those two things and be short.

umbrella · 1 of 30

16 Harness Engineering tier 3, Pro · line F with B, D, E

Not a technique, a name for the union of 15, 18, 21 and 28. The unit should say so and spend its words on the stance rather than pretending there is a separate skill here.

already doing · 10 of 30

1 Prompting tier 1, Noob · line B with A, G

You do this. The curriculum's job here is not to teach prompting, it is to establish the vocabulary the other 29 terms escalate from.

3 Tokens tier 1, Noob · line A with G, F

The unit. Worth exactly one commit that prints them on every run, because a number nobody sees is a number nobody optimises.

5 API Keys tier 1, Noob · line E with D, F

You have secrets management. The one genuinely new idea is that key scope is blast radius, which matters much later at term 30.

6 CLI tier 1, Noob · line D with E, B

You use a terminal. Its real role is to be the attended baseline that terms 17 and 18 take supervision away from.

8 CLAUDE.md tier 2, Beginner · line B with A, F

A README the harness reads on every turn. Useful, permanently priced into your context, and unable to enforce anything, which is the gap term 15 exists to close.

9 /commands tier 2, Beginner · line B with A, D

A shell alias with a prompt in it. The idea that matters is the trigger condition: an instruction that is not resident until called.

11 Sub-Agents tier 2, Beginner · line C with A, H

You have spawned one. The under-taught part is why: not to parallelise, but to keep four hundred lines of grep output out of the parent's window.

17 Background Agents tier 3, Pro · line D with H, C

A scheduled job with a model in it. The new content is failure handling: nobody is watching, so the interesting design is what it does when it is wrong.

19 Parallel Agents tier 4, Expert · line C with H, A

Fan-out. The technique is ordinary; the hazards are not, and they all live in throughline H.

30 Multi-Repo Orchestration tier 5, Vibe-God · line H with C, E

Mostly credential scoping and a dependency graph. The agent part is the easy part; the hard part is deciding which repository a given token may push to, which is term 5 grown up.

Where the tier list is wrong

Prompt caching sits at term 12 in tier 2 and belongs at tier 4. Tuning a hit rate requires a stable prompt architecture, and a tier 2 reader does not have one yet. It stays where the numbering puts it, and the unit says plainly that the reader is being handed a tier 4 lever early because it pays for itself immediately.

Tool poisoning sits at term 26 in tier 5 and belongs at tier 2. Exposure starts at term 7, when the first third-party MCP server is added. Teaching the attack nineteen terms after the reader accepted the risk is teaching the fire drill after the fire. The curriculum keeps the numbering and adds a forward reference from term 7 with the minimum defensive practice attached.

Harness engineering at term 16 is an umbrella over 15, 18, 21 and 28. It gets a commit because the repo needs the scaffold, and a short unit that says what it is a name for rather than pretending it is a separate skill.

What it costs and when it lands

A curriculum with no date attached is a curriculum nobody has costed. The hours below come from what each term’s verdict implies about the work, summed; the date comes from dividing them by a delivery rate lower than the booked one.

177hoursEstimated from what each verdict class implies, then summed.

7hours a week, delivered8 hours booked, 7 assumed delivered. A 3-4 AM block is a good block for writing and a fragile one for attendance, and a schedule that assumes every booked hour lands is a schedule that slips without ever admitting it.

2027-03-12forecast finish25.2 working weeks plus 3 lost to holidays, from 2026-08-21.

Hours, weeks and forecast end date for each tier.
Tier	Terms	Hours	Weeks	Ends	What it carries
1 Noob	1-6	30	4.3	2026-09-25	Most of the domain substrate lands here: DefiLlama discovery, PDF fetch, storage. The tier looks cheap by verdict and is not.
2 Beginner	7-12	36	5.1	2026-10-30	Three load-bearing terms plus the first interstitial, which needs a real token bill showing the spend going up.
3 Pro	13-18	37	5.3	2026-12-11	The heaviest tier. Four load-bearing terms, the synthesis chapter, and the hooks-against-worktrees reproduction that has to be flaky by construction.
4 Expert	19-24	32	4.5	2027-01-29	Evals and the held-out discipline, which every later gate reads. Two thin units keep the hours down.
5 Vibe-God	25-30	35	5	2027-03-05	The optimiser, auto-triage, CI, and the two-repo boundary. Gate 5 has to pass on a negative delta before this tier is done.
Book	book	7	1	2027-03-12	Preface, final ordering pass, and the full read-through against the built repo.

A load-bearing unit is 2 to 3 hours building the commit against real issuer documents, 45 minutes making the failure reproduce on demand, an hour writing, and half an hour verifying sharp edges against actual version numbers. A thin unit still ships its commit; only the writing shrinks.

Thanksgiving week and the two weeks around the new year, taken as lost rather than optimistically halved. A 15 percent rework allowance is inside the hours rather than appended to the date.

What moves this date

The estimate assumes issuer attestation PDFs stay reachable and roughly as inconsistent as they are now. A format change at a major issuer is a week.
Harness behaviour moves. Any unit citing a flag may need re-verification at publication, which is why every unit carries the version it was checked against.
Gate 4 is the schedule's real hinge. If the eval suite is not honest by mid-January, terms 25, 27 and 28 have nothing to measure against and Tier 5 stalls.

Derived from the hours, not chosen and then justified. If a tier runs long the date moves; the honest version of this line is that it is a forecast with a stated method, not a commitment.

Status, and what is not here yet

Stage 1. The scaffold: two repo skeletons, five failing gates, thirty empty units and a book that already builds. Two repository skeletons exist: reserve-registry, the engine that discovers issuers, fetches attestation PDFs, extracts fields and refuses to publish one it could not read, and reserve-registry-data, the published record it can open pull requests against but cannot merge. Five gate scripts run today and all five fail, each naming the file that is missing and the term that creates it. Thirty unit stubs and three interstitial stubs carry their throughlines, dependencies, build position and word budget in front matter, and nothing else.

The field manual already builds. Sixty-five pages of front matter, tier dividers and thirty empty units, assembled by pandoc and XeLaTeX from the same curriculum file this page renders, with the build failing on a dropped glyph or a missing term rather than shipping a book with a blank column in its central table. Proving that toolchain against empty stubs was deliberate: a book pipeline that fights you is a week-one problem, not a week-twenty-five one.

What is not here: any content. No unit is written, no commit is made, no gate passes. The tiers land in order, each shipping a layer that runs on its own, each term exactly one commit prefixed with its number, and no commit may break an earlier tier’s demo. The guide is assembled from the repository rather than written alongside it, so a code block that is not in a commit cannot appear in the book.

A personal project, in development. Nothing here is a product, a certification, or professional advice, and it is not affiliated with or endorsed by any employer or by any vendor whose tools it describes. Version numbers and harness behaviour move quickly; where the curriculum depends on a specific flag or path, the units will carry the version they were verified against. Research index.