IndyDevDan — The Claude Code Feature Senior Engineers KEEP MISSING

Why this is in the vault

Dan’s January 19 video flags a Cloud Code release that quietly ships the missing piece of the harness story: hooks now run inside skills, sub-agents, AND custom slash commands — not only globally in settings.json. It’s vault-worthy because:

1. It closes the loop on “watch what it did, not what it said.” This is the same instrumentation gap Dan calls out in the Mythos video earlier this same cycle. Mythos says “we need observability into what the model actually does”; this video gives us the deterministic enforcement layer to act on that observability per-skill, per-sub-agent, per-prompt. The two videos are halves of the same architecture.
2. It introduces “specialized self-validation” as a vocabulary the vault didn’t have. Existing RDCO global hooks (in ~/.claude/settings.json) are blunt — every tool call across every skill goes through the same hook. Per-skill hooks are surgical: a CSV-edit skill validates CSV; a Notion-update skill validates schema; an HTML-generation skill validates DOM. The “focused agent + focused validator” pattern is Dan’s load-bearing claim, and it’s directly transferable.
3. It restates “agents plus code beats agents” with a concrete mechanism. RDCO has been moving toward this with the autonomous loop, but the validation layer per skill has been thin. Dan shows the exact directory layout (.claude/hooks/validators/<purpose>-validator.py), the exact post-tool-use vs stop hook tradeoff, and the exact “resolve this error in ” agent-feedback pattern. Copy-paste implementable.

Core argument

Specialized self-validation via per-skill hooks turns prompts/sub-agents/skills into closed-loop systems that you can trust to validate their own work. Focused agents with focused validators outperform generalist agents with generalist validation, over scale.

The release that matters: Cloud Code now supports pre-tool-use, post-tool-use, and stop hooks inside skill front-matter, sub-agent front-matter, and custom slash command front-matter — not only in global settings.json. Dan flags this as the most-missed feature in the recent release notes.

The directory pattern Dan recommends:

.claude/
  commands/
  agents/
  skills/
  hooks/
    validators/
      csv-single-validator.py
      html-validator.py
      ...

The per-skill hook block in front-matter (paraphrased):

hooks:
  post-tool-use:
    - tool: Edit|Write|Read
      command: uv run ${CLAUDE_PROJECT_DIR}/.claude/hooks/validators/csv-single-validator.py

The agent-feedback contract: when the validator finds an error, it returns a string starting with “resolve this CSV error in :” plus the error list. The agent reads this back into context and immediately fixes it. Demo: removing a quote from a CSV → read hook fires → validator catches it → agent fixes it on the next turn → validator confirms clean → real work proceeds.

Post-tool-use vs stop:

• post-tool-use = fires after every Edit/Write/Read of a single file. Use when you want per-operation validation. The script gets the path that was just touched.
• stop = fires when the agent finishes its turn. Use when you want global validation across all files in the codebase (linting, formatting, schema checks).

The single sharpest line: “A focused agent with one purpose outperforms an unfocused agent with many purposes.” Dan’s repeated insistence on focused, single-purpose agents (CSV-edit-agent, HTML-validator, build-agent) is the corollary of the focused-validator pattern. Generalist agents with generalist validation are the failure mode.

Connection to Ralph Wiggum / agents-plus-code: This is the deterministic-validation half of the agent-loop pattern. The agent does the soft thing (interpretation, generation, repair); the validator does the hard thing (syntactic correctness, schema compliance, file-system invariants). Both halves running per-skill is the architecture.

The meta point Dan keeps making: “Engineers know what their agents are doing. Vibe coding is not knowing and not looking.” Per-skill validators are how you know — the validator log is the ground truth.

Mapping against Ray Data Co

