Capstone — Ship your agentic system.

Lessons in this module CORE + RECIPE

Work through these in order. Each lesson produces one frozen capstone artifact or one practiced discipline — scoping, architecting, building in isolation, integrating under observation, or shipping. By Lesson 10.5 the capstone folder is frozen and the course is complete.

1. 10.1   Scoping the capstone: the three-shape rule.

   Mostly CORE

   The scoping lesson. The most common capstone failure mode is not that the student builds the wrong thing — it is that the student builds an evolving thing, whose definition changes every few days, whose three components become five and then two, whose audience slides from “only me” to “also my family” to “also my friend’s family.” The charter is the cure: one to two pages, written in your own voice, naming what the system is, who it serves (only you), the three integrated components by shape (scheduled, coding, research-or-inbox, or custom skill — three of these four), the data classes it touches, and the explicit out-of-scope list. You pass the Capstone scope check HTML activity (7/7) and freeze /capstone/capstone-charter.md as the first of Module 10’s four frozen artifacts.

   Open Lesson 10.1 →

2. 10.2   Architecture, posture inheritance, and the freeze.

   Mostly CORE

   The architecture lesson. The charter answers what; the architecture answers how. You translate the charter into a six-section document — inventory, data flow, trust boundaries, schedule and cadence, cost estimate, posture amendments — detailed enough that a reviewer who has not seen the charter could guess it back from the architecture alone. You draw the system diagram (three components connected by shared-state arrows, trust boundaries marked at every untrusted edge), inherit the Module 9 posture without revision (noting any amendments the capstone requires), inherit the Module 8 shared-state pattern and kill switch, and write a first-pass cost estimate against the monthly budget. Freeze /capstone/capstone-architecture.md as the second Module 10 artifact.

   Open Lesson 10.2 →

3. 10.3   Build sprint: ship each component in isolation.

   Mostly RECIPE · longest lesson in the course

   The build lesson. A week-one mistake that ends more capstones than any other is starting with integration — all three components firing at once, their outputs tangled, the failure mode crossing component boundaries. The Lesson 10.3 discipline is isolation first, integration later: each of the three components is built as a standalone program with its own folder, its own entry point, its own input and output path, and its own smoke test (a quick first-run check that confirms the component is alive) — before any wiring is attempted. You set up /capstone/pipeline-v1/ with the standard subfolder layout, build components A, B, and C (resisting the urge to factor a shared helper until the second component actually needs it), and replace the first-pass cost estimate from Lesson 10.2 with a measured cost built from one real invocation of each component. End-state: three components, three green smoke tests, three one-paragraph READMEs, ready for integration.

   Open Lesson 10.3 →

4. 10.4   Integrate, observe, harden.

   CORE + RECIPE · the seven-day window

   The integration-and-observation lesson. You wire the three standalone components into one pipeline using the Module 8 shared-state pattern (components communicate through files in /capstone/pipeline-v1/shared-state/, never through direct calls), then fire the kill switch on purpose to prove it works — a kill switch that has never fired may not work. You run one of four incident drills (leaked key, runaway pipeline, drafted-but-unauthorized action, successful prompt injection) end-to-end against your own pipeline, write the after-action note to /capstone/incident-drill-afteraction.md, and then operate the pipeline live for seven consecutive calendar days under the posture, logging each run to observation-log.md. A posture violation mid-window restarts the count. End-state: one clean seven-day window, a complete observation log, and the kill-switch timing recorded.

   Open Lesson 10.4 →

5. 10.5   Document, demo, and ship.

   CORE + RECIPE · the shipping ritual

   The shipping lesson and the course close-out. A capstone that is not shipped is a capstone that does not close. You write /capstone/capstone-final.md — a ten-section consolidated document a reviewer can read in ~15 minutes — record the 3–5 minute screen-recording demo (one-sentence explanation, end-to-end run, three components named as they fire, one intentional failure plus recovery, closing “what I would do next”), write capstone-reflection.md against five prescribed prompts, work with the parent to complete the hours log and transcript language in /ops/credit-documentation.md, and receive the one-paragraph written sign-off from the reviewer. Freeze the capstone folder, tag the git commit capstone-frozen-YYYY-MM-DD, and close the course.

   Open Lesson 10.5 →

---

Resources for this module RECIPE

Eight printable companions and one interactive activity run alongside the lessons. Each printable is a print-to-PDF page that prints cleanly on letter paper; each one maps to the lesson whose deliverable it scaffolds. Use them in the order their lessons reference them.

