Curricula: 8 learning tracks for different readers

Time: about 25 min reading + 40 min practice

The gist

A monolithic course is an 800-page book you hand to everyone: a beginner with no background, a developer with ten years of experience, someone inheriting a business, a high school student. Each of them either drowns in chapters that don't apply to them or skips the foundation they actually need.

A curriculum (a learning track) is a different approach. The set of materials stays the same. What changes is the reading route. Each audience gets its own order, its own set of chapters, its own expected time and outcome.

The main saving: you write the content once. Curricula are pointers to that content in the right order. Fix a mistake in one chapter, and all 8 tracks that use it are updated automatically.

🎨 Picture this: a subway map. One network of 54 stations. You can plot different routes through it: a tourist route (downtown + sights), a commuter route (home → office), a student route (dorm → campus). The stations are the same. The routes are different. Nobody builds a separate subway for each passenger.

Key concepts

• Layer book: one atomic layer of knowledge (one "station"). A file of 7–13 KB that covers one concept in depth. Examples: L1 LLM, L26 Claude Code, L38 Stripe payments
• Library: the catalog of all layer books. Random access. Read any of them in any order. This is the base of materials
• Curriculum: a sequential reading path. An ordered sequence of layer books for a specific audience. It's a route through the base, not a separate set of books
• Target audience: who the track is for. A beginner with no background. A developer who wants to ship an MVP. A successor 30 years from now. Without a clear audience, a curriculum is useless
• Prerequisites: what you need to read BEFORE (for example, c02 requires c01)
• Layers sequence: the ordered list of layer books in the right sequence. [L1, L2, L9, L26] ≠ [L26, L9, L2, L1]
• Recipes unlocked: practical "knowledge → income" recipes available after finishing the track
• Outcome: what the reader will be able to do afterward. Phrased as verb + object, not as "knows about X"
• Reuse principle: one layer is used in several curricula. L1 LLM appears in c01, c02, c06, c07. Change it once, and it updates everywhere
• Base and routes: the base (54 books) lives independently. The routes (8 curricula) are paths through the base. You can develop the base and the routes separately

Theory

Why a monolithic course doesn't work

The classic school model: one textbook per class. Everyone reads the same way, from the first page to the last. That works when the audience really is uniform (30 students of the same age at the same school).

In the real AI world, the audience is mixed:

• A beginner with no background wants to understand what an LLM is
• A senior developer wants to ship a SaaS in 4 weeks
• A local business owner in Ecuador wants to automate one specific workflow
• A content creator wants a post factory in Spanish
• Someone inheriting a business 30 years from now wants to understand what they were handed
• A person building their own AI system on Claude wants to master the Anthropic stack in depth
• Someone curious is thinking about AI trading
• A teacher is getting ready to launch their own online course

Give them all the same textbook, and either nobody finishes it or everyone wastes 80% of their time on things that don't apply.

🎨 Picture this: a hospital doesn't hand one long medical textbook to everyone. A cardiologist has their own route through anatomy (focused on the heart and blood vessels). An ophthalmologist has theirs (the eye and nerves). One base (the same Gray's Anatomy), different routes.

A curriculum as an ordered traversal

In graph terms:

• The library is a graph of 54 nodes (layer books). The nodes are connected by "see also", "prerequisite" and "deeper into" links.
• A curriculum is an ordered walk through a subset of the nodes. Not all 54, only the relevant ones. And not at random, but in an order that makes teaching sense.

Example for c02 SaaS MVP:

L1 (LLM foundation) → L9 (MCP/Skills/Hooks)
   → L25 (Cursor) → L26 (Claude Code)
   → L23 (Web Builders)
   → L37 (Supabase database) → L36 (Cloudflare hosting)
   → L38 (Stripe payments)
   → r14 (recipe: SaaS tool)

This order isn't random. First the foundation (what an LLM is and what the tools are), then code editors, then site builders, then the backend, then money. Each step builds logically on the one before.

If a reader goes L38 → L1 (Stripe first, LLM later), they won't understand why they need Stripe in the context of an AI product at all. Order matters for learning.

The curriculum schema

In the library this example comes from, each curriculum is described with YAML frontmatter:

---
id: c<NN>
title: "<title>"
target_audience: "<who it's for, in one sentence>"
duration: "<weeks> · <time/day>"
total_hours: <number>
prereqs: [c01, c02]  # or empty
layers_sequence: [L1, L9, L23, L25, L26, L36, L37, L38]
recipes_unlocked: [r07, r14]
outcome: "<what they'll be able to do afterward, as a verb>"
---

