WWVCD: What Would Vin Claudel Do?

1,191 deep technical findings extracted verbatim from the source code of Anthropic's Claude Code — built to give your AI agents the exact structural knowledge and hard-won engineering decisions the Claude Code team used to build it.

The Problem This Solves

You are building an AI agent. It halluccinates. It gets stuck in a loop. It backgrounds bash processes incorrectly. It doesn't know the exact timeout before auto-backgrounding kicks in, or the circuit breaker that prevents infinite retry loops, or the exact retry strategy for a 529 overload.

The Claude Code team solved all of this. The answers are in their source code. This database extracts those answers — with exact constants, TypeScript interfaces, and Rust implementations — so your agents can query them directly.

Whenever your agent gets stuck, ask: What would Vin Claudel do?

He would drive a 1970 Dodge Charger off a moving cargo plane. We are building AI agents. So the next best thing is to look up exactly how the Claude Code team solved it.

Quick Start

Zero install:

npx wwvcd "bash background timeout"
npx wwvcd "context window compaction"
npx wwvcd "permission bypass dangerous"
npx wwvcd "pre-tool-use hook cancel"
npx wwvcd "rate limit retry backoff"

Installed:

npm install -g wwvcd
wwvcd "autocompact circuit breaker"
wwvcd "headless print mode non-interactive"
wwvcd "MCP tool dispatch mcp__ prefix"

Primary Use Case: Unsticking AI Agents

This tool exists for one reason: your agent gets stuck, and you need to know the exact structural pattern the Claude Code team uses to solve that class of problem. Not a blog post. Not a summary. The actual TypeScript interface, the exact constant, the actual implementation.

Examples

Agent is hallucinating?

npx wwvcd "hallucination verification evidence"

Returns the exact structural enforcement pattern: require code evidence citations, enumerate rationalization strategies by name, decouple generation from evaluation with a read-only judge.

Agent isn't backgrounding long-running bash correctly?

npx wwvcd "bash auto-background ASSISTANT_BLOCKING_BUDGET_MS"

Returns the exact millisecond threshold, the TaskOutput CircularBuffer pattern, and the bwrap/sandbox-exec sandboxing difference by platform.

Agent keeps retrying a denied permission infinitely?

npx wwvcd "denial tracking circuit breaker auto mode"

Returns DENIAL_LIMITS = { maxConsecutive: 3, maxTotal: 20 } with the exact TypeScript implementation.

Agent's context window keeps blowing up?

npx wwvcd "autocompact threshold circuit breaker"

Returns AUTOCOMPACT_BUFFER_TOKENS = 13_000, MAX_CONSECUTIVE_AUTOCOMPACT_FAILURES = 3, recursion guards for session_memory/compact querySource.

Building a headless/CI pipeline with Claude Code?

npx wwvcd "headless print mode non-interactive"

Returns isNonInteractiveSession flag, trust dialog skip logic, SIGINT handling difference, SDK stdout schema — exactly what changes between --print and interactive mode.

Agent hitting rate limits?

npx wwvcd "rate limit 529 retry backoff"

Returns DEFAULT_MAX_RETRIES=10, MAX_529_RETRIES=3, BASE_DELAY_MS=500, FOREGROUND_529_RETRY_SOURCES set, per-source retry policy.

Need to understand the tool permission decision tree?

npx wwvcd "hasPermissionsToUseTool allow deny ask"

Returns the exact 3-way decision algorithm: alwaysAllow → alwaysDeny → mode switch (planMode/bypassPermissions/auto/acceptEdits).

For AI Assistants (OpenClaw, Cursor, etc.)

Clone this repo into your skills folder (~/.openclaw/workspace/skills/wwvcd). When your agent gets stuck, type in chat:

"Query WWVCD for 'context compaction threshold' and implement what Vin Claudel would do."

Or pipe the JSON output directly into your agent's context:

