08-tooling

fable5 workflow optimization memo

2026-06-09·research-memo·source: 3-lane verified research workflow + Ethan Mollick datapoint
fable5claude-codeworkflowharness

Fable 5 + Claude Code Workflow Memo — for RDCO's COO Agent

Why this is in the vault

RDCO upgraded to Fable 5 on 2026-06-09 — the same day as this memo. This is the authoritative decision record for how the Fable 5 wave maps onto the existing COO-agent harness: what to adopt, what to skip, and why. Grounded adversarially against the live harness manifest (15 jobs), not against X-thread slop. The ranked recommendations (sections 4-5) are the operational call list; section 3b on native orchestration vs explicit dispatch closes the most-asked design question for the harness going forward.

2026-06-09 ~17:44 ET. Grounded against the live harness: scheduled-jobs.txt (15 jobs), ray-handoff.md, and today's 2026-06-09-fable5-harness-review.md. Practices held under adversarial verification; citation/pricing errors in the source briefs corrected inline. Merged 2026-06-09 with a founder-supplied practitioner datapoint (Ethan Mollick hands-on report) — see sections 1b and 3b.

1. The signal vs the noise

The X "loops and state machines" wave is ~70% real mechanism, ~30% repackaged slop. The durable signal, now officially documented in Anthropic's Fable 5 prompting guide, is one mental model: invest in the harness (loops, fresh-context verifiers, distilled memory), not one-off prompts — Boris Cherny's "my job is to write loops." That genuinely transfers to a cron-driven COO agent because Anthropic explicitly blesses the exact pattern (check long runs async via scheduled jobs, fresh-context verifier subagents, markdown memory). The slop is the copy-paste "5-day build plan" listicles (Alpha Batcher and clones, sub-1k impressions) that reconstruct a public Boris/Cat Wu video into a checklist with zero added testable detail — down-rank on sight. The one thing to resist as cargo-cult: importing code-shaped state machines (test-suite verifiers, git-tag done-signals, Ralph-style greenfield loops) wholesale into a COO agent whose outputs (newsletter voice, vault notes, paper-trade theses) have no objective pass/fail oracle. You already have the right primitives; the work is surgical mapping, not rebuilding.

1b. The practitioner view (Ethan Mollick)

Mollick's hands-on report (oneusefulthing.org, fetched 2026-06-09; credible-practitioner tier, mild Anthropic-positive bias) reframes the shift in one line: "I no longer steer; I commission." The human role moves from steering each step to briefing at a high level and signing off on finished work. He compares Fable to "a whole studio, where I am the client who signs off on the final work without ever setting foot on the floor" — the model makes hundreds of invisible intermediate decisions, spins up its own sub-agents to research/build/verify, and returns a completed artifact. His unnerving summary: "I just asked for something and it happened."

The practices that made this work are deliberately the opposite of decomposition. Start ambitious and vague (his isochrone-map and a 9.5-hour research-tool build each began from one high-level sentence) and let the model fill the execution gap. Minimal mid-run steering — "make it better" was often enough. Let the model write its own spec first (it generated a 19-page design doc before coding). Give it the big task, not pre-cut subtasks; decomposition happens internally and in parallel (research sub-agents running while it codes). The strengths he saw: multi-domain synthesis, software architecture, sustained 9+ hour autonomous builds.

The cautions are the honest counterweight, and the most load-bearing one corroborates this memo's own findings (see section 3b). Cost: roughly 2x Opus, burning tokens aggressively in bursts — budget a correction cycle (his expert-review + follow-up pass "consumed a tremendous number of tokens in a very short period"). Opacity: "the black box is the price of the power" — you validate outputs, not process; the decision trail is "too long to even be worth following." Guardrail over-triggering: he reports Fable falling back to Claude 4.8 Opus "way too often," which we should treat as a production risk, not a curiosity. And the jagged frontier persists — expert validation is still required post-output (his map had errors; the paper needed major revision), and generated code/docs carry "Claudisms" needing an editorial pass.

2. What we already do right

Cross-referenced against the manifest and today's audit — not taking credit for anything unbuilt:

3. The loops & state-machine question, answered for OUR setup

We have four orchestration primitives. Mapping "state machine" advice onto each:

Primitive What it is "State machine" advice maps to... Verdict
Cron loops (CronCreate via manifest) Time-triggered fan-out The outer scheduler. Already the blessed async-check pattern. Keep as-is
Dynamic /loop (self-paced) Model decides when to re-fire The "let the model execute the loop" half. Good for poll-until-done. Keep, use sparingly
Workflow tool (JS pipeline/parallel) Deterministic multi-agent DAG THIS is the actual state machine. Explicit nodes, ordered, parallelizable. Adopt more deliberately
Notion board Durable cross-session queue The persistent state store between loop iterations. Keep as-is

