PLANS For Fable 5: Rebuilding My /Plan Skill for Mythos Class Models — IndyDevDan

Why this is in the vault

Dan does a 62-minute live rebuild of his /plan meta skill — the prompt/template that controls what his agents produce as implementation plans — specifically upgraded for Fable 5 and Mythos-class model capabilities. This is directly actionable for Ray: Ray uses Claude Code with custom /plan skills and phData work demands planning-quality output from Claude that scales as Anthropic releases stronger models. The video provides a concrete, transferable SKILL.md structure (planF3) with the exact template format, workflow split, HTML-first output design, and image-generation integration. Dan's "planning is engineering" thesis also validates the architectural direction of RDCO's harness-engineering work.

Episode summary

Dan live-codes the planF3 (Plans for Fable 5) meta skill from scratch — a planning prompt that creates other prompts/plans. He starts with 30 minutes of manual writing/thinking before touching an agent, demonstrating his core thesis that upfront thinking is the highest-leverage engineering act. The final skill: a unified SKILL.md with five dedicated workflows (create-plan, update-plan, update-references, build-plan, image-generation), HTML-first plan output with embedded diagrams via ChatGPT Image 2, collapsible header metadata tracking agent sessions and commit hashes, and a per-phase embedded checklist pattern. The plan becomes a living artifact — agents update it in-place as they work through phases. Dan explicitly sacrifices speed and cost for performance, positions this as "spending to win" against Mythos-class capability.

Key arguments / segments

[00:00:10] Open thesis: most engineers outsource planning to the model — this is the "mass deprecation of raw engineering talent." Great planning is great engineering; the plan skill is the highest-ROI tool in an agentic engineer's stack.

frame-000010

[00:03:13] Dan writes raw.md by hand before spinning up any agent — just markdown stream-of-consciousness on what planF3 should do, why, and for whom. "Write first, agent second" is the pattern. This serves as priming context for both himself and any future agents that read the repo.

frame-000313

[00:05:00] The trade-off trifecta: performance vs. speed vs. cost. planF3 explicitly prioritizes performance > speed ≥ cost. New Mythos-class models unlock this — you can spend tokens to get plans that are so precise they reduce reviewing work substantially.
[00:07:00] Audience trifecta for the plan artifact: the engineer (you), the engineering team (collaborators), and AI agents. Most engineers over-index on one — the plan must serve all three simultaneously. This drives HTML-first output (readable by humans and parseable by agents).
[00:10:00] Property-based engineering: define the properties (sections/capabilities) you want in the output before writing the skill. Properties identified for planF3: embedded checklist per task/phase, rich updatable header metadata (created/modified/commits/agent name/session ID/back-references/forward-references), questions-and-answers section (togglable, ZTE-biased toward off), new-vs-existing file sections, synced HTML and image styles, validation commands per phase, focused embedded images.
[00:16:42] Writing the plan template structure in markdown first, then having an agent (Opus 4.8 on Claude Code, high-effort mode) convert it to HTML. The HTML template is what planF3 will output — not raw markdown.

frame-001642

[00:17:14] Per-phase structure: each phase gets a name, step-by-step tasks with embedded checkboxes, a testing strategy section, and specific validation commands. This creates a closed-loop structure — the agent cannot declare a phase complete without running validation commands.

frame-001714

[00:19:23] "Surgical prompt" discipline enforced against the agent: when the agent adds unrequested styling blocks, Dan immediately tells it "remove the styling section completely" and "all future prompts, be surgical — do only what was asked." Clear illustration of staying in the loop as the plan evolves.

frame-001923

[00:22:00] Five dedicated workflow files: create-plan, update-plan, update-references, build-plan, image-generation. Each workflow is a separate file inside a workflows/ directory in the skill. The skill SKILL.md has a routing table (markdown table) that maps incoming user prompt context to the correct workflow file.
[00:28:00] Image generation integration via ChatGPT Image 2 — a 200-line Astral UV single-file Python script dragged directly into the scripts/ directory inside the skill. Plans include generated images per section to "give the agent the ability to be absolutely clear on what's getting built." Image prompt constraint: under 10 words in the image, single or two primary ideas, professional software-engineer audience.
[00:35:00] Living artifact pattern: the plan document is created once and then updated by agents as they work through phases — checking off tasks, adding commit references, updating the modified list. The header metadata tracks every session that touched the plan.
[00:48:33] Full demo run: planF3 skill invoked with a real user prompt, generating a complete HTML plan with embedded images, per-phase checklists, and validation commands. Shows the complete end-to-end output.