npx wwvcd "bash sandboxing bwrap" --json | your-agent-tool

What's in the Database

1,191 findings extracted from StanHus/claude-code-src — a cleanroom reverse-engineering of Anthropic's Claude Code covering both the TypeScript implementation and the complete Rust rewrite. 791 findings (66%) include verbatim source code.

Source coverage: | Source | Findings | What's Extracted | |--------|----------|-----------------| | TypeScript spec (13 files, 27k lines) | ~1,087 | Core architecture, all 40+ tools, services, permissions, hooks, compaction, MCP, bridge | | Rust codebase (120 .rs files) | 95 | Complete async Rust rewrite: tools, TUI, MCP, bridge, query loop, SSE streaming | | TypeScript source (direct, 1,364 files) | ~110 | Constants not in spec, implementation details, exact function signatures |

What makes this different from generic LLM summaries:

• Exact constants: AUTOCOMPACT_BUFFER_TOKENS = 13_000, DENIAL_LIMITS = { maxConsecutive: 3, maxTotal: 20 }, CAPPED_DEFAULT_MAX_TOKENS = 8_000, DEFAULT_MAX_RETRIES = 10, MAX_529_RETRIES = 3
• 23 bash injection check IDs with names and numeric codes
• Real TypeScript interfaces verbatim — Tool<>, ToolUseContext, ToolPermissionContext
• Real Rust structs — QueryConfig, QueryOutcome, ToolContext, PermissionLevel
• CLAUDE.md loading order (4-tier hierarchy, memoized, @include directive)
• Complete retry strategy: foreground vs background source policy, 529 vs 429 handling
• Architectural decisions with rationale (e.g., why the 8k output cap exists — p99 is 4,911 tokens so 32k over-reserves 6×)

Coverage verified by adversarial eval

Both internal (55 questions) and organic (50 natural developer questions) evals pass at 100%. Additionally validated with two adversarial expert agent reviews (30 + 25 hard implementation questions) targeting:

• Rust-specific implementation (query loop, TUI, bridge wire protocol)
• Cross-cutting concerns (cost tracking, OAuth refresh, compaction after tool calls)
• Edge cases (concurrent file writes, headless vs interactive, Ctrl+C propagation)

Structural Deep Dives

The patterns/ folder contains implementable strategies you can copy-paste into your own agent prompts:

• 01-enumerate-rationalizations.md — explicitly name and forbid LLM rationalization patterns
• 02-structural-evidence.md — force code citations; no citation = automatic failure
• 03-read-only-judge.md — decouple generation from evaluation architecturally
• 04-explicit-faithfulness.md — override RLHF "helpfulness" by defining honesty as highest priority

How the CLI Works

wwvcd "query string" [--json]

The CLI performs semantic concept expansion (e.g., "hooks" expands to hooks-system, pre-tool-use, post-tool-use, lifecycle), SCREAMING_SNAKE_CASE splitting, camelCase splitting, and then scores all 1,191 findings by tag match + text match + code match. Returns top 10 results with full code evidence blocks.

--json returns machine-readable output for piping into agents.

Source

All findings are extracted from StanHus/claude-code-src — a cleanroom reverse-engineering of Anthropic's Claude Code, covering:

• The full TypeScript implementation (src/, 1,364 files)
• The complete Rust rewrite (src-rust/, 120 files across 11 crates: api, bridge, buddy, cli, commands, core, mcp, plugins, query, tools, tui)
• 13 structured spec markdown files documenting every subsystem

The extraction pipeline parses spec files section by section and goes directly to TypeScript/Rust source for implementation-level details not captured in the spec.

Philosophy

Building reliable autonomous agents is not about writing generic "You are a helpful assistant" prompts. It is about defensive, structural engineering — anticipating failure modes, naming them explicitly, and enforcing parseable evidence requirements for every claim.

Vin Claudel doesn't hallucinate. He executes. Because it's about family. And living life one token at a time.