Conclusion: PARTIAL adopt. The "explicit state machine" advice the community pushes is the Workflow tool, and we already own it — the gap is using it more deliberately for the few skills that are genuinely multi-stage (the 12-stage production workflow, pipeline-* seats), not bolting a new framework on. The genuinely portable new idea from the single-source tier is the external done-condition file (write testable completion criteria before the agent starts, "so the agent can't quietly redefine done mid-run") — but for a COO agent this only bites where "done" is mechanically demonstrable in-transcript (queue empty, file count, git clean). For soft outputs, the real grader is already our /verify-* fresh-eyes subagents. Skip code-shaped state machines (git-tag done-signals, test-suite backpressure) for non-code skills, and skip any Ralph-style autonomous loop (Huntley: greenfield-only, "no way in heck in an existing codebase").

3b. Does Fable's internal orchestration change our subagent strategy?

Mollick's report raises a sharp design question this memo has to answer directly. Fable autonomously spawns its own cheaper Claude Sonnet sub-agents to parallelize and adversarially verify its own work — unprompted. The operator did not configure it; the model decided. So when our harness explicitly dispatches Workflow/Agent fan-outs (the pipeline-* seats, process-newsletter's subagent-per-article, the /verify-* critics), are we partly duplicating what the model now does natively — and if so, what do we actually GAIN by doing it explicitly?

The honest answer: we are duplicating the capability, but we are buying three things the native orchestration cannot give us, and they are exactly the three things a COO agent on an always-on budget needs.

Conclusion: keep explicit orchestration for anything we need to audit or cost-cap — every soft-output skill, every channel-replying skill, every financial-execution path. Let Fable run internally-orchestrated only for self-contained, one-shot builds where we validate the output, not the process (a single isolated artifact with a clear pass/fail oracle and no downstream trust dependency). The native orchestration is a feature for the right shape of task, not a replacement for our harness.

Action: run an A/B test on one real skill. Pick a self-contained build (deep-research on a single bounded question is the natural candidate) and run it two ways — (A) our explicit tiered Workflow/subagent dispatch, vs (B) one high-level commission to Fable letting it orchestrate internally — then compare on auditability, output quality, wall-clock, and token cost. That single experiment converts this from reasoning to a measured policy.

4. Ranked recommendations

Ranked by value/effort. Each names a file/skill/cron. Confidence reflects evidence strength after adversarial correction.

HIGHEST-CONFIDENCE "FIX NOW" — now multi-source corroborated. Recommendation #2's silent-Opus-fallback finding is no longer single-source. This workflow independently found that reasoning-echo / "show your reasoning as response text" phrasing in skills can trigger a reasoning_extraction refusal that silently falls back to Opus 4.8. Ethan Mollick independently reports guardrails causing Fable to "fall back to Claude 4.8 Opus way too often." Two independent sources, one from vendor docs and one from hands-on practice, point at the same failure mode — upgrade this from single-source to multi-source-corroborated and treat it as the first thing to fix. Audit action: grep our skills for reasoning-echo phrasing (e.g. rg -i "show your reasoning|echo your reasoning|transcribe your reasoning|explain your reasoning as" ~/.claude/skills/), then strip or rephrase any hit so it cannot trip the refusal.

NEW — beyond today's audit

