Detailed content
This is the module on reference from Track 1. You don’t need to memorize everything: read it once to recognize the terms, and come back here whenever a word appears “out of nowhere” in a technical track. The rule for each entry is simple— a concrete sentence + an everyday analogy.
🪪 Identity & CLAUDE.md
📖 What is Identity?
In one sentence: is who the OS is, whom it serves, and what it must never refuse.
Analogy: the job description you give a new assistant on day one — without it, they're capable but lost.
Identity lives in a concrete file: the CLAUDE.md. It's a plain text file (format Markdown — only text with a few symbols) that the harness — the terminal program that gives AI hands, like the Claude Code — read first, before anything else. That's why the author calls the CLAUDE.md of “the soul file.”
📖 What is CLAUDE.md?
In one sentence: the Identity soul file, read before anything else, where the OS’s identity lives.
Analogy: the first page of the house manual—who lives here, the house rules, what never to do.
| Goes in the CLAUDE.md | Concrete example |
|---|---|
| Who you are | "I’m a wedding photographer, and I work alone." |
| Who it's for | "This OS serves me; clients never see it." |
| What never to refuse | "Never refuse to help draft contracts." |
Why learn
Because Identity is the first layer of everything (Track 2, Module 2.1, is dedicated to it). If you recognize the term now, you won’t get stuck later when the course says “write your concise CLAUDE.md.”
Key concepts
🗃️ Substrate vs. Context
📖 What is Substrate & Context?
In one sentence: is all the domain knowledge—the raw material, history, documents, and data the OS relies on.
Analogy: the kitchen behind the scenes—the pantry, the annotated recipes, the inventory the customer never sees, but without which the dish never gets made.
It’s worth separating two meanings that are often confused. The Substrate is everything stored on disk—the entire domain knowledge base. The Context is the portion of that material that actually enters the model’s "window" during a conversation. Since the window is limited, you store a lot (substrate) and inject a small, carefully chosen amount (context).
| Substrate | Context | |
|---|---|---|
| What it is | everything that's on disk | what enters the conversation |
| Size | big, always growing | small, limited by the window |
| Analogy | the entire pantry | the ingredients on the counter now |
💡 Why the distinction matters
"The dumpster fire" (Module 2.2) is precisely the messy substrate. Organizing it before connecting the AI is what lets you inject only what matters into the context — without wasting the window on noise.
Why learn
Because in many domains, this layer is the biggest slice of the pie. Confusing “store everything” with “inject everything” clogs the context and makes the answers worse. This distinction teaches you to separate the archive (substrate) from what you serve (context).
Key concepts
🚧 Rule vs. Hook
This is the most important pair not to confuse. Both are used to impose limits, but they have different strengths: a rule asks, a hook requires.
📖 What Is a Rule?
In one sentence: a suggestion strong to the model—it almost always obeys, but there's no guarantee.
Analogy: a sign that says "do not enter." It convinces almost everyone, but doesn't physically stop them.
📖 What is a Hook?
In one sentence: one action deterministic that always (or never) happens — it's not the model's opinion; it's code.
Analogy: a locked door. No matter what you want, it won't open.
| Rule (rule) | Hook (hook) | |
|---|---|---|
| Strength | probabilistic (almost always) | deterministic (always/never) |
| Where it lives | text in rules/ | code (e.g., settings.json, pre-commit) |
| Use for | tone, preferences, best practices | what must NOT fail (PII, money, database writes) |
💡 The rule of thumb
Deterministic where it matters. If an error is costly—leaking personal data, deleting a table, sending the wrong amount of money—don’t trust a “soft” rule: use a hook. For everything else (style, tone, order of preference), the rule is enough.
Why learn
Because Track 2 (Module 2.3) is entirely about grading rules and installing hooks. Confusing the two leads you to trust a sign when you needed a locked door—and that’s how costly accidents happen.
Key concepts
🧩 Skill (ability)
📖 What Is a Skill?
In one sentence: a repeatable task, packaged to run the same way every time — a single "verb" the OS knows how to execute.
Analogy: a recipe card. The same steps, in the same order, producing the same dish whenever you follow them.
No Claude Code, a skill usually looks like a slash command — a command that starts with a slash, like /resumo. You trigger the verb by name, and it runs the process you packaged. The author reinforces a central idea: start manual (do it by hand first), capture the steps afterward, and never stop refining.
✓ Good skill candidate
- ✓Something you already do by hand and repeat often.
- ✓Stable steps with a predictable result.
- ✓It’s worth packaging because it saves real time.
✗ Bad skill
- ✗Something you’ve never done by hand (you don’t know the steps).
- ✗Writing 10 at once without using any of them.
- ✗Treat it as "ready"—a skill is never finished.
Why learn
Because skills are the first “action” layer (Track 3, Module 3.1). Knowing that a skill is a repeatable verb—and that you start manually—helps you avoid the classic mistake of trying to automate something you don’t understand yet.
Key concepts
🤖 Agent
📖 What is an Agent?
In one sentence: a sheet of paper with judgment that chooses which skills to use, in what order, usually with a review gate before anything goes out.
Analogy: the chef who chooses the right tool, puts the dish together, and tastes it before sending it to the table—unlike the recipe card (skill), which only performs one step.
The difference from a skill is the key: the a skill is a verb (does one thing); the an agent is a worker (decides which verbs to use). That’s why the agent is the final layer—it needs skills to orchestrate. And it’s only worth promoting a routine to an agent if you already does by hand today.
| Skill | Agent | |
|---|---|---|
| It’s a… | verb (1 task) | role (decides tasks) |
| Judgment | none — just executes | chooses and orders |
| Analogy | recipe card | the chef |
Why learn
Because “agent” is the word that creates the most excitement and the most confusion. Defining agent = chef (judgment) and skill = recipe (execution) immunizes you against the number one mistake in Module 1.2—jumping to agents before you have skills.
Key concepts
🔌 Skill vs CLI vs MCP vs API
These are the four ways the OS can “interact with the world”—and knowing when to use each one is one of the course’s central questions (Module 3.2). They range from the most “yours” (a skill you package yourself) to the most external (a service’s raw API).
How to read: from left to right, you go from what’s “very much yours” (a Skill that packages your way of doing things) to what’s “purely external” (the service’s raw API). The CLI is in the middle: you build it on top of an API for lean—and secure—control.
| Term | In one sentence | Analogy | When to use |
|---|---|---|---|
| Skill | repeatable verb that you package | the house style | your own process, without needing an external service |
| CLI | command-line program for a service | lean remote control | when you want control (and read-only security) |
| MCP | protocol that connects AI to a tool | power adapter | quick, default context (less relevant over time) |
| API | a service’s data door | the building's service entrance | the foundation — you usually wrap it in a CLI |
🌱 New here?
CLI = "command-line interface," a program you operate by typing commands. MCP = "Model Context Protocol," a standard way to plug tools into AI. API = "application programming interface," the gateway programs use to request data from a service. You don't need to know how to program either one now—just recognize what each acronym means.
Why learn
Because the question “skill, CLI, MCP, or API?” comes up every time the OS needs to interact with something external. With this framework in mind, you choose intentionally—and understand why the author prefers read-only CLIs for dangerous operations.
Key concepts
💎 Nugget · context rot · reverse meta-prompting
Three terms the author says that "most people ignore" — and that separate an amateur OS from an OS that stays alive. Each comes with its own phrase and analogy.
Nugget
A highly distilled summary (about 10 bullets) of the raw material, ready to inject into context.
Analogy: the reduced broth — concentrated, without the water.
Context rot
Context decay: the point at which information gets old and needs to be updated.
Analogy: food with an expiration date — at some point it goes bad.
Reverse meta-prompting
Ask the AI, at the end of a session, to distill the conversation into a reusable skill.
Analogy: write the recipe after you’ve already cooked.
💡 How the three connect
You distill the material into nuggets, monitors the context rot to know when to update them, and uses reverse meta-prompting to turn what you learned into a skill—instead of rewriting everything from scratch next time.
Why learn
Because these are the concepts that keep the OS “cultivated” (Module 1.1) instead of letting it rot. They show up again in Track 5 (production): synthesis cron jobs, domain-specific cutoffs, and post-session summaries all come from here.
Key concepts
📦 raw vs synthesized
📖 What is raw vs. synthesized?
In one sentence: you keep the raw material in a folder raw/ (just in case) and injects only the distilled version—the nuggets—of a folder into the OS synthesized/.
Analogy: pantry (raw, stored) vs. finished dish (distilled, served). You cook from the pantry, but serve only the dish.
The author's golden rule is just one sentence: "inject only the nuggets". The raw material (full transcripts, long PDFs) stays stored, but never goes straight into the context—because it would clog the window with noise. A cheaper model (a "workhorse," like Gemini Flash) loops through the raw material and summarizes it into nuggets.
How to read: the raw input comes in on the left and is stored; the workhorse model reduces it to nuggets; and only the nuggets cross the final arrow into the context. The folder raw/ never feeds the model directly — it's the safety net, not an ingredient in the dish.
Why learn
Because “raw → synthesized → injected” is the data pattern that repeats in EVERY domain of the course. Locking it in now makes Track 2 (Substrate) and Track 5 (production) feel obvious—you already know to store a lot and inject a little.
Key concepts
✅ Module summary
Next track:
Track 2 · Technical I — start with Identity (2.1), the first true layer. 🪪