docs: add REPL article, enhance rig positioning, integrate rig into L1

Add "REPL is dead, long live REPL" (Brandon Waselnuk, Unblocked) to
further reading and link it from L1's REPL Fractal section. Reposition
rig as a baseline guardrails framework in README. Add rig mention in
L1 Design-First Workflow section.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: franklywatson

README.md

@@ -23,15 +23,15 @@ The patterns were extracted from a [production-grade Telegram trading bot](docs/
 
 Peter Steinberger, creator of OpenClaw, has described a similar approach — managing 5-10 parallel agents, closing the feedback loop so agents verify their own work, investing heavily in planning before implementation, and treating code reviews as architecture discussions. His core insight: *"I don't think software engineering is dead with AI: in fact, quite the opposite."* Agentic development demands more engineering discipline, not less.
 
-Other frameworks approach similar problems from different angles. [gstack](https://github.com/garrytan/gstack) provides a skill framework with resolver pipelines. [superpowers](https://github.com/obra/superpowers) provides base skills for brainstorming, planning, TDD, and code review. [rig](https://github.com/franklywatson/claude-rig) implements the L2-L3 patterns from this repo as a working agent harness with enforcement pipelines, tool routing, and session management. These systems informed this work — the best available ideas at the time, applied and refined in production.
+Other frameworks approach similar problems from different angles. [gstack](https://github.com/garrytan/gstack) provides a skill framework with resolver pipelines. [superpowers](https://github.com/obra/superpowers) provides base skills for brainstorming, planning, TDD, and code review. [rig](https://github.com/franklywatson/claude-rig) is a baseline guardrails framework built on the L2-L3 patterns from this repo — an opinionated, configurable implementation that automates enforcement pipelines, tool routing, scout agents, and session management. Install with `rig init`. These systems informed this work — the best available ideas at the time, applied and refined in production.
 
 The lineage: patterns were extracted from the reference project, organized into this library, then used to build rig — which now serves as both a reference implementation and a development tool for improving this very repo.
 
 ### Reference Implementations
 
 | System | What it implements | Language |
 |--------|-------------------|----------|
-| [rig](https://github.com/franklywatson/claude-rig) | L2 enforcement pipeline, L3 tool routing + scout agent, skill chain with phase transitions, CLI installer, CI guardrails | TypeScript |
+| [rig](https://github.com/franklywatson/claude-rig) | Baseline guardrails framework: L2 enforcement pipeline, L3 tool routing + scout agent, skill chain with phase transitions, CI guardrails. Configurable via `.harness.yaml`. | TypeScript |
 | [gstack](https://github.com/garrytan/gstack) | L2 skill framework with resolver pipeline, preamble system | TypeScript |
 | [superpowers](https://github.com/obra/superpowers) | L2 base skills (brainstorming, TDD, verification, review), automated worktree management | Markdown/JS |
 

docs/L1-feedback-loops.md

@@ -24,6 +24,8 @@ This REPL exists at multiple scales:
 
 Each higher-level REPL absorbs but doesn't replace the lower ones. Unit tests don't go away when you add stack tests — they become the contract that stack tests verify against. The fractal pattern means every interaction follows the same structure: gather context, act, verify, iterate.
 
+This fractal view of the REPL — where agents handle code-level loops so engineers can operate at the intent layer — is explored further in Brandon Waselnuk's article [REPL is dead, long live REPL](https://getunblocked.com/blog/repl-is-dead-long-live-repl/).
+
 ---
 
 ## Context Harvesting — From Understanding to Design
@@ -46,6 +48,8 @@ Every agent interaction with the system — a new feature, a bug fix, an archite
 
 7. **Execute** — Use the `executing-tasks` skill to implement the plan as documented. Run tests, fix issues found, verify against the plan's acceptance criteria.
 
+The [rig](https://github.com/franklywatson/claude-rig) framework automates this workflow through its skill chain — enforcing the transition from planning to implementation to verification. The `plan+` skill structures the design-first approach; the phase tracker prevents jumping to `tdd+` without a prior plan. See [L2: Behavioral Guardrails](L2-behavioral-guardrails.md) for the full skill chain architecture.
+
 ### Why Context Harvesting Precedes Testing
 
 Stack tests validate design intent. But if the design is wrong, perfect tests just confirm the wrong thing with high confidence. The agent needs to understand the system before changing it.

docs/references/further-reading.md

@@ -34,6 +34,14 @@
 - **Related to:** L0, L1, L2, L3, L4
 - **URL:** <https://newsletter.pragmaticengineer.com/p/the-creator-of-clawd-i-ship-code>
 
+### REPL is dead, long live REPL
+
+- **Type:** Article
+- **Author:** Brandon Waselnuk (Unblocked)
+- **Summary:** Argues that the Read-Eval-Print Loop hasn't died with agentic coding — it's been promoted. Engineers now operate the REPL at the intent layer (read agent output, evaluate against intent, print next instruction, loop) while agents handle the code-level REPL. The article demonstrates that context curation and intent-level evaluation produce drastically better outcomes than naive code-level REPL, and that the skill shift is learnable but real: from writing code to writing instructions and reviewing diffs.
+- **Related to:** L1
+- **URL:** <https://getunblocked.com/blog/repl-is-dead-long-live-repl/>
+
 ## Videos
 
 ### Your codebase is NOT ready for AI