# Change Why (mechanism) Effort Conf Net effect
1 Add a between-job /clear (or fresh session per job) to the cron harness. Today's audit cut open-threads frequency; it did NOT address that context carried across distinct cron jobs is re-written at the cache-write premium ($12.50/MTok on Fable), because the 5-min cache TTL has expired by the time the next job fires minutes-to-hours later. Cron jobs are spaced wider than the cache TTL, so a fat carried prefix is paid as a full cache write, not a cheap read, every job. /clear between unrelated jobs avoids rebuilding stale context at write premium. Anthropic docs: "Stale context wastes tokens on every subsequent message." S High Direct $ cut on every cron fire; compounds with the open-threads fix
2 Audit ~/.claude/skills/ for over-prescription and show-your-reasoning phrasing, skill-by-skill, low-blast-radius first. Fable's prompting guide: skills written for older models are "often too prescriptive" and degrade Fable output; instructions to "echo/transcribe/explain your reasoning as response text" can trigger a reasoning_extraction refusal that silently falls back to Opus 4.8. MULTI-SOURCE-CORROBORATED: Mollick independently reports Fable guardrails causing fallback to "Claude 4.8 Opus way too often" — two independent sources on the same silent-downgrade failure mode. This is the highest-confidence fix-now item; grep skills for reasoning-echo phrasing as the concrete audit step. Two failure modes the audit didn't name: quality degradation from enumerated checklists, and silent model downgrade from reasoning-echo phrasing. Test default-vs-scaffolded per skill; keep simpler only if genuinely as good. M High (↑ multi-source) Quality + cost (kills silent Opus fallback); per-skill, reversible
3 Use context: fork (NOT fork:true) on the heavy read-only ingestion skills first: process-newsletter, process-youtube, deep-research. fork:true is Boris's informal tweet shorthand and would be ignored; the shipped/documented field is context: fork + agent: general-purpose. Forking isolates the skill's heavy churn (newsletter HTML, transcripts, web fetches) from parent context — generalizes our existing subagent-per-article pattern. Real payoff at Fable's 2x input. M Med Context-rot + $ savings on the read-heavy skills
4 Do NOT fork the channel/rule-dependent skills (morning-prep, check-board) the same way; split analyze-vs-reply. A forked skill still re-loads CLAUDE.md unless agent type is Explore/Plan (which strip the hard rules those skills need); context: fork returns only a summary and can't see the inbound channel context the reply requires. Caveat the source brief flags as load-bearing for us: fork the heavy analysis, keep the final channel-reply decision in the parent which holds the chat_id + hard rules (run date, reply-via-tool). S High Prevents a fork from breaking hard-rule channel replies
5 Close the sql-guardrail snow CLI gap (audit Config finding #9): add a PreToolUse Bash(*snow *) matcher → sql-guardrail.sh. The script already covers snow internally; the hook only invokes on snowsql/duckdb/psql. The modern Snowflake CLI — the tool most relevant to the #1 phData cert bet — currently bypasses the destructive-SQL guardrail entirely. S High Safety gap on the primary bet's toolchain

REINFORCES today's audit (do, but already directionally captured)

# Change Why Effort Conf Net effect
6 Ship the subagent model-tiering policy the audit drafted (haiku for extraction, sonnet for pipeline/critic, Fable for judgment). Add the config caveat the audit understates: a subagent with no model: field defaults to inherit — every unconfigured subagent silently runs Fable. (Mollick corroboration: Fable's own internal sub-agents default to cheaper Sonnet unprompted — the model already tiers down natively, which sharpens the case for pinning our explicit seats deliberately rather than letting them inherit Fable.) Pre-Fable skills have no model: pin, so the lever does nothing until they're explicitly set. The real cost driver is verbose output + cache, so Haiku helps doubly (10x cheaper output, generates less). M High Biggest standing $ lever; audit-aligned, needs the inherit-audit added
7 Pin routine cron skills to low/medium effort; keep high for strategic skills (deep-research, investing theses, /verify-strategic-output). Official: "Lower effort on Fable 5 still performs well and often exceeds xhigh on prior models." Effort is the throttle; thinking bills as output (the dominant cost). S High $ on routine fan-out; reinforces audit's effort note
8 Wire the pre-send verification gate (verify-action PreToolUse hook) the audit flagged as the highest-value open build. feedback_calibrate_overconfidence concludes memory bullets failed to stop fabrication and twice demands this hook; the model swap resets behavioral priors. Note: a verifier prompted to find gaps over-reports, so scope to channel replies / required-tier writes, not blanket. M High Closes the fabrication failure mode; audit-aligned

Correction to bank before codifying anything: the input-price premium vs Opus 4.8 is ~2x flat, not ~2.5x. Fable 5 and Opus 4.8 share the same tokenizer (introduced at Opus 4.7); the ~35% inflation already happened and is baked into the 4.8 baseline. Don't double-count it. Mollick's hands-on "roughly 2x Opus" estimate independently lands on the same multiple. Context discipline still has real money consequences — just state the multiple honestly.

5. Explicitly skip

6. Sources

Primary (high authority):

Credible practitioners (original testable detail):

Slop patterns to ignore:

Key files referenced: ~/.claude/scripts/scheduled-jobs.txt, ~/.claude/state/ray-handoff.md, ~/rdco-vault/08-tooling/2026-06-09-fable5-harness-review.md, ~/.claude/settings.json (sql-guardrail at :187-199, model pin :252).

Related