// claude skills · craigm26 · 2026
12 Claude skills for Fable 5 orchestration, founder workflows, and craft — all 12 installable today via the founder-skills plugin marketplace. Skills sit above Anthropic's execution primitives — workflows, subagents, structured questions — encoding when to use them, which model to route to, and how to structure the work.
Token efficiency. A 30-second calibration at session start — effort tier, domain, what done looks like — governs how millions of downstream tokens get spent. Wrong-direction work and wrong-model routing are the two most expensive failure modes of an agentic session, and both are cheapest to prevent before the first tool call. The judgment layer spends a few hundred tokens to make that decision explicit.
Fable 5 is a leap in intuition. A model that can genuinely judge when to plan, what to route where, and how much effort a task deserves makes a calibration layer worth building. These skills give that intuition a structured place to act — explicit, inspectable, and reusable — instead of leaving it implicit and unrepeatable inside each session.
The primitives underneath are Anthropic's — start with the official docs: Skills · Subagents · Agent SDK · Interactive mode · Models overview
Stop losing the first hour to wrong-direction work. Three AskUserQuestion prompts before anything starts — effort tier, domain, what "done" looks like — then it loads memory from prior sessions and routes you to the right skill chain. The universal entry point for any Fable 5 session.
Make your token budget a decision instead of an accident. One question sets Opus 4.8 / Sonnet 4.6 routing for the entire session — with an external-executor fallback when tokens run low — and maps onto the API's effort levels and Task Budgets when you need per-request control. Call mid-session to downgrade.
Ship features to spec, not to vibes. Fable writes a detailed plan file, a capable model (Opus 4.8 / Sonnet 4.6) implements it exactly, Fable reviews against the spec. The plan's acceptance criteria double as a Managed Agents Outcome rubric for unattended hosted runs. Fable never writes implementation code.
Know exactly what you're walking into before a refactor, an onboarding, or a deal. 4-phase principal-level audit: discovery → severity-rated findings grounded in file:line evidence → strategy → milestone task plan. Refusal-aware on security-adjacent code (Fable 5's classifiers can false-positive — the audit reports it, never silently skips).
Catch silent customer-integration failures before the demo, not during it. Probes your platform's real APIs across 8 dimensions, grades each 🟢 🟡 🔴 ⚫, produces a prioritized gap list — and runs itself weekly via /schedule routines or CMA scheduled deployments, getting smarter each run through memory. Built against a specific stack (PlatAtlas); the pattern is portable.
Your agent stops at "done", not "good enough". Rubric-graded self-correction loops with an independent verifier sub-agent — Anthropic's documented best practice ("verifier sub-agents tend to outperform self-critique") — built on /goal, /loop, and Managed Agents Outcomes. Cross-session memory progression: fail → investigate → verify → distill → consult.
5-phase market research workflow: scope the question → fan-out verified web research → synthesize into deck data → Tufte HTML/PDF visualization → emit a brief. ~1.5M tokens per full run. Adversarially verified claims.
Judge panel: generate N independent build approaches → score each → stress-test assumptions → weighted decision matrix. Math single-sourced in tested weighting.py. Produces a winner with clear trade-off documentation for the PRD handoff.
Generate a Product Requirements Document from validated market data and the chosen build option. Structured with objective, scope, acceptance criteria, out-of-scope items, and open questions. Feeds into /tasks.
Your plan executes without you in the loop. Breaks a PRD into ordered tasks where every acceptance criterion is a boolean check an agent can verify alone — which means the criteria export directly as a Managed Agents Outcome rubric. The handoff from planning to autonomous building.
Ideate and critique data visualizations using Edward Tufte's principles. Includes 4 working HTML demo files (GISS temperature, Kyoto sakura, sunspot butterfly, sunspot pretty) and reference docs on analytical design. Use before building any chart or dashboard.
Plan and sequence improvements across a multi-repo software ecosystem. Bake lessons into upstream tooling, gate on human-in-the-loop (HIL) approval, manage bring-up self-tests. Built from a real multi-repo robotics bring-up; the planning pattern is portable.
# In any Claude Code session /plugin marketplace add craigm26/founder-skills
# All 12, one loop for s in session-start effort market-validation \ build-options prd tasks fable-orchestrated-feature-dev \ fable-repo-audit fable-org-audit fable-loop-design \ tufte-viz ecosystem-planning; do /plugin install ${s}@founder-skills done
# Start every session with the calibrators /session-start /effort # Then the chain, as the work demands /market-validation /build-options # And the orchestration layer when the work demands it /fable-repo-audit /fable-orchestrated-feature-dev
All twelve ship as Claude Code plugins via the plugin marketplace — one command to add, one per skill to install. The model reads the skill's SKILL.md on invocation and follows it for the remainder of the session.
Skills are session context, not persistent rules. Invoke a skill at the start of a session when you need it — only the ones relevant to the work at hand.
Per-skill walkthroughs (what each asks, what it produces, what it costs) live on the founder-skills site.
/market-validation → /build-options → /prd → /tasks) is designed to run sequentially across sessions. Each skill's output is the next skill's input — save the artifacts between sessions.
# Fetch a public skill straight from GitHub $ curl -s https://raw.githubusercontent.com/craigm26/\ founder-skills/master/plugins/session-start/SKILL.md
Claude Desktop Settings → Custom Instructions (or System Prompt) Paste the full SKILL.md content there. Or use it as a conversation starter: "Here is a skill I want you to follow: [paste SKILL.md content] Now help me audit this repository."
Claude Desktop doesn't have native slash-command skill loading. Instead, paste a skill's SKILL.md content into your system prompt or custom instructions field.
Best skills for always-on Desktop instructions:
/session-start — paste this as a persistent instruction so every new conversation opens with the three calibration questions. Works on any surface.
/effort — add alongside session-start so the model always asks about token budget before spending any. Lightweight and universally useful.
/fable-loop-design — if you design agentic systems, this as a persistent instruction keeps the verifier sub-agent pattern and memory progression top of mind across all conversations.
/tufte-viz — works well as a persistent instruction if you frequently discuss data visualization. The principles apply whether you're sketching charts or critiquing dashboards.
fable-repo-audit, fable-orchestrated-feature-dev) are less useful in Desktop because they rely on file system access (saving reports to ~/.claude/audits/, passing plan file paths). Use Claude Code CLI for those.
// Node.js / TypeScript import Anthropic from '@anthropic-ai/sdk' const skill = await (await fetch( 'https://raw.githubusercontent.com/craigm26/founder-skills' + '/master/plugins/session-start/SKILL.md' )).text() const client = new Anthropic() const msg = await client.messages.create({ model: 'claude-fable-5', max_tokens: 8192, system: skill, messages: [{ role: 'user', content: 'Start the session.' }] })
Skills are plain markdown — load any SKILL.md as a string and pass it as the system prompt in your API call. The model treats it as its operating instructions for the session.
For multi-agent pipelines: use /fable-loop-design to design the loop structure, then hard-code the rubric and verifier pattern directly in your Agent() calls rather than loading the skill at runtime — the skill is a design guide, not a runtime dependency.
The fable-orchestrated-feature-dev skill's model routing logic (Opus vs Sonnet vs an external executor, based on token budget) is useful for building your own adaptive pipelines — the same routing tiers are documented in the effort skill.
market-validation, build-options) include Python and JavaScript helper scripts in their assets/ subdirectories — these run standalone outside the API and produce structured outputs (deck-data.json, decision matrices) that feed into subsequent API calls.
Before any work begins: three structured questions establish effort tier, goal, and skill routing. Surfaces pending memory from prior sessions. Prevents an hour of wrong-direction work in 30 seconds.
You have a hypothesis but no validated market data. Run the full founder chain: research the market, score your build options against each other, write the PRD, break it into tasks.
You know what to build but the implementation spans many files and you want a spec before touching code. Fable writes the plan, Opus or Sonnet implements it, Fable reviews the output against the spec.
You need an honest, evidence-based assessment before you start changing things. Get a graded audit with severity-rated findings, an improvement strategy, and a milestone-based task plan.
You want Fable to hillclimb on a task using a rubric rather than steering it step-by-step. Design the self-correction loop with a verifier sub-agent. The grader runs in a separate context window so it can't rationalize its prior attempt.
You want Claude to get smarter across sessions rather than re-deriving the same conclusions. Use the memory progression: fail → investigate → verify → distill → consult. Distilled rules go to memory.md; raw failure notes stay in failures.md.
You want to communicate data clearly without chartjunk. Apply Tufte's principles before writing any chart code. Use the 4 demo HTML files (sunspot butterfly, Kyoto sakura flowering, GISS temperature) as calibration examples.
You have lessons from one repo that should be baked upstream into a library or CLI. Plan the sequencing across repos, define HIL gates, and write a self-test that validates the improvement end-to-end.
The fable-orchestrated-feature-dev skill has built-in token routing. It reads budget signals from context and routes implementation to Sonnet 4.6 when you're cost-conscious, or hands the plan file to an external executor when tokens are exhausted.
All twelve install in one command each via the Claude Code plugin marketplace — plain markdown skills, no dependencies.
Install via marketplace →