feat(course): build out all 27 modules, capstone, scaffold, and conventions

Scaffold the course repo and author the full curriculum in dependency-chain
order, following the settled build decisions in handoff.md.

- Scaffold: course README, vendor-neutral AGENTS.md (dogfoods Module 5),
  _TEMPLATE.md (the fixed 9-section module shape), root .gitignore, ship config.
- Modules 1-2: reference exemplars (locked for tone/depth/lab style).
- Modules 3-27: full lessons + runnable labs, each following the template,
  respecting the chain, vendor/model-agnostic, with "feel the pain" labs.
- Module 8 hosting comparison web-researched and date-stamped (as of 2026-06-22),
  not written from memory; expansion-zone modules carry Verify-before-publish.
- Capstone: the full loop end to end on the running tasks-app example.

Lab code syntax-checked (Python/shell/YAML); every module has the 7 core
template sections.

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

modules/13-testing-in-the-ai-era/lab/tasks-app/README.md

@@ -0,0 +1,25 @@
+# Demo app — `tasks` (Module 13 copy)
+
+The same tiny task tracker from Modules 1 and 2, with one feature added: a `count` command backed
+by `TaskList.pending_count()`. Use this copy for the Module 13 lab so everyone starts from the same
+code — including the same latent bug.
+
+If you already have a `tasks-app` from earlier modules, you can use that instead; just make sure it
+has a `count` command (the Module 2 lab added one). The planted bug in this copy is there on purpose.
+
+## Files
+
+- `tasks.py` — core logic (`Task`, `TaskList`), now with `pending_count()`.
+- `cli.py` — command-line front end. Adds `count`.
+
+## Run it
+
+```bash
+python cli.py add "write the tests"
+python cli.py add "fix the bug"
+python cli.py done 0
+python cli.py list
+python cli.py count
+```
+
+Requires Python 3.10+. No third-party packages — tests use the standard library `unittest`.

modules/13-testing-in-the-ai-era/lab/tasks-app/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. Same minimal app from Modules 1 and 2, with a
+`count` command bolted on.
+"""
+
+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/13-testing-in-the-ai-era/lab/tasks-app/tasks.py

@@ -0,0 +1,43 @@
+"""Core task logic for the demo app.
+
+Same running example from Modules 1 and 2, carried forward. It has grown one feature since then:
+a `pending_count()` helper that the AI added to back a `count` command. The feature "works" in
+the obvious case — which is exactly the kind of code this module teaches you to verify properly.
+"""
+
+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:
+        # Added by the AI to support `cli.py count`. Looks right, ran fine in a quick check.
+        return len(self.tasks)
+
+    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)