/codd-fable-consult

name: codd-fable-consult
description: |
  Consult Claude Fable 5 (Anthropic's most capable model for deep, long-horizon reasoning — or whichever model currently holds that role) for a genuinely hard, novel CoDD architectural design decision, where a quick mechanical patch would be wrong. Packages CoDD's philosophy, invariants, GitHub repo, and session-derived insights into a rigorous consultation prompt; reviews the returned design before any implementation begins. Use AFTER a bug/gap has already been precisely diagnosed — this is a design skill, not a diagnostic one.

CoDD × Fable — Strategic Design Consultation

Route a genuinely hard CoDD design fork to Claude Fable 5 instead of guessing, drive-by patching, or letting a subagent design in a vacuum. This skill exists because a real consultation this project ran (the Java/C#/C++ marker-authenticity delegated-assertion gap, 2026-07-01/02) produced a design far better than an ad-hoc prompt would have — but only once several specific ingredients were deliberately injected. Skip any of them and you get generic, ungrounded, or overfit advice instead.

When to Use

Only after diagnosis is already done and the case genuinely meets **all** of these:

• A real bug/gap has been root-caused with concrete evidence (ideally from a live dogfood run, not a hypothetical) — not "something might be wrong," but "here is exactly what fails and why."
• A quick mechanical patch would be **wrong**, not just tedious. Signs: the fix would hardcode a framework/instance-specific special case into shared code; the fix could be done three different reasonable ways with real tradeoffs; the fix spans multiple language adapters and a per-language patch would duplicate audited logic; there's a live risk of solving today's instance while creating tomorrow's overfit.
• The decision is squarely inside CoDD's own stated hard invariants (generality-first, anti-false-green/anti-false-red, owner-not-a-bottleneck) such that getting it wrong would violate one of them, not just be suboptimal.

**Do NOT use this for:**

• A bug with one obviously correct fix — just fix it, and cite `codd/coverage_execution_coherence.py`-style commits (this project has many) as the bar for a well-scoped, well-tested mechanical patch.
• Exploratory "what should we build next" prioritization — that's a Gunshi/owner conversation, not a design-fork consultation.
• Anything where the honest answer is "we don't have enough live evidence yet" — go get a live failure first (via a normal investigation agent), then come back here.

Why the Naive Version Fails (what this skill fixes)

A first attempt at this consultation used the Agent tool's subagent routing with `model: "fable"` and failed instantly ("Claude Fable 5 is currently unavailable") — that routing path was not reliable even when Fable 5 access itself was confirmed working via direct CLI. **Always invoke Fable 5 via direct CLI, not the Agent tool's model parameter**, until/unless that routing is independently reconfirmed (see Invocation below).

A second, more subtle failure mode: even a well-intentioned prompt that just describes the problem in prose gets you a plausible-sounding but *ungrounded* or *genericized* answer. The prompt structure below exists because each ingredient closed a specific gap observed in practice:

| Missing ingredient | What goes wrong without it | |---|---| | The actual GitHub URL | Fable 5's own sandboxed session may have filesystem access denied by its execution environment's own permission profile (observed directly: Read/`ls`/`grep`/`git fetch` all auto-denied in one real run) — with no repo URL, it either refuses or speculates about code it never saw. Handing it `https://github.com/yohey-w/codd-dev` up front let it self-recover by reading the real, current `origin/main` via web-accessible tools instead. | | CoDD's philosophy stated explicitly, not implied | Without explicit "generality-first: no `language ==` in shared code" and "anti-false-green: nothing may let an AI certify its own homework," a generically-smart model will still reach for the locally-obvious fix (a per-language special case, or weakening a gate) because that reads as "pragmatic" absent the stated constraint. | | "The design must stay generic" as an *explicit, named* requirement | Otherwise you get a correct-looking fix for the ONE framework/instance you showed it (e.g., "special-case ArchUnit's `.check()`") without the model ever being asked to defend that choice against the next framework that shows up. | | A concrete adversarial-case demand | Without asking for adversarial examples the design must still reject, you get a design that solves the reported case but has no evidence it preserves the anti-false-green invariant against a lightly-different attack. | | "End with ONE recommended path" | Absent this, capable models default to an evenhanded survey of options — useful for exploration, useless as an implementation ticket. | | A staged/live-verification rollout ask | Without this, the returned plan tends to be "ship everything at once" — this project's own discipline (a live dogfood rerun per increment, not just `pytest` green) needs to be requested, not assumed. |

Invocation

**Direct CLI, not the Agent tool.** Write the prompt to a scratchpad file first — a multi-paragraph prompt inlined into a shell command is an escaping nightmare — then invoke via `nohup ... & disown` so the consultation survives independently of whatever is currently killing long-running `run_in_background: true` Bash tasks in this environment (observed, unresolved root cause as of 2026-07-02 — resuming/re-launching reliably recovers regardless of cause, and a fully-detached process sidesteps the whole question).

# 1. Write the prompt (see template below) to a file.
#    Use the Write tool for this, not a heredoc in the same command.

# 2. Launch detached, capturing stdout/stderr separately:
nohup claude --print --model claude-fable-5 --effort