feat(labs): make every lab a self-contained, skip-friendly starting point

Each lab now stands on its own; no hard dependency on prior labs.
- App-based labs get a canonical tasks-app snapshot in lab/start/ (three
  baselines: v0 add/list/done; v1 +count; v2 +count/delete), assigned by where
  each module sits in the command timeline. Modules with a purpose-built app
  (M10 trap, M13 planted bug, M21) snapshot their own app; planted devices kept.
- Self-contained labs (M15/17/18/19/22/23/24/25/27, which operate on their own
  lab files) get a preamble pointing at modules/NN/lab/.
- Every module + capstone gets a "Starting point (skip-friendly)" preamble:
  copy the snapshot, git init -b main, commit -> clean status, then start.

Lets a learner skip around or recover: copy start/, commit, go. All snapshots
run; tools/check.sh passes; no em-dashes.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TfzV5QvtPDz8LJS3Pu5VLT

modules/21-skills-teaching-the-ai-your-playbook/README.md

@@ -160,6 +160,18 @@ On paper this is just "write a runbook." The AI-specific twist is what changes t
 
 ## Hands-on lab
 
+
+> **Starting point (this lab is skip-friendly).** You do not need to have done the earlier labs.
+> To begin from a clean, known state, copy this module's snapshot into a fresh `tasks-app` and
+> make the first commit:
+>
+> ```bash
+> mkdir -p ~/ai-workflow-course/tasks-app
+> cp -r ~/ai-workflow-course/modules/21-skills-teaching-the-ai-your-playbook/lab/start/. ~/ai-workflow-course/tasks-app/
+> cd ~/ai-workflow-course/tasks-app && git init -b main && git add -A && git commit -m "start: module 21"
+> ```
+>
+> Already carrying your `tasks-app` from earlier modules? Keep using it and ignore this box.
 **Lab language:** markdown (the skill file) plus shell and Python (the `tasks-app`). You'll write a
 skill, then have your editor-integrated AI (Module 4) execute it.
 

modules/21-skills-teaching-the-ai-your-playbook/lab/start/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+Newest entries on top. One line per user-visible change.
+
+## Unreleased
+
+- Add `count` command: print how many tasks are still pending.
+- Add `done <index>` command: mark a task complete.
+- Initial CLI: `add` and `list`.

modules/21-skills-teaching-the-ai-your-playbook/lab/start/cli.py

@@ -0,0 +1,59 @@
+"""Tiny command-line front end for the demo task app.
+
+Run it:
+    python cli.py add "write the lesson"
+    python cli.py list
+    python cli.py count
+
+State is kept in tasks.json next to this file. The same minimal app from Module 1 onward; the
+target your "add a command" skill extends.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+from tasks import Task, TaskList
+
+STATE = Path(__file__).parent / "tasks.json"
+
+
+def load() -> TaskList:
+    if not STATE.exists():
+        return TaskList()
+    raw = json.loads(STATE.read_text())
+    return TaskList(tasks=[Task(**t) for t in raw])
+
+
+def save(tlist: TaskList) -> None:
+    STATE.write_text(json.dumps([t.__dict__ for t in tlist.tasks], indent=2))
+
+
+def main(argv: list[str]) -> int:
+    tlist = load()
+    if not argv:
+        print("usage: python cli.py [add <title> | list | done <index> | count]")
+        return 1
+
+    command = argv[0]
+    if command == "add":
+        title = " ".join(argv[1:])
+        tlist.add(title)
+        save(tlist)
+        print(f"added: {title}")
+    elif command == "list":
+        print(tlist.render())
+    elif command == "done":
+        tlist.complete(int(argv[1]))
+        save(tlist)
+        print("updated")
+    elif command == "count":
+        print(f"{tlist.pending_count()} task(s) pending")
+    else:
+        print(f"unknown command: {command}")
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

modules/21-skills-teaching-the-ai-your-playbook/lab/start/tasks.py

@@ -0,0 +1,41 @@
+"""Core task logic for the demo app.
+
+The same running example from Module 1 onward, carried forward with the `pending_count()` helper
+that backs the `count` command. This is the codebase your "add a command" skill operates on.
+"""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Task:
+    title: str
+    done: bool = False
+
+
+@dataclass
+class TaskList:
+    tasks: list[Task] = field(default_factory=list)
+
+    def add(self, title: str) -> Task:
+        task = Task(title=title)
+        self.tasks.append(task)
+        return task
+
+    def complete(self, index: int) -> None:
+        self.tasks[index].done = True
+
+    def pending(self) -> list[Task]:
+        return [t for t in self.tasks if not t.done]
+
+    def pending_count(self) -> int:
+        return len([t for t in self.tasks if not t.done])
+
+    def render(self) -> str:
+        if not self.tasks:
+            return "(no tasks yet)"
+        lines = []
+        for i, task in enumerate(self.tasks):
+            box = "[x]" if task.done else "[ ]"
+            lines.append(f"{i}. {box} {task.title}")
+        return "\n".join(lines)

modules/21-skills-teaching-the-ai-your-playbook/lab/start/test_tasks.py

@@ -0,0 +1,44 @@
+"""Test suite for the tasks-app. Run from this folder with:
+
+    python -m unittest
+
+Your "add a command" skill should ADD a test here for every new command. The point is to assert
+intended behavior, not just that nothing crashed.
+"""
+
+import unittest
+
+from tasks import TaskList
+
+
+class TestTaskBasics(unittest.TestCase):
+    def test_add_appends_a_task(self):
+        tl = TaskList()
+        tl.add("write the skill")
+        self.assertEqual(len(tl.tasks), 1)
+        self.assertEqual(tl.tasks[0].title, "write the skill")
+        self.assertFalse(tl.tasks[0].done)
+
+    def test_complete_marks_done(self):
+        tl = TaskList()
+        tl.add("a")
+        tl.complete(0)
+        self.assertTrue(tl.tasks[0].done)
+
+    def test_pending_excludes_completed(self):
+        tl = TaskList()
+        tl.add("a")
+        tl.add("b")
+        tl.complete(0)
+        self.assertEqual([t.title for t in tl.pending()], ["b"])
+
+    def test_pending_count_ignores_done(self):
+        tl = TaskList()
+        tl.add("a")
+        tl.add("b")
+        tl.complete(0)
+        self.assertEqual(tl.pending_count(), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()