This is a machine-readable spec. You can:

• Generate a table of all curricula automatically
• Find "which curricula use L9" with a single grep
• Check an invariant: if L9 is rewritten, which curricula need a review

The 8 curricula from the example: an overview

Each track covers one real need, not "everything about everything".

Track c07 on AI trading teaches tools and gives an honest look at the risks. It doesn't promise returns and is not investment advice.

A close look at three contrasting curricula

To see how the same model works for different audiences, let's compare three tracks along one axis: layers sequence, pace, what's included and what's deliberately left out.

c01 Foundation (beginner, 2 weeks, 7 hours)

Layers: L1 LLM → L2 Models → L6 Prompting → L7 Context → L8 RAG.

This is the minimum set to understand 80% of AI. No L9 MCP (too early), no L26 Claude Code (too early), no L36–38 (deployment isn't needed before the foundation). 30 minutes a day is the rhythm for someone who has a job and for whom AI isn't priority #1.

Deliberately left out: code, tools, production. Understanding only.

c02 SaaS MVP (developer, 4 weeks, 28 hours)

Layers: L1 → L9 → L23 → L25 → L26 → L36 → L37 → L38.

L1 repeats here (it's also used in c01), but if the developer took c01 as a prereq, they can skip it. After the foundation we jump straight into tools: MCP/Skills/Hooks (Claude extensions), Cursor, Claude Code, web builders. Then the backend (Supabase) and payments (Stripe).

A pace of 60 minutes a day fits a working developer who sets aside an hour before or after work.

Deliberately left out: L6 Prompting (a developer already knows how to prompt), L7 Context (covered only lightly), deep theory. The goal is to ship a product, not write a dissertation.

c06 Successor (successor, 30 days, 50 hours)

Layers: L1 → L2 → L9 → L26 → L27 → L50 → L51 → L52 → L53 → L54.

There's an intersection with c01/c02 here (L1, L2, L9, L26): the same foundational layers. But after that comes a unique path: L27 and L50–54 are layers about architecture, portfolio detachability, the successor protocol and financial discipline.

90 minutes a day: the successor has most likely stepped away from their main job for a while to take the helm. They can set aside more time.

Deliberately left out: shipping a product (the successor doesn't need that right away), the specifics of a contractor business in Ecuador (that's c03), trading (that's c07). The goal is to run the system they were handed on their own.

🎨 Picture this: one human anatomy. The cardiologist's, ophthalmologist's and orthopedist's textbooks share some chapters (the skeleton, circulation). But after that, each goes into their own specialty. Nobody teaches an orthopedist about the cornea. That doesn't make the cornea "worse". It's just not for that profession.

Counterexample: one 30-hour "AI for everyone" course

To see the problem from the opposite side, picture a monolithic course. Let's call it MEGA-AI.

• 30 hours of material
• 50 lessons
• Audience: "everyone interested in AI"
• Outcome: "understanding AI and being able to apply it"

What happens to six real readers?

• The beginner (c01) drowns in the "Cloudflare Workers deployment" lesson: no foundation
• The developer (c02) gives up on the "What is a neural network" lesson: too basic, a waste of time
• The successor (c06) doesn't get the key chapters on the portfolio detachability pattern and the legacy protocol (they aren't there, because they're "not for everyone")
• The content creator (c04) doesn't find Spanish-language content practices
• The trader (c07) doesn't get honest warnings about the risks
• The educator (c08) doesn't learn how to build a course

MEGA-AI = a course "for everyone" = a failure for all six. Not because the author is bad. Because the audience isn't defined, so optimizing is impossible.

It's the same mistake as a universal "cures everything" drug. Medicine doesn't have those. Education shouldn't either.

Why 8 and not one universal course

Could you make one universal course? You could. It would be 50 hours long and fit nobody in particular.

Could you make 50 narrowly specialized ones? You could. But maintenance would wear you out: 50 files to keep in sync with the base.

8 is an empirical balance. Each track covers one real audience of the project; there's a specific person it was written for. Each is recognizable in 30 seconds from its target_audience. No duplicates (if c01 and c02 covered the same thing, we'd merge them).

🎨 Picture this: a big clothing store doesn't have ONE fitting room "for everyone". But it doesn't have 200 either (one per size × color × season). It has 8–12 sections: men's, women's, kids', sport, formal. Each solves a real task. Universal "clothing" doesn't work.

The reuse principle in practice

L1 LLM appears in:

• c01 Foundation (Module 1)
• c02 SaaS MVP (Week 1)
• c06 Successor (Day 8)
• c07 AI-trader (Week 1)

It's the same chapter. Not four copies. If someone finds a mistake in L1 (say, an API price is out of date or a new Claude model came out), you fix it in one file, and all 4 curricula get the update automatically.

If each course had its own copy of L1, you'd have to fix the mistake in 4 places. The chance that at least one of them is left with outdated information: 99%.

🎨 Picture this: a public library and a library card. There's one copy of War and Peace in the library. A thousand readers borrow it in turn. If pages get torn out, one librarian sees it and repairs it, and every reader after that gets the whole book. If everyone had their own copy, keeping them all intact would be impossible.

Base and routes: separating the layers

A two-level model:

Base (library):

• 54 layer books
• Atomic content
• Can develop independently
• Owner: the layer's author

Routes (views):

• 8 curricula
• Pointers + order + context for the audience
• Can develop independently
• Owner: the curriculum's author (often a different person)

The base and the routes change at different frequencies:

• The base is updated when reality changes (a new Claude model, a new tool)
• Curricula are updated when the teaching approach changes (a new reading order works better)

These changes don't block each other. The author of layer L26 doesn't need to ask 4 curriculum authors for permission to fix something. They get the update automatically and decide for themselves whether the track's structure needs to change.

Curriculum quality measures

A curriculum counts as good quality if it meets 3 criteria:

1. Time budget is realistic: you can finish it in the advertised time. If it says "2 weeks at 30 min" but actually takes 6 hours a day, the curriculum is broken.
2. Cold reader test: a stranger got through it without outside help. If every step requires googling or asking someone, the order is bad.
3. Outcome achieved: after finishing, the reader can do what the outcome promised. Not "knows the theory" but "can do it".

Without these three, a curriculum exists only on paper.

How to create a curriculum for your audience in 5 steps

Step 1: Define the target audience in one sentence. "A backend developer with 5+ years of experience who has never worked with LLMs and wants to ship an internal AI tool within a month." If you can't do it in one sentence, the audience is too vague.

Step 2: Define the outcome as a verb. "Launched a working internal AI tool with auth, access to company data and a Slack integration." Not "understands", not "learned", but "did".

Step 3: Inventory existing materials. Which layer books already exist? Do you need to create new ones? If you need more than 3 new ones, maybe the audience is too exotic or the base is incomplete.

Step 4: Order the layers for learning. Which reading order minimizes the reader's frustration? Each next layer should build on the previous ones. Test: can you skip any step? If yes, it's unnecessary.

Step 5: Validate with a real cold reader. Find a person from the target audience. Give them the curriculum without explanations. Time them. Check the outcome a week later. If all 3 criteria are met, the curriculum is ready.

🧪 Practice

The library/curricula/ and library/library/ folders live in the course author's working repository and haven't been made public. If you don't have them, do the tasks using this course's material: a "layer" here is one lesson, and a "curriculum" is a route through the lessons (the site has three such routes, see the course page). The grep commands in tasks 3 and 5 work on any folder with your files.

Task 1: Read an existing curriculum

Open any ready-made route: one of the three routes on the course page, or your own curriculum file if you already have one.

Check:

• Is the target audience stated in one sentence?
• Is the outcome phrased as a verb (what they'll be able to do)?
• Is the layers sequence listed explicitly in the frontmatter?
• Can you tell in 30 seconds whether it's right for you?

If all 4, the curriculum is written correctly.

Task 2: Design your own curriculum

Pick one of the audiences that doesn't have a track in your library yet:

• A designer who wants to master AI tools for their workflow
• A teacher who wants to bring Claude into their classes
• A journalist who wants to speed up research for articles
• A lawyer who wants to automate contract review

Create the file library/curricula/c09-<your-audience>.md with this structure:

---
id: c09
title: "<title>"
target_audience: "<one sentence>"
duration: "<weeks> · <time/day>"
total_hours: <number>
prereqs: []
layers_sequence: [L?, L?, L?]
recipes_unlocked: []
outcome: "<verb + object>"
---

# c09 · <Title>

## Program

### Week 1: <topic>
- Day 1-2 · Module 1: <Lxx Title> (X hours)
- ...

## Outcome
- ✅ <specific skill 1>
- ✅ <specific skill 2>
- ✅ <specific skill 3>

## Common pitfalls
- ...

Build on the materials you already have (in this course, the lessons). Don't create new content. Use what exists.

Task 3: Find reuse opportunities

In the terminal, run:

cd ~/my-library   # the folder with your materials
grep -rn "L1" library/curricula/ | grep "layers_sequence"

How many curricula use L1? If 4 or more, it's a heavily used layer. That means:

• The quality of L1 is critical (a mistake spreads to 4 tracks at once)
• An API change in L1 requires checking all 4 curricula
• L1 = the core foundation, not an expansion

Find the top 3 most reused layers. They're the core of your base.

Task 4: Cold reader test

Find a real person from the audience c01 is written for (a beginner with no AI background). Maybe a relative or a coworker.

Give them a link to the beginner route (on the course site, that's the "I use AI in my work" route, or your own c01). Don't explain anything yourself.

After 14 days, check:

• Did they finish? If they quit, at what stage and why?
• Can they explain the answers to 5 questions from the Final Test to a five-year-old?
• How many hours did they actually spend vs the promised 7?

Write the results to a file like curriculum-tests/c01-<name>.md. This is feedback for improving the track.

Task 5: Update a layer → check the curricula

Simulate an update to the base.

Open library/library/04-build/L26-claude-code.md. Say you've updated the information (a new version of Claude Code).

Run:

grep -l "L26" library/curricula/*.md

You'll get a list of the curricula that use L26. For each one, check:

• Does the reading order still make sense after the L26 update?
• Did any new prerequisites appear (for example, L26 now requires L9, but in the curriculum L9 comes after L26)?
• Did the completion time change (do you need to update duration)?

This is a maintenance ritual. Without it, the base and the routes drift apart, and the curriculum starts lying.

⚠️ Anti-patterns

❌ A curriculum without a target audience. "For everyone" = for nobody. If you can't picture a specific person, rewrite it.

❌ Duplicating content between the curriculum and the layer book. A curriculum holds only pointers + order + context. The content itself lives in the layer books. If you copy paragraphs from L1 into c01, you're creating maintenance hell.

❌ An outcome like "knows about X" instead of "does X". "Understands Stripe" is bad. "Connected Stripe Checkout to their app and processed the first payment" is good.

❌ A random order of layer books. If the order has no teaching purpose, it's not a curriculum, it's a random selection. Each step should prepare for the next.

❌ A curriculum nobody has finished. If zero cold readers have completed it, the curriculum exists only in your head. Until the first successful completion, it isn't valid.

❌ A time budget from the author, not the reader. "I could read it in 30 minutes" ≠ "30 minutes is realistic for a beginner". Test with the real audience, not with yourself.

❌ Too many curricula. If you have 50 tracks and each is used by one person, the base drowns in maintenance. Rule of thumb: 8–15 curricula for 50–100 layer books.

❌ Changing the base without checking the curricula. You rewrote L9, and curricula may have broken. Without grep + review = silent rot.

❌ A curriculum without prerequisites. If c02 requires an understanding of LLMs but doesn't list prereqs: [c01], c02-level readers will fall flat on day one.

🔗 Related

• Context management: advanced techniques: context engineering for long-form materials. A curriculum is a special case: how much context to give the reader per unit of time.
• RAG: Retrieval Augmented Generation: RAG and chunking. The same logic: atomic blocks of content + smart assembly for the request. Only here the "request" = the audience, and the assembly = the curriculum order.
• Knowledge Atlas: a map of knowledge: documentation as a base. A curriculum = a route through the documentation base. Same model, different object.
• 3-Tier Templates: solo, mid, corporate: the next lesson: how to choose a project's level of infrastructure based on its real load.

✅ Checkpoint

Before moving on to the next lesson, check:

• You understand the difference between the base (library) and a route (curriculum)
• You can explain why the reuse principle saves maintenance time
• You know the 3 criteria for a quality curriculum (time, cold reader, outcome)
• You've gone through the 5 steps of creating a curriculum for your audience
• You've created at least one draft c09-.md
• You can explain the "subway and routes" metaphor to a five-year-old

If 4/6 or more, move on to the next lesson. If fewer, reread the "Base and routes" section and do practice task 2.

Sources

• The course author's library: 8 example curricula (a working repository, not made public)
• Single-base principle: the DRY (Don't Repeat Yourself) principle from software engineering, applied to knowledge
• Pedagogical sequencing: Bloom's Taxonomy applied to technical learning
• Reuse pattern: software engineering DRY, applied to educational content
• Cold reader test: usability testing methodology (Krug, "Don't Make Me Think")
• Curriculum schema: the course author's internal convention for the track format (2026)

🎨 One last picture: a world atlas is the base. An "Italy in a week" tourist route is a curriculum. The atlas isn't rewritten for every new tourist. The route is pointers + order + context for a specific audience. Carta non est itinerarium.

→ Next lesson: 3-Tier Templates