• Capstone charter template — printable for Lesson 10.1. A six-section template for the frozen charter: purpose, audience, the three components by shape, data classes touched, explicit out-of-scope list, and the freeze header. The document you copy into /capstone/capstone-charter.md and fill in during Lesson 10.1.
• Capstone architecture template — printable for Lesson 10.2. A six-section architecture scaffold (inventory, data flow, trust boundaries, schedule and cadence, cost estimate, posture amendments) with the posture-inheritance block pre-wired and a measured-cost table ready to fill. The template that becomes /capstone/capstone-architecture.md.
• Observation log template — printable for Lesson 10.4. Seven daily blocks (date, invocations, cost, anomalies, kill-switch activations, notes) plus the end-of-window summary and a restart-history section for windows that had to start over. The document that becomes /capstone/observation-log.md.
• Incident drill after-action template — printable for Lesson 10.4. One scenario walked end-to-end: scenario description, four-step timeline (stop / assess / repair / tell one human), prediction-vs.-reality comparison, and the list of changes logged back into the posture document or the architecture. Becomes /capstone/incident-drill-afteraction.md.
• Capstone final template — printable for Lesson 10.5. The ten-section consolidated document that reads straight through in ~15 minutes: what this system does, the architecture summarized, the three components, the seven-day log summary, the incident drill outcome, the demo video link, the cost summary, the posture attestation, what I would build next, and the freeze header. The template for /capstone/capstone-final.md.
• Demo video script and shot list — printable for Lesson 10.5. Pre-record checklist (microphone source, file format, resolution, fabricated stand-in data for sensitive fields), the five-beat script (one-sentence explanation, end-to-end run, three components named as they fire, intentional failure and recovery, what I would build next), a post-production checklist, and the common-mistakes list. The scaffold for the 3–5 minute demo.mp4.
• Capstone reflection template — printable for Lesson 10.5. The five prescribed prompts (what surprised you; what broke and what rail caught it; what directing the AI cost in dollars and time; the one rail you are adding to the posture; the one thing you would build next), each answered in 3–5 sentences, plus a closing line. Becomes /capstone/capstone-reflection.md.
• Named-human sign-off template — printable for Lesson 10.5. Three questions the reviewer answers in their own voice (did you see the system run end-to-end; did you see the incident loop fire; would you trust this system to operate unattended under its posture?), a rubric result line, and a signature block with date. Becomes /capstone/named-human-signoff.md.
• Capstone scope check — interactive HTML activity for Lesson 10.1. Seven yes-or-no questions against your just-written charter (one-sentence purpose; audience-equals-you; three distinct shapes named; data classes labeled; explicit out-of-scope list; realism test; freeze header present). 7/7 is the gate; a charter that does not pass is revised before Lesson 10.2.

---

What you should have when this module is done CORE

By the time you close out Module 10, the capstone folder is frozen and you can point to eight concrete artifacts — the complete portfolio a parent, an admissions officer, a future employer, or your own future self will read:

• A frozen /capstone/capstone-charter.md — one to two pages, three shapes named explicitly from the four-shape vocabulary, the audience-equals-you rule signed by the student, and the explicit out-of-scope list. Passed the Capstone scope check activity at 7/7.
• A frozen /capstone/capstone-architecture.md — six sections (inventory, data flow, trust boundaries, schedule, cost, posture amendments), the system-diagram.png embedded, posture amendments listed (or “none, the Module 9 posture covers this capstone as written”), and a measured cost estimate from Lesson 10.3 replacing the first-pass estimate.
• A working /capstone/pipeline-v1/ — three component subfolders (each with code, README, and smoke test), one shared-state/ folder, one smoke-test folder with three green test results on file, and a root README.md. The kill switch has been measured and its timing recorded.
• A /capstone/incident-drill-afteraction.md — one of the four scripted scenarios walked end-to-end against the real pipeline, with the four-step timeline documented and the posture or architecture updates logged.
• A /capstone/observation-log.md — seven clean daily blocks under the posture, the end-of-window summary, and the restart history (empty if the first seven-day window ran clean; populated if any earlier attempt had to restart).
• A frozen /capstone/capstone-final.md — the ten-section consolidated document that reads straight through in ~15 minutes, with the system diagram, the component summaries, the seven-day log summary, the cost numbers, the posture attestation, and the demo video linked.
• A /capstone/demo.mp4 (or .mov equivalent) — a 3–5 minute screen recording covering the five beats, saved locally, audience is the student and the reviewer (not the open internet).
• A frozen /capstone/capstone-reflection.md plus the /capstone/named-human-signoff.md written in the reviewer’s voice, plus the completed Module 10 end-of-module check, plus the capstone folder git-tagged capstone-frozen-YYYY-MM-DD. The tag is the freeze.

If any of these is missing, return to the lesson that produced it. The course does not freeze without all of them — the rubric checks each artifact by name, and a missing artifact is a failing criterion no amount of extra effort on the others can compensate for. Finish the list, then freeze the folder, then close the course.