---
type: claim
domain: ai-alignment
secondary_domains: [living-agents, collective-intelligence]
description: "Agent methodology follows a hardening trajectory — documentation (aspirational) → skill (reliable when invoked) → hook (structural guarantee) — but over-automation corrupts quality when hooks encode judgment rather than verification"
confidence: likely
source: "Cornelius (@molt_cornelius), 'Agentic Systems: The Determinism Boundary' + 'AI Field Report 1: The Harness Is the Product' + 'AI Field Report 3: The Safety Layer Nobody Built', X Articles, March 2026; independently validated by VS Code Agent Hooks, Codex hooks, Amazon Kiro hooks shipping in same period"
created: 2026-03-30
depends_on:
- the determinism boundary separates guaranteed agent behavior from probabilistic compliance because hooks enforce structurally while instructions degrade under context load
- context files function as agent operating systems through self-referential self-extension where the file teaches modification of the file that contains the teaching
supports:
- trust asymmetry between agent and enforcement system is an irreducible structural feature not a solvable problem because the mechanism that creates the asymmetry is the same mechanism that makes enforcement necessary
reweave_edges:
- trust asymmetry between agent and enforcement system is an irreducible structural feature not a solvable problem because the mechanism that creates the asymmetry is the same mechanism that makes enforcement necessary|supports|2026-04-03
---

# Methodology hardens from documentation to skill to hook as understanding crystallizes and each transition moves behavior from probabilistic to deterministic enforcement

Agent methodology follows a three-stage hardening trajectory:

1. **Documentation** — Aspirational instructions the agent follows if it remembers. Natural language in context files, system prompts, rules. Subject to attention degradation and the 556:1 copy-to-contribution waste ratio.
2. **Skill** — Reliable when invoked, with quality gates built in. The methodology is encoded as a structured workflow the agent can execute, not just advice it may attend to. 2-3 skills per task is optimal; beyond that, attention dilution degrades performance.
3. **Hook** — Structural guarantee that fires on lifecycle events regardless of agent attention state. The behavior moves from the probabilistic to the deterministic side of the enforcement boundary.

Each transition represents a pattern that has been validated through use and is now understood well enough to be mechanized. The progression is not just about reliability — it is about encoding organizational learning into infrastructure that survives session resets and agent turnover.

The convergence validates the trajectory: Claude Code, VS Code, Cursor, Gemini CLI, LangChain, Strands Agents, and Amazon Kiro all independently adopted hooks within a single year. The documentation-to-hook progression is not a theoretical framework — it is the empirical trajectory the industry followed.

**The over-automation trap:** Every hook that works creates pressure to build more. The logic at each step is sound ("why leave this to agent attention when infrastructure can guarantee it?"), but the cumulative effect can shrink the agent's role to triggering operations that hooks validate, commit, and report. The most dangerous failure is not a missing hook but a hook that encodes judgment it cannot perform — keyword-matching connections that fill a graph with noise while metrics report perfect compliance. The practical test: would two skilled reviewers always agree on the hook's output? Schema validation passes this test. Connection relevance does not.

Friction is the signal through which systems discover structural failures. If hooks systematically eliminate friction, they also eliminate the perceptual channel that would reveal when over-automation has occurred.

## Challenges

The three-stage model assumes that understanding always moves in one direction (toward determinism). In practice, requirements change, and hooks that encoded valid methodology may become constraints when the methodology evolves. The refactoring cost of hooks is higher than documentation — reverting an over-automated hook requires understanding why it was built, which may not be documented. The model also assumes clear boundaries between the three stages, but in practice the transitions are gradual and the optimal enforcement level for any given behavior is context-dependent.

---

Relevant Notes:
- [[the determinism boundary separates guaranteed agent behavior from probabilistic compliance because hooks enforce structurally while instructions degrade under context load]] — this claim describes the boundary; the hardening trajectory describes the *movement* of behaviors across that boundary over time
- [[context files function as agent operating systems through self-referential self-extension where the file teaches modification of the file that contains the teaching]] — the context-file-as-OS is where documentation-stage methodology lives and where the self-extension loop proposes promotions to skill or hook stage
- [[curated skills improve agent task performance by 16 percentage points while self-generated skills degrade it by 1.3 points because curation encodes domain judgment that models cannot self-derive]] — the hardening trajectory's skill stage is specifically about curated skills; auto-generated skills represent a different pathway that degrades performance

Topics:
- [[_map]]
