docs(tac): add self-determination theory and dark flow note

Folds Jeremy Howard's SDT-based talk (youtube.com/watch?v=SUZwYV5JYBM)
into loop_engineering.md. Covers autonomy/mastery/relatedness/purpose,
the dark flow trap in vibe coding, and the augmentation-vs-replacement
distinction. Four application points for agentic engineering loops.

plans/meta-prompts/loop_engineering.md

@@ -189,3 +189,44 @@ TAC invariants still hold when a multiplexer is the substrate:
 - the primary agent must not gain a raw-command deploy path just because it can drive shells.
 
 References: cmux fleet-driving prompts (`github.com/disler/learning-cmux-with-agents`), herdr agent multiplexer (`herdr.dev`), cmux + Claude Code + Pi demo (YouTube `WAFUMBLOjHo`).
+
+## Reproducible agentic dev environment
+
+Reference: kunchenguid dotfiles (`github.com/kunchenguid/dotfiles`), Agentic Engineering Setup walkthrough (YouTube `5N-okeDdIuI`).
+
+**Architecture stack:** Nix (Determinate Nix) → Nix Darwin (macOS system) / Home Manager (user-level packages + dotfiles) → symlinks (agent configs, global agents.md) → `rebuild.sh` (one command from fresh OS to productive setup).
+
+**Key insight — agent configs as versioned symlinks.** The global `agents.md` memory file lives in the dotfiles repo. Home Manager symlinks it into each agent's config directory. All agents (Claude Code, pi, etc.) read the same ruleset from one source-of-truth file. Change once, rebuild, every agent picks it up.
+
+**Cross-OS portability (Windows sketch):**
+
+| macOS component | Windows equivalent |
+|---|---|
+| Nix + Nix Darwin | Nix via WSL, or scoop/winget |
+| Homebrew | scoop / winget / chocolatey |
+| Westerm terminal | Windows Terminal / WezTerm |
+| Zsh + Starship | PowerShell Core + Starship, or Git Bash |
+| Neovim (Lazy.nvim) | Neovim (identical, paths differ) |
+| Herdr multiplexer | Herdr (native Windows binary) |
+| Claude Code | Claude Code (Windows CLI) |
+| `rebuild.sh` | `rebuild.ps1` or cross-OS `justfile` |
+
+**Cross-OS constants** that make this viable: Herdr (single Rust binary, works everywhere, see Agent multiplexer note above); Neovim (identical config across OSes); Claude Code/pi (both work on Windows); Starship (cross-shell prompt); global `agents.md` (plain markdown, OS-agnostic).
+
+**The target pattern:** one command from a fresh OS install to a fully productive agentic engineering environment. Every tool, every config, every agent rule — versioned, repeatable, documented for the OSes you target.
+
+## Self-determination theory and AI work
+
+Reference: Jeremy Howard talk at Answer.AI (YouTube `SUZwYV5JYBM`), built on Deci & Ryan's Self-Determination Theory (SDT) — 50 years of research on human flourishing.
+
+**Core insight for agentic engineering:** SDT identifies **autonomy, mastery, relatedness, and purpose** as the pillars of eudaimonic flourishing. AI tools can either *support* or *decay* each pillar. The outcome depends on design and usage, not the tool itself.
+
+**Dark flow trap.** Csikszentmihalyi's flow — high challenge + high skill — is generative. But casinos and slot machines engineer an *illusion of control* that produces junk-flow without growth. Rachel Thomas calls the AI coding version "vibe coding's spell" — the dopamine hit of rapid generation decoupled from external validation. Symptoms: feeling productive while producing unshippable code, 200K-line vibe-coded codebases that slow down over time, quarterly reality checks where nothing shipped.
+
+**Augmentation pattern (the Howard thesis):** tools like SolveIt that let you *do the work yourself with help* — read papers, ask questions, reimplement systems, write your own code, verify against real evals. The AI supports effortful craft rather than replacing it. This is the same lineage as Ivan Sutherland's Sketchpad (1963), Doug Engelbart's Mother of All Demos (1968), Ken Iverson's APL as a tool of thought, and Bret Victor's exploratory environments.
+
+**Apply to agentic engineering:**
+- Every agent prompt should *teach or enable*, not just *produce*.
+- Prefer architectures where the primary agent does the reasoning and delegates execution, not where it becomes a blind router.
+- Size your loops so the human stays in the learning loop — the agent handles toil, the human handles judgment.
+- If a day of agentic work leaves you energized and knowledgeable, you're augmenting. If it leaves you with output you can't explain or debug, you're in dark flow.