# How to Actually Learn PAI + Claude Code > **A 6-week process guide grounded in cognitive-science research and verified practitioner sources. Pairs with the 10-step content curriculum in this folder.** > > Written for Teage Calvin, May 2026. Distilled from 4 parallel research agents (PAI sources, Claude Code community, pedagogy literature, contrarian practitioners) + the existing PAI scaffolding. --- ## What this is — and what it isn't The 10-step curriculum in this folder (`curriculum.js`) is **content** — what PAI is, what each subsystem does, the vocabulary you need. This guide is **process** — when to read what, what to ship per week, what to skip, what to do when you're stuck, how to know you're actually mastering it instead of feeling like you are. Both layers matter. Content without process is the trap nobody warns you about: you'll read the docs, build a skill, modify a hook, and feel productive — while shipping nothing real and losing concept depth (Anthropic's own research found AI-assisted users scored [17% lower on concept quizzes](https://www.anthropic.com/research/AI-assistance-coding-skills)). Process without content is what most generic "how to learn" guides give you. We need both. The 6-week schedule below pairs each week with one or two curriculum steps. Open the curriculum step in the study app while you work the week. Don't read this guide once and put it away — keep it open in a tab. --- ## The Trap — read this before Day 1 Four things every PAI/Claude Code learner gets wrong. They cost months. The research is unambiguous. ### Trap 1 — You will feel 40 points more productive than you actually are METR ran a randomized controlled trial in 2025 on experienced open-source developers using AI coding tools. The result: **AI-tool users took 19% longer** to complete real issues. They thought AI sped them up by 20%. Reality vs. self-perception delta: 39 points ([METR, July 2025](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/)). This bites everyone — including the people building these tools. The dopamine of "I just shipped a skill in 20 minutes" lies. The only honest metric is **artifacts other people use**. Ship-something-real-this-week beats ship-five-skills-nobody-needs. ### Trap 2 — Tuning your PAI install becomes the new refactoring nobody asked for I searched hard for a single 90-day positive retrospective on PAI. There isn't one. Every practitioner post on Daniel Miessler's PAI is 1-8 weeks in ([source: PAI sources research, May 2026](#sources)). The longest first-person account is [Kukuschi's 3-hour install pain log](https://github.com/danielmiessler/Personal_AI_Infrastructure/discussions/922) — "each terminal error is a wall." That asymmetry is the signal. Most people who go deep on PAI end up tuning the install instead of using it for real work. The indie-hacker community calls this "[generating code all day but never shipping](https://www.builtthisweek.com/blog/indie-hacker-productivity-tips)." Apply the same skepticism here: every hour you spend on hook authoring is an hour you're not spending on the thing PAI is supposed to help you ship. ### Trap 3 — You'll try to read the docs cover-to-cover before building anything Cal Newport's deep-work / deliberate-practice synthesis says the opposite: real projects under deadline pressure produce mastery faster than passive documentation reading ([Newport, *Deep Work*](https://calnewport.com/deep-work-rules-for-focused-success-in-a-distracted-world/)). The 70-20-10 corporate-L&D ratio everyone cites? Folklore. [Kajewski & Madsen 2012](https://web.archive.org/web/2026/https://www.td.org/content/atd-blog/70-20-10-where-is-the-evidence) found it has no defensible empirical foundation. What does have evidence: **interleaved daily exposure** to all 9 PAI subsystems beats weekly blocked focus on one. [Rohrer & Taylor's 2007 *Instructional Science* study](http://uweb.cas.usf.edu/~drohrer/pdfs/Rohrer&Taylor2007IS.pdf) showed a **3x retention gap one week later** (63% vs. 20%) for interleaved vs. blocked practice on procedurally similar material. PAI subsystems are exactly that — Algorithm calls ISA calls Skills fires Hooks. Touch all of them every day, in small doses. ### Trap 4 — You'll trust the AI's output without verifying [Anthropic's own research](https://www.anthropic.com/research/AI-assistance-coding-skills) found AI-using developers scored 17% lower on concept quizzes than peers who coded by hand. Concept-debt compounds. For a 19-year-old whose competitive advantage is supposed to compound for 40 years, that's a real tax. The fix: every time Apollo (or any agent) gives you an answer that affects something you'll commit to memory, **make it explain why** in your own words back. The Algorithm's [Verification phase](~/.claude/PAI/ALGORITHM/v6.3.0.md) exists for exactly this. Don't skip it just because nothing is on fire. --- ## Day Zero — before Week 1 Three moves before you start the schedule. Each ~30 minutes. ### 1. Locate yourself on the PAI Maturity Model Read [Daniel Miessler's PAI Maturity Model post](https://danielmiessler.com/blog/personal-ai-maturity-model). It maps capability across six dimensions (Context, Personality, Tool Use, Awareness, Proactivity, Multitask Scale) on a CH1 → AG1 → AS3 scale. Most people new to PAI sit at **AG1** (basic agentic use, working tool calls, some context) but compare themselves to **AS3** outputs (orchestrated multi-agent systems with rich Telos integration). That gap is demoralizing for no reason. Locate yourself honestly. The whole 6-week path is climbing one to two notches — not skipping to the top. ### 2. Pin a PAI version + snapshot `~/.claude/` [Issue #1141](https://github.com/danielmiessler/Personal_AI_Infrastructure/issues/1141) documents one user losing ~48 custom skills silently on a v4→v5 upgrade. [Discussion #754](https://github.com/danielmiessler/Personal_AI_Infrastructure/discussions/754) is the upgrade-pain anthology: "I'm spending most of my time with AI to manage the implementation of PAI." Before you change anything, snapshot: ```bash tar -czf ~/pai-snapshot-$(date +%Y%m%d).tar.gz ~/.claude/ ``` Note the PAI version (PAI 5.0.0 right now). Don't upgrade for 6 weeks. The point is to learn what's here, not chase a moving target. ### 3. Do the self-dump Daniel recommends On the [Cognitive Revolution podcast (Jan 2026)](https://www.cognitiverevolution.ai/pioneering-pai-how-daniel-miessler-s-personal-ai-infrastructure-activates-human-agency-creativity/), Daniel was explicit about the right onboarding move: *"Sit down and dump via dictation or writing or whatever you want to do... you're basically doing a telos assessment of yourself."* You already ran `/interview` (your TELOS is populated). But re-do the *dump* — open a notes app, set a 30-minute timer, and write everything you can about: who you are right now, what you're trying to build over the next 12 months, what would make this year a win. Don't edit. Just dump. Then re-read your `PRINCIPAL_IDENTITY.md` and `TELOS/MISSION.md`. Diff what you wrote from what's there. Update what's stale. > **Why this matters:** Daniel's most-quoted onboarding line across his writing is *"Without TELOS, your DA has nothing to optimize against"* ([PAI README](https://github.com/danielmiessler/Personal_AI_Infrastructure)). Apollo is only as useful as the Telos it's reasoning against. Garbage TELOS in, generic responses out. --- ## The Method — six evidence-backed moves These are the moves you make every week, in every session, regardless of which week of the schedule you're in. ### 1. Daily interleaved exposure to ALL nine subsystems The single highest-leverage research finding. [Rohrer & Taylor 2007](http://uweb.cas.usf.edu/~drohrer/pdfs/Rohrer&Taylor2007IS.pdf): interleaved practice produced 63% retention vs. 20% blocked, one week later, on procedurally similar content. PAI's nine subsystems (Algorithm, ISA, Skills, Hooks, Memory, Agents, Pulse, USER/Telos, Observability) interact constantly — your brain needs to keep reloading the discriminative cues between them. **Daily move:** at minimum, *read one paragraph* about every subsystem you haven't actively used today. The architecture summary at `~/.claude/PAI/DOCUMENTATION/ARCHITECTURE_SUMMARY.md` is a one-page navigation table — scroll through it daily. ### 2. Chunk at the interface boundary Chase & Simon's chess research ([Gobet & Simon 1998](https://pubmed.ncbi.nlm.nih.gov/9709441/)) showed experts store 50,000-100,000 *interface chunks* — not bigger working memory, better-organized retrieval units. For each PAI subsystem, the right chunk is **what it accepts and what it emits** — not the implementation, not a single function. **Concrete move:** for each subsystem you study, fill in two sentences: - *"X takes [these inputs] and produces [these outputs]"* - *"X depends on [Y, Z] and is depended on by [A, B]"* Write these to a sticky note. Your Skills sticky differs from your Hooks sticky in exactly the way they differ functionally. That's the chunk. ### 3. Reflect for 10 minutes after every Algorithm run Ericsson's deliberate-practice work ([Ericsson, Krampe & Tesch-Römer 1993](https://psycnet.apa.org/record/1993-40718-001)) identifies feedback + **reflection cadence** as the actual differentiator — not 10,000 hours, which Ericsson himself disowned. The Algorithm gives you rich pass/fail feedback (ISC criteria) and an audit trail. Most learners ignore both. **Concrete move:** after every Algorithm run that took more than ~5 minutes, open the ISA file and answer in writing: - What ISC was harder than I predicted? Why? - Which subsystem interaction surprised me? - What would I do differently next time? The reflection is the practice. The run is just the prompt. ### 4. Build under deadline pressure with feedback Newport's *[Deep Work](https://calnewport.com/deep-work-rules-for-focused-success-in-a-distracted-world/)* synthesis: programmers learn fastest when "responsible for projects of massive importance with hard deadlines beyond skill level." [Michael Carey's "How I'm Using AI in 2026"](https://michaelcarey.ca/blog/how-im-using-ai-in-2026/) makes the same point about PAI specifically: *"I highly recommend you install the PAI project from Daniel Miessler and modify it to fit your needs"* — the modification step is what most beginners skip. **Concrete move:** by Week 2, you should have a real artifact you're trying to ship that uses PAI. Not "learn PAI" — "use PAI to ship X by [date]." Examples: a custom skill that automates a specific weekly task you actually do; a hook that enforces a discipline you actually need; a study tool you'll actually use. ### 5. Make analogies explicit, not decorative [Gick & Holyoak 1980](https://pdf.retrievalpractice.org/transfer/Gick_Holyoak_1980.pdf): only ~10% of subjects spontaneously transferred a known solution to an analogous problem in a new domain — without an explicit cue. With the cue, transfer jumped dramatically. [Gentner's structure-mapping theory](https://groups.psych.northwestern.edu/gentner/papers/Gentner83.2b.pdf) explains why: transfer requires aligning *relational structure*, not surface features. **Translation for you:** "ISCs are like wrestling weight cuts" works because both have the same relational structure — hard binary threshold, no partial credit, public verification. "Skills are like wrestling moves" doesn't work — it's surface-similarity only. Every cross-domain anchor in the table below is structural, not decorative. ### 6. Pair every concept with a hand-drawn diagram Paivio's dual-coding theory ([Clark & Paivio 1991](https://nschwartz.yourweb.csuchico.edu/Clark%20&%20Paivio.pdf)) is among the most replicated effects in cognitive psychology. Verbal + visual encoding consistently beats verbal-alone for retention. Picture-picture > picture-word > word-word. **Concrete move:** for each subsystem, draw the data flow on paper (not on screen — paper is faster and forces compression). Algorithm phases as 7 boxes with arrows. ISA's twelve sections as a column. Memory layers as a stack. Keep these in a notebook. Re-draw them weekly. --- ## Daily 45-Minute Cadence This is the rhythm that makes the schedule below work. Same shape every day, every week. ### Morning — 10 minutes (active recall) - Open the pai-study app. Run 10 flashcards from yesterday's curriculum step (or the rotating step for today, see week schedule). - Then close your eyes and answer in your head: *"What did I learn yesterday that I couldn't have explained the day before?"* - One sentence. Write it on a sticky note. ### Mid — 25 minutes (build / modify / observe) - One micro-build session. Something concrete and small enough to finish in 25 minutes. - Examples by week: Week 1 — manually walk the Algorithm phases on a fake task; Week 3 — write a 5-ISC ISA for "make tea"; Week 5 — modify an existing skill's USE WHEN block and observe whether routing changes. - The build is not the point. The **observation** is the point. Note what surprised you. ### Night — 10 minutes (capture + reflect) - Append today's learning to `~/.claude/PAI/MEMORY/LEARNING/notes-{YYYY-MM-DD}.md` (or your study journal — file shape isn't sacred). - Answer two questions in writing: *What clicked today?* and *What's still fuzzy?* - The fuzzy items become tomorrow morning's predict-before-reading prompt. ### Why this shape works - **10 / 25 / 10** matches Pomodoro-adjacent attention research without imposing a rigid timer. - Active recall in the morning leverages spaced retrieval ([Roediger & Karpicke 2006](http://psychnet.wustl.edu/memory/wp-content/uploads/2018/04/Roediger-Karpicke-2006_PPS.pdf) — testing > re-reading by a wide margin). - Build in the middle hits Newport's deep-work window when your prefrontal cortex is fresh. - Night reflection writes to memory while it's still fresh enough to be honest about what didn't click. **45 minutes a day. Every day. Six weeks.** That's the entire commitment. --- ## The 6-Week Path Each week pairs with one to two of the curriculum steps in `pai-study/`. Open the curriculum tile in the study app on Day 1; do the flashcards on Day 7. Each week ends with a **ship deliverable** (something concrete that didn't exist before) and a **self-check** (binary, ISA-style — pass or fail, no fuzzy). --- ### Week 1 — Live in the Algorithm **Pairs with curriculum:** Step 1 (Foundations & Philosophy) + Step 2 (Instruction Hierarchy) **Wrestling anchor:** *Periodization.* You don't max-effort every week. Week 1 is base-building. The 6-week schedule is one full cycle. **The frame.** Most learners try to understand PAI top-down (read the architecture doc, then the Algorithm spec, then individual subsystems). Top-down for a 9-subsystem mesh is a slog because each piece references the others. Do bottom-up instead: live inside one Algorithm run end-to-end, and let the rest pull itself into focus. **Day-by-day:** - **Day 1:** Read [`PAI/ALGORITHM/v6.3.0.md`](~/.claude/PAI/ALGORITHM/v6.3.0.md) end-to-end. Predict before you read each section: "What do I think OBSERVE does?" Write your prediction. Then read. Diff. - **Day 2:** Walk a fake task through all 7 phases manually on paper. Use a mundane example: "make a grocery list for this weekend." Write the ISC criteria, the verification probe for each, the decisions. Don't run any tool — just walk it. - **Day 3:** Read 3 existing ISAs from `~/.claude/PAI/MEMORY/WORK/`. Pick the most recent, the most complex, and one labeled `phase: complete`. For each, identify the 12 sections and which ones are populated. - **Day 4:** Read [the Instruction Hierarchy section](~/.claude/PAI/PAI_SYSTEM_PROMPT.md) of the system prompt. Diagram the four-layer chain on paper: System Prompt → CLAUDE.md → @-imported files → dynamic context. Identify which layer has the strongest authority and why. - **Day 5:** Run one real Algorithm task at E2 (something you actually need to do — a small file edit, a config tweak). Watch yourself follow the phases. Don't optimize for output quality this run — optimize for *noticing* the phase transitions. - **Day 6 (catch-up + extension):** Re-read whatever didn't click. Or skip ahead to read [Daniel's December 2025 PAI post](https://danielmiessler.com/blog/personal-ai-infrastructure-december-2025) for the founder's framing. - **Day 7 (ship + self-check):** Run flashcards for Steps 1+2. Then write a 1-page summary in your own words: "What is the Algorithm? Why is it the gravitational center of PAI?" If you can't write it without referencing notes, you're not done — re-read the gaps tomorrow. **Ship deliverable:** A 1-page hand-written summary of the Algorithm + Instruction Hierarchy, plus your first walked-through fake-task ISA on paper. **Self-check ISCs (pass = all four):** - [ ] I can name the 7 Algorithm phases in order without looking - [ ] I can name the 12 ISA sections in order - [ ] I have walked one fake task through all 7 phases on paper - [ ] I have read 3 real ISAs from `MEMORY/WORK/` --- ### Week 2 — The Algorithm in Practice **Pairs with curriculum:** Step 3 (The Algorithm — Gravitational Center) **Poker anchor:** *Pot odds.* Each Algorithm phase asks: is the next move worth its cost? OBSERVE asks "what do I actually know?" before paying for THINK. PLAN asks "is the cheapest plan good enough?" before paying for BUILD. The phases are decision gates, not bureaucracy. **The frame.** The Algorithm doesn't slow you down — it speeds you up by killing rework. Most learners run it for the first time and feel the ceremony. By Day 5 of this week you should feel the opposite: skipping a phase costs more than running it. **Day-by-day:** - **Day 1:** Pick a real, multi-file task you'd otherwise just dive into. Stop. Run OBSERVE end-to-end manually — write the ISA section by section. Notice what you would have missed if you'd dived in. - **Day 2:** Same task — run THINK. Use the [closed-enumeration thinking capabilities list](~/.claude/PAI/ALGORITHM/v6.3.0.md) (FirstPrinciples, SystemsThinking, RootCauseAnalysis, etc.). Pick 4. Justify each. - **Day 3:** PLAN + BUILD + EXECUTE. Notice when you skip the inline-verification mandate. (You will.) Notice the cost. - **Day 4:** VERIFY + LEARN. Write the Verification entries by quoting actual command outputs, not "tests pass." Write the Changelog in conjecture/refutation/learning format. - **Day 5:** Read [Owen Fox's "Hooks, Subagents, Skills" guide](https://ofox.ai/blog/claude-code-hooks-subagents-skills-complete-guide-2026/) — best end-to-end advanced primer in the public Claude Code corpus. Note where his framing diverges from PAI's. - **Day 6 (catch-up):** If you only got through one full Algorithm run this week, run a second one — at a different effort tier this time. - **Day 7 (ship + self-check):** Flashcards + write your own version of "what the 7 phases are *for*" in 200 words. **Ship deliverable:** One real ISA with all 7 phases recorded, including a populated Changelog entry. **Self-check ISCs:** - [ ] I have one ISA at `phase: complete` with non-trivial Verification entries (real evidence, not "should work") - [ ] I have one Changelog entry in proper conjecture/refutation/learning format - [ ] I can name 4 thinking capabilities verbatim from the closed enumeration - [ ] I noticed at least one place where skipping a phase would have cost me --- ### Week 3 — The ISA as Test Harness **Pairs with curriculum:** Step 4 (The ISA — Five Identities of One Primitive) **Wrestling anchor:** *Weight cut.* An ISC is a wrestling weight cut. Hard threshold. No partial credit. Public verification. "I felt strong today" is not an ISC. "Bench 225 for 5 reps with full ROM, witnessed" is. **The frame.** The ISA is the primitive every other PAI subsystem revolves around. It's *simultaneously* the ideal-state articulation, the test harness, the build verification, the done condition, and the system of record. Most learners use it as documentation; experts use it as the test surface that makes everything else falsifiable. **Day-by-day:** - **Day 1:** Read [`PAI/DOCUMENTATION/IsaFormat.md`](~/.claude/PAI/DOCUMENTATION/IsaFormat.md) end-to-end. Then read the canonical example at `~/.claude/skills/ISA/Examples/canonical-isa.md` (BeanLine). - **Day 2:** Read 3 example ISAs at different tiers (E1, E3, E5) from the ISA skill's `Examples/` directory. Notice how the section depth scales with tier. - **Day 3:** Apply the **Splitting Test** to 5 ISCs from your Week 2 ISA. Are they atomic? If not, split them with stable IDs (ISC-7 → ISC-7.1, ISC-7.2). Practice the discipline. - **Day 4:** Write 5 anti-criteria for a real project of yours. (Anti-criteria are the regression-prevention probes — "Anti: /admin returns 200 in v1 build.") This is the discipline most learners skip. - **Day 5:** Write an ISA for one of your real life projects (your wrestling season target, your $5k summer goal, a class assignment). Use all 12 sections. Tier it E3 minimum. - **Day 6 (extension):** Read [the BeanLine canonical-isa.md](~/.claude/skills/ISA/Examples/canonical-isa.md) line-by-line. Notice what makes the Vision section land vs. fall flat. - **Day 7 (ship + self-check):** Flashcards + your own 5-sentence definition of "the five identities of the ISA." **Ship deliverable:** One personal-life ISA at E3+ with all 12 sections populated. **Self-check ISCs:** - [ ] I can name all five ISA identities (ideal-state articulation, test harness, build verification, done condition, system of record) - [ ] I have written ≥1 ISA with anti-criteria - [ ] I can apply the Splitting Test to a vague ISC and produce 2-3 atomic ISCs - [ ] I have one personal-life ISA, not just task ISAs --- ### Week 4 — Skills + Hooks (the composability turn) **Pairs with curriculum:** Step 5 (Skills) + Step 6 (Hooks & Lifecycle) **Flying anchor:** *Preflight checklist.* Hooks are checklists that fire automatically. You don't "remember to check the fuel gauge" — the checklist does. Skills are the maneuvers themselves; hooks are the discipline that makes maneuvers safe. **The frame.** This week is the composability turn. Skills are self-activating capabilities (USE WHEN routing); hooks are deterministic guards in the lifecycle. Together they're how PAI moves from "smart assistant" to "system that enforces standards." But — read [the eesel guide](https://www.eesel.ai/blog/hooks-in-claude-code) first: hooks are a maintenance tax. Add slowly, remove ruthlessly. **Day-by-day:** - **Day 1:** Read 5 existing skills end-to-end (`~/.claude/skills/*/SKILL.md`). Pick a mix: ISA, Sales, Research, Interceptor, CreateSkill. Diff their USE WHEN sections — that's the routing contract. - **Day 2:** Read 3 existing hooks (`~/.claude/PAI/hooks/*.hook.ts`). Pick: PromptProcessing, ISASync, SatisfactionCapture. Diagram which lifecycle event each binds to and what state it touches. - **Day 3:** Build your first custom skill. Pick something genuinely useful: maybe a `/wrestling-cut` skill that tracks weight, or a `/sales-rep` skill for practicing pitches. Use [`Skill("CreateSkill", "scaffold ...")`](~/.claude/skills/CreateSkill/SKILL.md). Get it to invoke at all. - **Day 4:** Optimize the skill's USE WHEN block. Test that it triggers on the queries you want and doesn't trigger on adjacent queries. ([OptimizeDescription workflow](~/.claude/skills/CreateSkill/SKILL.md) does this for you.) - **Day 5:** Read [Cat Wu (Anthropic Head of Claude Code Product) on Lenny's Podcast](https://www.youtube.com/watch?v=PplmzlgE0kg) for how the Claude Code team itself uses it. - **Day 6 (extension):** Build *one* hook — and only one. Pick: a Stop hook that runs `bun typecheck` on a project you care about. Don't build five hooks. One. Get it right. - **Day 7 (ship + self-check):** Flashcards + write a 1-paragraph "when do I reach for a skill vs. a hook?" test. **Ship deliverable:** One custom skill that works end-to-end + (optional) one custom hook. **Self-check ISCs:** - [ ] I have one custom skill at `~/.claude/skills//SKILL.md` that activates on the queries I expect - [ ] I can articulate the difference between skills and hooks in 2 sentences - [ ] I have read 5 existing skills and 3 existing hooks (not just listed them) - [ ] I can name the lifecycle events hooks bind to (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, SessionEnd, Compact) --- ### Week 5 — Memory + Agents **Pairs with curriculum:** Step 7 (Memory) + Step 8 (Agents & Delegation) **Finance anchor:** *Working capital vs. long-term reserves.* Memory layers map directly. WORK = working capital (current task state, ephemeral). LEARNING = reinvested earnings (recent reflections, harvest queue). KNOWLEDGE = long-term reserves (curated archive). You don't pull from KNOWLEDGE for daily ops; you don't dump WORK into KNOWLEDGE without harvesting. **The frame.** Memory is what makes PAI compound across sessions. Agents are how you parallelize cognition. Both are leverage primitives. Both are easy to over-use — most "agentic systems" papers are 3 agents pretending to be 30. Use them when they earn their cost. **Day-by-day:** - **Day 1:** Read `~/.claude/PAI/DOCUMENTATION/Memory/MemorySystem.md`. Identify the three layers and what flows between them. Run `bun ~/.claude/PAI/Tools/MemoryRetriever.ts "PAI"` to see BM25 retrieval. - **Day 2:** Walk your `MEMORY/LEARNING/` directory. Read 5 entries. Notice what the harvester captured vs. what you would have remembered. The gap is the value. - **Day 3:** Read `~/.claude/PAI/DOCUMENTATION/Agents/AgentSystem.md` and `~/.claude/PAI/DOCUMENTATION/Delegation/DelegationSystem.md`. Notice the delegation gate: *"Can I do this with Glob + Grep in under 30 seconds?"* - **Day 4:** Spawn one real research team — 3-4 parallel research agents on a topic you actually need to research (a class paper, a wrestling opponent scout, a stock you're considering). Use the multi-vendor pattern: Perplexity + Gemini + Claude or similar. - **Day 5:** Read [Nader Dabit's "Complete Guide to Building Agents with Claude Agent SDK"](https://nader.substack.com/p/the-complete-guide-to-building-agents). It's the bridge from "use agents" to "design agent systems." - **Day 6 (extension):** Run [`Skill("Knowledge", "harvest")`](~/.claude/skills/Knowledge/SKILL.md) and watch what it pulls into KNOWLEDGE. Curate one entry by hand to feel the difference. - **Day 7 (ship + self-check):** Flashcards + write the delegation rubric in your own words ("when do I spawn agents, when do I just grep?"). **Ship deliverable:** One real multi-agent research run on a non-PAI topic + one curated KNOWLEDGE entry. **Self-check ISCs:** - [ ] I can name the 3 memory layers and what flows between them - [ ] I have spawned ≥1 multi-agent research team on a real, non-PAI topic - [ ] I can articulate the delegation gate ("can I do this with Glob+Grep in 30s?") - [ ] I have read at least 1 file from each of WORK/, LEARNING/, KNOWLEDGE/ --- ### Week 6 — USER/Telos + Pulse + Capstone **Pairs with curriculum:** Step 9 (USER/ — Telos & Identity) + Step 10 (Pulse + Capstone) **Faith anchor:** *Permission to fail.* PAI's 17th founding principle. Same shape as grace — you commit to the hill-climb knowing you'll stumble, and the stumbling is part of the climb. Don't reach Week 6 thinking mastery means no errors. Mastery means you recognize errors faster and they cost less. **The frame.** Week 6 is the integration week. You've touched all 9 subsystems. Now you ship one thing that uses all of them — your capstone. And you do the honest assessment: are you more useful with PAI than without it? Be ruthless. The METR study reminds you the dopamine lies. **Day-by-day:** - **Day 1:** Re-read your `USER/PRINCIPAL_IDENTITY.md` and full `TELOS/` directory. Diff what's there from your Day-Zero dump. Update aggressively. Your Telos in May is not your Telos in October. - **Day 2:** Read `~/.claude/PAI/DOCUMENTATION/Pulse/PulseSystem.md`. Open `http://localhost:31337/`. Walk the dashboard. Notice what's there that you've never opened. - **Day 3:** Plan your capstone. The brief: *one thing PAI helps you do that produces a real artifact for a real audience this month.* Examples: a custom-skill-driven sales-call rehearsal tool that scores your filler words; a Pulse module that tracks your daily wrestling weight against your cut schedule; a custom agent team that researches a stock and produces a one-page memo every Sunday. - **Day 4:** Build the capstone. Use the Algorithm. Use ≥1 skill (custom or existing). Use ≥1 hook if it earns its place. Write the ISA *first*. - **Day 5:** Ship it. Use it for real today. Capture 3 things that surprised you (positive or negative). - **Day 6 (honest assessment):** Pull up the [METR study](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/) again. For your capstone: how long would this have taken without PAI? Be honest. If PAI saved you time, name how. If it cost you time, name how. Document in `MEMORY/LEARNING/`. - **Day 7 (final ship + self-check):** Flashcards across all 10 steps. Then write the *meta-retrospective*: what would you tell yourself at Week 1 Day 1? **Ship deliverable:** Your capstone, in production use. Your meta-retrospective, written. **Self-check ISCs:** - [ ] My capstone exists, runs, and I used it for real this week - [ ] My TELOS reflects me-now, not me-at-Day-Zero - [ ] I have an honest accounting of where PAI saved me time vs. cost me time - [ ] I have a written meta-retrospective for Week-1-me --- ## Cross-Domain Anchors (Gentner-validated only) Every anchor below has *genuine relational structure* — not surface similarity. Memorize the ones that resonate; ignore the ones that feel forced. | PAI concept | Anchor | Shared relational structure | |-------------|--------|------------------------------| | ISC criteria | Wrestling weight cut | Hard binary threshold, no partial credit, public verification | | 7 Algorithm phases | Wrestling periodization | Fixed phase sequence, each phase has its job, skipping phases costs you in competition | | ISA Verification | Wrestling film review | Evidence-based review of what actually happened vs. what you intended | | Memory layers | Finance: working capital → reserves | Liquidity tiers; you don't pull from KNOWLEDGE for daily ops | | Effort tier (E1–E5) | Finance: position sizing | Match the size of the bet to the conviction + stakes | | Delegation gate | Poker: pot odds | "Is the next move worth its cost?" — fold cheaply, raise on signal | | Cost of asking vs. cost of building | Poker: implied odds | The thing that's expensive isn't the call; it's the chain of calls it commits you to | | Hooks | Flying preflight checklist | Deterministic guards that fire before consequence; not optional | | Plan mode + interrupt | Flying go-around | "It's not landing right — abort, climb, set up fresh" — discipline > pride | | "Permission to fail" principle | Faith: grace | Commit to the climb knowing you'll stumble; the stumbling is part of the climb | | TELOS | Sales: pitch deck for yourself | The clearer the pitch, the better the routing; vague Telos = generic responses | | Skills with USE WHEN | Sales: prospect qualification | Routing is everything; bad routing wastes the rep, bad USE WHEN wastes the agent | When you study a new PAI concept, ask: which of these anchors fits the *relational structure* of what I'm learning? If none fit, don't force one — write the concept on its own terms. --- ## Anti-Patterns — Read This Weekly Drawn directly from the contrarian research. These are the moves that look productive and aren't. 1. **"I'll learn it all before I ship anything."** Newport says wrong; Ericsson says wrong; the entire indie-hacker community says wrong. Set a Week-2 ship date. Hit it. 2. **"Let me write 5 hooks first."** [eesel](https://www.eesel.ai/blog/hooks-in-claude-code): every hook is a script you maintain. PAI ships dozens. Add yours one at a time. Remove the ones that don't pull weight. 3. **"I'll trust the AI's output."** [METR](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/): you'll feel 40 points more productive than you are. Verify. Re-explain in your own words. Build the discipline now while the stakes are low. 4. **"I'll do the $200 Max plan immediately."** [Macaron](https://macaron.im/blog/claude-max-subscription-review): for the 1% of users. Stay on Pro until you can name three weekly artifacts that need higher limits. 5. **"I'll wholesale-import Daniel's TELOS."** PAI bakes in his worldview ("Human 3.0," "Euphoric Surprise" 9-10 ratings). It's not neutral. Rewrite your TELOS from your faith-first, wrestler's-discipline perspective. Use the structure; refuse the substance. 6. **"I'll wait until I understand it all."** The Maturity Model says you're at AG1 and that's fine. Build at AG1. Climb to AG2. Don't compare to AS3 outputs. 7. **"I'll let the agent implement the whole feature."** HN consensus across multiple top threads: ask for step 1, then step 2. Agents degrade in long autonomous runs. Plan mode → small step → verify → next step. 8. **"I'll upgrade PAI now to get the new feature."** [Issue #1141](https://github.com/danielmiessler/Personal_AI_Infrastructure/issues/1141): one user lost 48 skills silently in v4→v5. Pin your version through the 6 weeks. Snapshot before any upgrade. 9. **"I'll replace my whole development workflow with PAI."** [jdrolls Discussion #542](https://github.com/danielmiessler/Personal_AI_Infrastructure/discussions/542): PAI is built for "deep problem-solving at your terminal, not autonomous background operation." Use it where it's strong; don't force it where it isn't. --- ## Weekly Self-Check ISCs (Master List) Print this. Tape it next to your study setup. End of each week, mark each box honestly. Don't lie. The whole system breaks if you do. **Week 1 — Live in the Algorithm** - [ ] I can name the 7 Algorithm phases in order - [ ] I can name the 12 ISA sections in order - [ ] I have walked one fake task through all 7 phases on paper - [ ] I have read 3 real ISAs from `MEMORY/WORK/` **Week 2 — Algorithm in Practice** - [ ] I have one ISA at `phase: complete` with non-trivial Verification entries - [ ] I have one Changelog entry in proper conjecture/refutation/learning format - [ ] I can name 4 thinking capabilities verbatim from the closed enumeration - [ ] I noticed at least one place where skipping a phase would have cost me **Week 3 — ISA as Test Harness** - [ ] I can name all five ISA identities - [ ] I have written ≥1 ISA with anti-criteria - [ ] I can apply the Splitting Test to a vague ISC and produce 2-3 atomic ISCs - [ ] I have one personal-life ISA (not a task ISA) **Week 4 — Skills + Hooks** - [ ] I have one custom skill that activates on the queries I expect - [ ] I can articulate the difference between skills and hooks in 2 sentences - [ ] I have read 5 existing skills and 3 existing hooks - [ ] I can name the hook lifecycle events **Week 5 — Memory + Agents** - [ ] I can name the 3 memory layers and what flows between them - [ ] I have spawned ≥1 multi-agent research team on a real, non-PAI topic - [ ] I can articulate the delegation gate - [ ] I have read at least 1 file from each of WORK/, LEARNING/, KNOWLEDGE/ **Week 6 — Capstone** - [ ] My capstone exists, runs, and I used it for real this week - [ ] My TELOS reflects me-now, not me-at-Day-Zero - [ ] I have an honest accounting of where PAI saved me time vs. cost me time - [ ] I have a written meta-retrospective --- ## Pairing with the pai-study App Run the curriculum step in the study app on the *first* day of each week (Day 1 reading) and the flashcards on the *last* day (Day 7 review). The schedule: | Week | Curriculum step(s) in app | |------|---------------------------| | 1 | Step 1 (Foundations) + Step 2 (Instruction Hierarchy) | | 2 | Step 3 (The Algorithm) | | 3 | Step 4 (The ISA) | | 4 | Step 5 (Skills) + Step 6 (Hooks) | | 5 | Step 7 (Memory) + Step 8 (Agents) | | 6 | Step 9 (USER/Telos) + Step 10 (Pulse + Capstone) | The highlight tool you added to the study app this week is built for exactly this: as you read each step, mark the 3-5 sentences that are load-bearing for you. Cyan for "core concept I must own," yellow for "concrete example to come back to," pink for "I'm confused — return to this." Use the Expert Depth Module at the end of each curriculum step **only after you've shipped the week's deliverable**. The depth module is the test, not the path. --- ## Sources All URLs verified reachable on 2026-05-12. **PAI-specific:** - [Daniel Miessler — Building a Personal AI Infrastructure (December 2025)](https://danielmiessler.com/blog/personal-ai-infrastructure-december-2025) — *#1 newbie mistake: bad tool descriptions* - [Daniel Miessler — A Personal AI Maturity Model](https://danielmiessler.com/blog/personal-ai-maturity-model) — *the CH1→AG1→AS3 map* - [Daniel Miessler — Building Your Own Personal AI Infrastructure](https://danielmiessler.com/blog/personal-ai-infrastructure) — *TELOS-before-tools doctrine* - [The Cognitive Revolution — Pioneering PAI (interview with Daniel Miessler, Jan 2026)](https://www.cognitiverevolution.ai/pioneering-pai-how-daniel-miessler-s-personal-ai-infrastructure-activates-human-agency-creativity/) — *the dictation onboarding move* - [PAI GitHub repo](https://github.com/danielmiessler/Personal_AI_Infrastructure) - [Discussion #922 — Gap Between Vision and Reality (Kukuschi)](https://github.com/danielmiessler/Personal_AI_Infrastructure/discussions/922) — *the 3-hour install pain log* - [Discussion #754 — PAI Upgrade Woes](https://github.com/danielmiessler/Personal_AI_Infrastructure/discussions/754) - [Discussion #542 — Comparing PAI and OpenClaw (jdrolls)](https://github.com/danielmiessler/Personal_AI_Infrastructure/discussions/542) — *PAI's actual scope* - [Issue #1141 — v5 silently loses custom skills](https://github.com/danielmiessler/Personal_AI_Infrastructure/issues/1141) - [Jon Roosevelt — Building on Giants](https://jonroosevelt.com/blog/building-on-pai) — *the convergence story* - [Michael Carey — How I'm Using AI in 2026](https://michaelcarey.ca/blog/how-im-using-ai-in-2026/) — *the modification step beginners skip* **Claude Code learning:** - [Anthropic — Claude Code Quickstart](https://code.claude.com/docs/en/quickstart) - [Anthropic — Hooks](https://code.claude.com/docs/en/hooks) - [Anthropic — Skills](https://code.claude.com/docs/en/skills) - [Anthropic — Sub-agents](https://code.claude.com/docs/en/sub-agents) - [Anthropic Skilljar — Claude Code in Action (free 4-module course)](https://anthropic.skilljar.com/claude-code-in-action) - [Owen Fox — Hooks, Subagents, Skills Complete Guide (2026)](https://ofox.ai/blog/claude-code-hooks-subagents-skills-complete-guide-2026/) - [Cat Wu (Anthropic Head of Claude Code Product) on Lenny's Podcast](https://www.youtube.com/watch?v=PplmzlgE0kg) - [Nader Dabit — Complete Guide to Building Agents with Claude Agent SDK](https://nader.substack.com/p/the-complete-guide-to-building-agents) - [hesreallyhim/awesome-claude-code](https://github.com/hesreallyhim/awesome-claude-code) — *43.4k-star curated list* - [ykdojo/claude-code-tips](https://github.com/ykdojo/claude-code-tips) — *45 actively-maintained practitioner tips* **Pedagogy & cognitive science:** - [Rohrer & Taylor 2007 — The shuffling of mathematics problems improves learning (PDF)](http://uweb.cas.usf.edu/~drohrer/pdfs/Rohrer&Taylor2007IS.pdf) — *interleaving 3x retention finding* - [Bjork & Bjork 2011 — Desirable Difficulties (PDF)](https://bjorklab.psych.ucla.edu/wp-content/uploads/sites/13/2016/04/EBjork_RBjork_2011.pdf) - [Roediger & Karpicke 2006 — The Power of Testing Memory](http://psychnet.wustl.edu/memory/wp-content/uploads/2018/04/Roediger-Karpicke-2006_PPS.pdf) - [Ericsson, Krampe & Tesch-Römer 1993 — Deliberate Practice](https://psycnet.apa.org/record/1993-40718-001) - [Cal Newport — Deep Work](https://calnewport.com/deep-work-rules-for-focused-success-in-a-distracted-world/) - [Gentner 1983 — Structure-Mapping (PDF)](https://groups.psych.northwestern.edu/gentner/papers/Gentner83.2b.pdf) - [Gick & Holyoak 1980 — Analogical Problem Solving (PDF)](https://pdf.retrievalpractice.org/transfer/Gick_Holyoak_1980.pdf) - [Clark & Paivio — Dual Coding Theory](https://nschwartz.yourweb.csuchico.edu/Clark%20&%20Paivio.pdf) - [70:20:10 — Where Is the Evidence? (ATD critique, archive.org)](https://web.archive.org/web/2026/https://www.td.org/content/atd-blog/70-20-10-where-is-the-evidence) — *the model is folklore* **Contrarian / honesty:** - [METR — AI Slows Down Experienced Developers (RCT, 2025)](https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/) — *the 40-point self-perception delta* - [Anthropic — How AI Assistance Impacts Coding Skills](https://www.anthropic.com/research/AI-assistance-coding-skills) — *17% concept-quiz drop* - [eesel AI — Hooks in Claude Code](https://www.eesel.ai/blog/hooks-in-claude-code) — *the maintenance tax* - [Mehul Gupta — Claude Code is Shitty, Overhyped (archive.org)](https://web.archive.org/web/2026/https://medium.com/data-science-in-your-pocket/claude-code-is-shitty-overhyped-0acd8c8ae88d) - [Macaron — Is Claude Max Worth It?](https://macaron.im/blog/claude-max-subscription-review) - [BuiltThisWeek — Indie Hacker Productivity Tips](https://www.builtthisweek.com/blog/indie-hacker-productivity-tips) **PAI internal references (open these in your editor):** - `~/.claude/PAI/ALGORITHM/v6.3.0.md` — current Algorithm doctrine - `~/.claude/PAI/DOCUMENTATION/IsaFormat.md` — ISA format spec - `~/.claude/PAI/DOCUMENTATION/PAISystemArchitecture.md` — full architecture - `~/.claude/PAI/DOCUMENTATION/ARCHITECTURE_SUMMARY.md` — one-page navigation - `~/.claude/skills/ISA/Examples/canonical-isa.md` — the BeanLine showpiece ISA --- ## One-Sentence Takeaway PAI mastery isn't reading every doc — it's spending 45 minutes a day for 6 weeks running real Algorithm cycles, shipping one custom skill, and writing weekly self-checks honest enough to catch the 40-point productivity-delusion the research says you'll feel. --- *Generated 2026-05-12. Update this guide when your Week-6 retrospective surfaces something the next iteration should know. Living document — every cycle through it should leave it sharper.*