frame-004833

[00:50:05] Discussion of the questionable variable — an optional flag that triggers an interactive Q&A session between the agent and the engineer before planning begins. Default is false (ZTE-biased), but enables human-in-the-loop for complex or ambiguous requirements.

frame-005005

[00:51:11] Skill is designed to be self-contained — no cross-dependencies on other skills. Everything needed to create, update, build against, and generate images for a plan lives inside the planF3 directory. Portability is a first-class property.

frame-005111

[00:51:42] Dan packages the skill for public release at https://github.com/disler/planf3 — explicitly designed to be cloned and used immediately with any Claude Code installation.

frame-005142

[01:01:11] Closing philosophy: "The future is built by those who PLAN it, not those who vibe code it." Dan positions planning skill as the primary differentiation between engineers who control agentic outcomes and those who hope for them.

frame-010111

[01:01:48] Call to action to clone planF3 from GitHub; encourages engineers to fork and adapt the template to their own codebase patterns.

frame-010148

Notable claims

"Great planning is great engineering" — repeated 10+ times as the central thesis; not hyperbole, it is the organizing principle of the entire video.
Mythos-class models (Fable 5 and above) unlock a new level of planning accuracy that was not achievable with prior model tiers — specifically the ability to follow highly complex, multi-section HTML templates reliably.
Per-model stacking: Opus 4.8 is the right model for meta-skill/planning work (high complexity, one-time cost); Fable 5 is the orchestrator once available; Sonnet handles routine execution steps.
The questionable pattern (optional human-in-the-loop Q&A before execution) is specifically toggled off by default to preserve ZTE — but the toggle itself is a key design feature for complex/novel projects.
Plans should track their own provenance: which agent sessions modified them, which commits they reference, which future plans reference back. This is metadata infrastructure, not polish.
ChatGPT Image 2 named as the best image generation model for precise technical diagrams — not Midjourney, not Stable Diffusion, not Flux.

Mapping against Ray Data Co

Relevance: strong

Ray actively maintains custom skills under ~/.claude/skills/ and uses Claude Code as his primary agentic engineering environment. The planF3 skill architecture is directly portable:

Immediate action — clone and adapt planF3: The skill is public at https://github.com/disler/planf3. Ray should clone it and adapt the plan template to RDCO and phData project patterns (Snowflake, dbt, Claude API, data pipelines). The five-workflow structure (create / update / update-references / build / image-generation) maps cleanly to RDCO's existing skill pattern.
HTML-first plan output: RDCO's current plan outputs are markdown. Upgrading to HTML-first gives Ray richer plan artifacts that render as internal deliverables for phData clients — a non-trivial upgrade for Deal Solutions Architect work where "the plan IS the deliverable" in discovery/scoping engagements.
Living artifact pattern: The update-references workflow (keeping back-references and forward-references current as the codebase evolves) directly addresses a gap in RDCO's vault: plans become stale because they're never updated after creation. Making plans living artifacts that agents maintain changes this.
Validation commands per phase: RDCO sub-agent dispatches currently rely on implementation-notes files to track decisions, but lack built-in validation gates per phase. The planF3 closed-loop pattern (each phase has explicit validation commands before marking complete) would reduce the "sub-agent declared completion but output was wrong" failure mode.
phData DSA relevance: In discovery/scoping engagements, Ray's RACI has Responsibility on scoping and handoff. A Fable-5-calibrated plan template gives Ray a structured artifact that (a) demonstrates engineering rigor to technical stakeholders, (b) can be handed off to implementation teams with clear per-phase instructions, and (c) tracks its own history via header metadata.
Image generation in plans: Ray has not been embedding images in plan artifacts. The ChatGPT Image 2 integration for focused technical diagrams (under 10 words, single idea) is worth adopting — particularly for phData architecture plans where a visual of the data flow or agent topology communicates faster than prose.

One caution: Dan's "write by hand for 30 minutes before touching an agent" norm runs against the current RDCO pattern of rapid skill-dispatch. For planning critical infrastructure (new client engagement, RDCO system architecture, phData delivery architecture), the pre-agent writing discipline is worth the time cost.