• This is the deterministic enforcement layer the autonomous loop has been missing. Today, when process-newsletter writes a vault file, we trust it wrote correct YAML front-matter. When check-board updates a Notion task to Done with a path, we trust the path exists on disk. When process-youtube writes a transcript and assessment pair, we trust the assessment links to the transcript and not to a sibling. None of these are validated; all of them have failed silently in the past. Concrete delta: write a vault-frontmatter-validator.py that checks every vault write for (a) frontmatter cap ≤ 80 lines, (b) related: is block-list quoted YAML, (c) newsletter_format is in the enum, (d) sponsored=true requires ## Sponsorship body section, (e) hybrid format requires ## Curation section heading, (f) filename slug head matches source field. Wire this as a post-tool-use hook on Write/Edit inside process-newsletter, process-youtube, compile-vault, process-inbox. The audit-model skill currently runs this AFTER the fact across the whole vault; Dan’s pattern would catch it AT WRITE TIME inside the skill that’s about to drift.
• The Notion-task-update path needs the same treatment. When check-board reports “DONE — ” in its cycle output, we have no in-loop check that the filename actually exists. Concrete delta: write a notion-task-done-validator.py that intercepts mcp__claude_ai_Notion__notion-update-page calls where Status is being set to “Done” and confirms the path mentioned in the report exists. Wire as a pre-tool-use hook on check-board, process-newsletter, process-youtube.
• generate-tests and build-project are obvious places for per-skill linter/formatter stop hooks. Dan’s build.md example is exactly the RDCO use case — when the build agent finishes, run the linter and formatter automatically as a stop hook. RDCO doesn’t do this today; the founder runs lints manually. Concrete delta: add stop hooks to build-project and vercel:deploy that run the project’s linter + formatter and reject if either fails.
• The “focused agent + focused validator” pattern is a critique of some RDCO skills. Skills like process-newsletter and compile-vault do many things — extract, summarize, file, cross-link. Dan would argue these should each spawn focused sub-agents per phase, each with its own validator. RDCO already does this for the per-article fan-out; the open question is whether the per-article work itself should be split further (extract-validator, summarize-validator, file-validator). Worth experimenting with on the next refactor.
• This pairs with the per-cycle tool-call audit log from the Mythos ingestion. The audit log is observability AFTER the fact (“what did the agent actually do this cycle?”). Per-skill hooks are enforcement IN the moment (“don’t let the agent finish until validation passes”). Both are needed; together they close the “watch what it did” loop.
• A concrete Sanity Check angle: “Per-skill hooks are the missing layer of agentic engineering.” Most operators run global hooks via settings.json or none at all. Per-skill validators are surgical, scale with the skill library, and turn each skill into a closed-loop system. RDCO’s vault-frontmatter-validator (built per the follow-up below) is the demo asset. Strong piece because it’s concrete, contrarian to the “more model intelligence solves it” reflex, and ships with a working example.

Open follow-ups

• Build ~/.claude/hooks/validators/vault-frontmatter-validator.py. Validates frontmatter cap ≤ 80 lines, related: format, newsletter_format enum, sponsored→Sponsorship section, hybrid→Curation section, filename-slug-matches-source. Wire as post-tool-use hook on Write/Edit inside process-newsletter, process-youtube, compile-vault, process-inbox. Estimated 2 hours. Catches the exact constraint-drift the prompt for this cycle warned about.
• Build ~/.claude/hooks/validators/notion-task-done-validator.py. Intercepts Notion task-Done updates and confirms the cited filepath exists. Wire as pre-tool-use hook on check-board, process-newsletter, process-youtube. Estimated 1 hour. Catches the “marked Done but file doesn’t exist” failure mode that has happened in past cycles.
• Add stop-hook linter+formatter to build-project and any deploy skills. Estimated 1 hour per skill. Mirrors Dan’s build.md pattern.
• Audit the 60+ skill library for “could this skill embed a hook?” Cross-reference with the IDD-cracked-skills audit and the IDD-ditching-MCP audit follow-ups (also queued today). All three audits are pieces of the same skill-architecture review pass — should be combined.
• Sanity Check angle: “Per-skill hooks: the missing layer of agentic engineering.” Practitioner-grounded, concrete demo asset (vault-frontmatter-validator), contrarian to “more intelligence solves it.” Strong if the validator is built first and the piece is shipped against a real example.
• Concept page: “The Closed-Loop Prompt.” Dan keeps using this phrase. The vault should have a 200-word canonical concept page — agent does the soft thing, validator does the hard thing, hook is the binding mechanism. Future ingestions can link to it.

Related

• ~/rdco-vault/06-reference/transcripts/2026-04-19-indydevdan-self-validating-hooks-transcript.md — raw transcript
• ~/rdco-vault/06-reference/2026-04-19-indydevdan-cracked-claude-agent-skills.md — Dan’s “skills decision tree”; this video is the validation-layer that completes the skill story
• ~/rdco-vault/06-reference/2026-04-19-indydevdan-mythos-unshipped-model.md — Mythos system card and “watch what it did, not what it said”; per-skill hooks are the deterministic enforcement layer for that observability mandate
• ~/rdco-vault/06-reference/2026-04-19-indydevdan-claude-code-deletes-production.md — production-delete incidents; per-skill hooks are the prevention pattern
• ~/rdco-vault/06-reference/2026-04-19-indydevdan-setup-hook-install-maintain.md — Dan’s earlier setup-hook pattern; this video generalizes it to per-skill scope
• ~/rdco-vault/06-reference/2026-04-11-garry-tan-thin-harness-fat-skills.md — Tan’s “fat skills”; per-skill hooks are how skills get FATTER without becoming brittle