1 Overview
IndyDevDan rebuilds his /plan meta skill from the ground up for Fable 5 and the new Mythos class of models. This is a slow, deliberate, in-depth agentic engineering devlog — not a flashy demo. The core thesis is simple and repeated throughout: great planning is great engineering. The video walks through the entire process: starting with pen-and-paper thinking, defining properties, building a templated HTML plan format, creating five unified workflows, embedding GPT Image 2 generation, and finally running the new skill against a real task — re-implementing agent-to-agent communication using the Iroh networking protocol.
2 Why Planning Is the Most Important Skill
Dan frames the entire video around a fundamental observation: most engineers hand off their planning entirely to the model — to Claude Code, Open Code, Codex — and this is a massive mistake. It assumes the model knows what you're looking for, which it doesn't unless you tell it precisely.
He identifies this as part of the "mass deprecation of raw engineering talent" happening across the industry. Engineers are becoming too reliant on models and agents, outsourcing their thinking when they should be encoding it.
The two constraints of agentic engineering are planning and reviewing. More investment in planning directly reduces the reviewing burden. And with every new Mythos class model, this relationship becomes even stronger — better models amplify the value of better plans.
3 Start by Writing — Not Prompting
Dan does something that surprises many engineers watching: he opens a blank raw.md file and just starts typing. No agent, no framework, no parallelization scheme. Just thinking and writing about what he wants to build and why.
He creates a new directory called planf3 (Plans For Fable, three F's — FFF), opens VS Code (he's dropped Cursor entirely since they abandoned their tab completion model and went all-in on agents), and starts writing context for both himself and his future agents.
- What is Plan F3? — A brand new
/plan F3meta skill designed to capture the intelligence ceiling of Mythos class models - Why rebuild? — The Fable 5 and Mythos class models unlock a new level of planning ability, letting you specify exact outcomes if you know how to ask
- API design — Takes a user prompt and an optional
questionableflag that toggles interactive Q&A with the agent
4 The Trade-off Trifecta — Performance, Speed, Cost
Every agentic engineering decision involves trading off three things: performance, speed, and cost. Dan makes the priorities explicit:
- Performance > Speed ≥ Cost
- This new plan template trades speed and cost for optimal performance
- They're "spending to win" — not holding back on tokens
- Cost comes in the form of tokens; this approach is deliberately token-heavy
His mindset: when you're using state-of-the-art technology, make the sacrifices you need to get state-of-the-art results. That usually means sacrificing speed and cost. "We're scaling our compute to scale our impact."
5 The Agent Trifecta — Who Plans Are For
A critical framing: plans are not just for AI agents. The output of every plan is created, updated, and consumed by the agent trifecta:
- You — the engineer who needs to understand and validate the work
- Your engineering team — co-workers who need to read and collaborate
- AI agents — the models that will execute and update the plan
Many engineers over-index on just one of these audiences. Some build only for AI agents (bare markdown, no human readability). Others over-index on themselves or their team. The plan format must satisfy all three — this drives decisions like HTML-first output and embedded images.
6 Property-Based Engineering
Dan uses a methodology he calls property-based engineering: before building anything, define the specific properties (sections/capabilities) the system must have. For Plan F3:
- Embedded checklist — per-task and per-phase checkboxes that agents update live as they work
- Per-phase and per-task breakdown — structured implementation phases with nested tasks
- HTML-first output — rich visual format for the agent trifecta
- Embedded images — one focused image per phase via GPT Image 2 generation
- Toggleable Q&A section — human-in-the-loop only when the work intensity warrants it (pushing toward ZTE — Zero Touch Engineering)
- Rich updatable header metadata — created date, modified dates (list), commits (list), agent name, session ID, back references, forward references
- Validation and testing sections — closed-loop structures that prevent completion until every box is checked
- New vs. existing file sections — clear mapping of what exists and what needs to be created
- Synced HTML and image styles — consistent visual identity across the plan
- Purpose, problem, solution — classic framing with 2-8 sentence constraints
7 From V1 to V3 — Evolution of the Plan Format
Dan shows his V1 spec prompt — a format he wrote over a year ago and has used thousands of times. It's simple but proven: purpose at the top, variables (user prompt), output, instructions (bullet points), workflow (step-by-step actions), and the plan format — the templated output the agent must reproduce.
The Meta Skill Concept
This isn't an ordinary skill — it's a meta skill: a skill or prompt that creates another prompt or skill. The plan format is the engineering template that the agent mirrors every time. 80% of the V1 format hasn't changed; what's new is pushing it further for Mythos class capability.
Template vs. Free-Form
The model must do exactly two things with the plan format: (1) fill in the templated sections with real content, and (2) leave everything that's not templated where it is. This is what "templating your engineering" means — teaching the agent how you engineer.
8 HTML-First Plans
A key upgrade for the Mythos era: the plan format is now HTML-first rather than Markdown. Dan starts by writing the template structure in Markdown for clarity, then has Opus 4.8 convert it to HTML format.
Why HTML?
- More useful tokens for agents — Anthropic published research showing that giving agents more structured, valuable tokens improves output quality
- Better for the agent trifecta — opens in any browser, visually rich, easy to navigate
- Collapsible sections — metadata header becomes a
<details>element - Styled consistently — professional, minimal theme based on the original user prompt
The cost: significantly more tokens for generation. But that's a known trade-off they've accepted up front — performance over cost.
9 Five Unified Workflows
Plan F3 isn't a single-purpose skill — it's a unified planning skill with five dedicated workflows, all in one self-contained skill (no cross-dependencies):
- Create Plan — The core workflow: analyze requirements, parse user prompt, explore codebase, design solution, write HTML plan, generate images, optionally run Q&A, open in browser
- Update Plan — Modify an existing plan: update metadata fields, be surgical with changes, append to the amend section (running history of post-creation changes)
- Update References — Maintain forward and back references: when a new plan or AI doc is created, update referenced plans. All metadata except
createdis append-only comma-separated lists - Build Plan — For the agent that actually implements the plan: read the plan, absorb all images and back references (depth 1), execute phases top-to-bottom, announce each phase, update checklist status live, loop until tests pass, don't start next phase until current passes validation
- Image Generation — Two sub-workflows: create (during plan creation) and update (explicitly requested or after plan changes). Uses GPT Image 2 via an embedded UV single-file script
Task Status System
Four states for every task: idle (empty), work in progress, X (complete), F (failed). Failed tasks can be marked and moved past if truly blocked — leaning on the model's capability to identify genuine blockers.
Workflow Routing
A table in the skill's workflow section maps incoming prompts to the correct workflow file, so the agent knows which pathway to execute based on context.
10 Embedded Images & GPT Image 2
"An image is worth a thousand words — let's put that into action." Dan embeds image generation directly into the planning skill using GPT Image 2 (which he calls the best image generation model on the market for instruction following).
Image Placement Rules
- Hero image — one at the top of every plan
- Problem & solution sections — one image each
- One per phase — conveying the core architecture of that phase's work
- Optional for Q&A — if questionable mode is active
- As many as needed in notes — the free-form section where agents run free
Image Generation Guidelines
- Professional, focused on one or two primary ideas
- Text minimized — total words under 10 to avoid cluttered generations
- Wide format, high quality
- Built for professional software engineers to convey exactly what's being built
- Generated in parallel when possible
The image generation script is ~200 lines as an Astral UV single-file script, embedded directly into the skill's scripts/ directory.
11 Plans as Living Artifacts
One of the biggest conceptual jumps in Plan F3: treating plans as living artifacts in the codebase, not throwaway documents. This means:
- Plans are updated live — as the agent works through phases, it checks off tasks, updates statuses, modifies metadata
- Back references — every plan links to previous plans, AI docs, and other relevant documents
- Forward references — when future plans are created, existing plans get updated to reference them
- Amendment history — a dedicated amend section tracks all changes made after initial creation
- Agent metadata trail — agent name, session ID, commits, modification timestamps are all tracked as append-only lists
The philosophy: plans are as important as code. They live in the same repository, are version-controlled, and maintain a complete history of how and why engineering decisions were made.
The Notes Section — Letting Agents Run Free
A common critique of templated engineering is that it constrains the model. Dan's answer: include a free-form notes section where the agent can add whatever it thinks is relevant. In practice, agents use this for feature parity matrices, reference documentation, dependency docs, and architectural diagrams that don't fit the templated structure.
12 Demo — Re-implementing Agent Comms with Iroh
Dan puts Plan F3 to the test with a real engineering task. He uses the Pi Coding Agent with agent-to-agent communication (agents can prompt each other over a simple HTTP network) to plan a re-implementation of his networking layer using Iroh — a protocol that enables direct connections between applications, like "Tailscale but embedded in the application."
The Task
Replace the existing centralized HTTP hub-and-spoke agent communication with Iroh's peer-to-peer gossip swarm. The current system requires a central server (single point of failure, bound to one host). Iroh would enable decentralized, direct agent-to-agent communication with a single environment variable for configuration.
Running the Plan
Running /plan F3 with Opus 4.8 (not Fable 5, which was banned at recording time). The agent:
- Enters the create plan workflow
- Researches the entire codebase and Iroh documentation
- Spins for ~6 minutes on research and thinking
- Writes the complete HTML plan with structured phases
- Generates 8 images in parallel via GPT Image 2
The Output
The resulting HTML plan includes:
- Hero image — one-shot visual overview
- Collapsible metadata header — back references, session ID, agent name, commits, timestamps
- Purpose, problem, solution — the problem section identifies every flaw in the current HTTP architecture
- 4 implementation phases — each with a focused image, per-task checklists, and closed-loop validation ("Do not exit this phase until every box is checked")
- Feature parity matrix — automatically added in the notes section, comparing old HTTP system vs. new Iroh implementation
- Reference documentation — dependency docs, architectural notes
- Amendment section — ready for post-build changes
13 Results & Future Directions
Dan reflects on the broader implications and next steps:
Anti-Vibe-Coding Manifesto
He sees a dangerous trend: engineers not typing, not thinking, just "mindlessly prompting their agents." Many are becoming skill-atrophied — natural when technology gives and takes, but dangerous when it means outsourcing your thinking entirely. The planning constraint is where the real differentiation lives.
Future Improvements
- SVG support — for dynamic node-based diagrams that are cheaper to update than generated images
- Multimodal specs — audio and video inputs for planning context (on the "agentic horizon")
- Running on true Mythos class models — the plan is designed for models that don't exist yet; current results are 80-90% of the ceiling
Core Philosophy
"Domain knowledge is what differentiates you. Encode it into your skills, template your engineering, and stop outsourcing your thinking."
You get out of the normal distribution of results by teaching your agent how you engineer — through templated plans, specific properties, and structured workflows. One agent, one prompt, one purpose.
✦ Key Takeaways
🔑 Key Takeaways
- Great planning is great engineering — your planning skill determines result quality before any code is written; more planning investment directly reduces reviewing burden
- Don't outsource your thinking to models — most engineers hand off planning entirely, assuming the model knows what they want; this is "the mass deprecation of raw engineering talent"
- Start with writing, not prompting — open a blank document and think through what you're building and why before touching any agent or framework
- Trade-off trifecta: performance > speed ≥ cost — when building critical skills, spend tokens and time to get state-of-the-art results; scale compute to scale impact
- Build for the agent trifecta — plans serve three audiences (you, your team, AI agents); over-indexing on any one produces worse results for the other two
- Use property-based engineering — define the exact properties/capabilities your system must have before building; this doubles as a work specification
- HTML-first plans give agents more useful tokens — Anthropic research shows more structured, valuable tokens improve output quality; HTML plans are easier for everyone to consume
- Embed images via GPT Image 2 — one focused image per phase conveys architecture faster than text; minimizes words in prompts (under 10) for clean generation
- Treat plans as living artifacts in the codebase — agents update checklists, metadata, and references live; plans maintain amendment history and forward/back reference chains
- Five unified workflows in one skill — create, update, update references, build, and image generation; each with clear routing and no cross-dependencies
- Closed-loop validation per phase — agents cannot exit a phase until every task is checked and every validation command passes; failure mode (F) for genuinely blocked tasks
- Template your engineering to escape the normal distribution — encoding domain knowledge into plan templates is what produces differentiated results; this is the true competitive advantage
🔗 Resources & Links
- PlanF3 Skill (GitHub) — The /plan F3 meta skill built in this video, available for download
- Tactical Agentic Coding — IndyDevDan's agentic engineering course and methodology
- Fable 5 / Mythos 5 Announcement — Anthropic's announcement of the Mythos class models
- Iroh Documentation — The peer-to-peer networking protocol used in the demo (direct connections between applications)
- GPT Image 2 — OpenAI's image generation model used for plan images
- Pi to Pi Agent Communication — Previous video on agent-to-agent communication via HTTP